TRON Energy API

import hashlib
import hmac
import json
import requests

API_ID = 1
API_KEY = "AA85A2111B4E76R3E181160EB23E51851D48403A756134E7D0CF845406ABFBA9"

data = {
    'quantity': 65000,
    'period': 1,
    'receiver': 'TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
    'callback_url': 'https://domain.name/callback',
    'outter_id': 'your order id',
}

json_data = json.dumps(data, sort_keys=True, separators=(',', ':'))

signature = hmac.new(
    API_KEY.encode(),
    json_data.encode(),
    hashlib.sha256
).hexdigest()

headers = {
    'Content-Type': 'application/json',
    'X-API-ID': str(API_ID),
    'SIGNATURE': signature,
}

response = requests.post("https://energy.store/api/createOrder", data=json_data, headers=headers)
print(response.json())

const axios = require('axios');
const crypto = require('crypto');

const API_ID = 1;
const API_KEY = "AA85A2111B4E76R3E181160EB23E51851D48403A756134E7D0CF845406ABFBA9";

const data = {
    quantity: 65000,
    period: 1,
    receiver: 'TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
    callback_url: 'https://domain.name/callback',
    outter_id: 'your order id'
};

const jsonData = JSON.stringify(data);

const signature = crypto
    .createHmac('sha256', API_KEY)
    .update(jsonData)
    .digest('hex');

const headers = {
    'Content-Type': 'application/json',
    'X-API-ID': API_ID,
    'SIGNATURE': signature
};

axios.post('https://energy.store/api/createOrder', jsonData, { headers })
    .then(response => {
        console.log('Response:', response.data);
    })
    .catch(error => {
        console.error('Error:', error.response ? error.response.data : error.message);
    });

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

class Program
{
    static async Task Main()
    {
        int API_ID = 1;
        string API_KEY = "AA85A2111B4E76R3E181160EB23E51851D48403A756134E7D0CF845406ABFBA9";

        var data = new
        {
            quantity = 65000,
            period = 1,
            receiver = "TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
            callback_url = "https://domain.name/callback",
            outter_id = "your order id"
        };

        var jsonData = JsonSerializer.Serialize(data);

        var keyBytes = Encoding.UTF8.GetBytes(API_KEY);
        var messageBytes = Encoding.UTF8.GetBytes(jsonData);

        using var hmac = new HMACSHA256(keyBytes);
        var hashBytes = hmac.ComputeHash(messageBytes);
        var signature = BitConverter.ToString(hashBytes).Replace("-", "").ToLower();

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("X-API-ID", API_ID.ToString());
        client.DefaultRequestHeaders.Add("SIGNATURE", signature);

        var content = new StringContent(jsonData, Encoding.UTF8, "application/json");
        var response = await client.PostAsync("https://energy.store/api/createOrder", content);

        var responseContent = await response.Content.ReadAsStringAsync();
        Console.WriteLine(responseContent);
    }
}

package main

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    apiID := 1
    apiKey := "AA85A2111B4E76R3E181160EB23E51851D48403A756134E7D0CF845406ABFBA9"

    data := map[string]interface{}{
        "quantity":     65000,
        "period":       1,
        "receiver":     "TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
        "callback_url": "https://domain.name/callback",
        "outter_id":    "your order id",
    }

    jsonData, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    h := hmac.New(sha256.New, []byte(apiKey))
    h.Write(jsonData)
    signature := hex.EncodeToString(h.Sum(nil))

    req, err := http.NewRequest("POST", "https://energy.store/api/createOrder", bytes.NewBuffer(jsonData))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-API-ID", fmt.Sprintf("%d", apiID))
    req.Header.Set("SIGNATURE", signature)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

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

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

import com.fasterxml.jackson.databind.ObjectMapper;

public class EnergyStoreApiExample {
    public static void main(String[] args) throws Exception {
        int API_ID = 1;
        String API_KEY = "AA85A2111B4E76R3E181160EB23E51851D48403A756134E7D0CF845406ABFBA9";

        Map data = new HashMap<>();
        data.put("quantity", 65000);
        data.put("period", 1);
        data.put("receiver", "TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
        data.put("callback_url", "https://domain.name/callback");
        data.put("outter_id", "your order id");

        ObjectMapper mapper = new ObjectMapper();
        String jsonData = mapper.writeValueAsString(data);

        String signature = calculateHMAC(API_KEY, jsonData);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://energy.store/api/createOrder"))
                .header("Content-Type", "application/json")
                .header("X-API-ID", String.valueOf(API_ID))
                .header("SIGNATURE", signature)
                .POST(HttpRequest.BodyPublishers.ofString(jsonData))
                .build();

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

    private static String calculateHMAC(String key, String data) throws NoSuchAlgorithmException, InvalidKeyException {
        Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
        SecretKeySpec secret_key = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
        sha256_HMAC.init(secret_key);

        byte[] hash = sha256_HMAC.doFinal(data.getBytes(StandardCharsets.UTF_8));
        StringBuilder hexString = new StringBuilder();
        for (byte b : hash) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) hexString.append('0');
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import java.security.MessageDigest
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec

fun main() {
    val API_ID = 1
    val API_KEY = "AA85A2111B4E76R3E181160EB23E51851D48403A756134E7D0CF845406ABFBA9"

    val data = JSONObject().apply {
        put("quantity", 65000)
        put("period", 1)
        put("receiver", "TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
        put("callback_url", "https://domain.name/callback")
        put("outter_id", "your order id")
    }

    val jsonData = data.toString()

    val signature = calculateHMAC(API_KEY, jsonData)

    val client = OkHttpClient()

    val mediaType = "application/json; charset=utf-8".toMediaType()
    val body = jsonData.toRequestBody(mediaType)

    val request = Request.Builder()
        .url("https://energy.store/api/createOrder")
        .addHeader("Content-Type", "application/json")
        .addHeader("X-API-ID", API_ID.toString())
        .addHeader("SIGNATURE", signature)
        .post(body)
        .build()

    client.newCall(request).execute().use { response ->
        println(response.body?.string())
    }
}

fun calculateHMAC(key: String, data: String): String {
    val secretKeySpec = SecretKeySpec(key.toByteArray(), "HmacSHA256")
    val mac = Mac.getInstance("HmacSHA256")
    mac.init(secretKeySpec)

    val hmacBytes = mac.doFinal(data.toByteArray())
    return hmacBytes.joinToString("") { "%02x".format(it) }
}

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

API_ID = 1
API_KEY = "AA85A2111B4E76R3E181160EB23E51851D48403A756134E7D0CF845406ABFBA9"

data = {
  quantity: 65000,
  period: 1,
  receiver: 'TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
  callback_url: 'https://domain.name/callback',
  outter_id: 'your order id'
}

sorted_data = data.sort.to_h
json_data = sorted_data.to_json

digest = OpenSSL::Digest.new('sha256')
signature = OpenSSL::HMAC.hexdigest(digest, API_KEY, json_data)

uri = URI.parse('https://energy.store/api/createOrder')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true if uri.scheme == 'https'

request = Net::HTTP::Post.new(uri.path)
request['Content-Type'] = 'application/json'
request['X-API-ID'] = API_ID.to_s
request['SIGNATURE'] = signature
request.body = json_data

response = http.request(request)
puts response.body

use hmac::{Hmac, Mac};
use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
use serde::{Deserialize, Serialize};
use sha2::Sha256;
use std::error::Error;

type HmacSha256 = Hmac;

#[derive(Serialize, Deserialize)]
struct OrderRequest {
    quantity: u32,
    period: u32,
    receiver: String,
    callback_url: String,
    outter_id: String,
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    let api_id = 1;
    let api_key = "AA85A2111B4E76R3E181160EB23E51851D48403A756134E7D0CF845406ABFBA9";

    let order_data = OrderRequest {
        quantity: 65000,
        period: 1,
        receiver: "TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX".to_string(),
        callback_url: "https://domain.name/callback".to_string(),
        outter_id: "your order id".to_string(),
    };

    let json_data = serde_json::to_string(&order_data)?;

    let mut mac = HmacSha256::new_from_slice(api_key.as_bytes())?;
    mac.update(json_data.as_bytes());
    let result = mac.finalize();
    let signature_bytes = result.into_bytes();
    let signature = hex::encode(signature_bytes);

    let client = reqwest::Client::new();

    let mut headers = HeaderMap::new();
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
    headers.insert("X-API-ID", HeaderValue::from_str(&api_id.to_string())?);
    headers.insert("SIGNATURE", HeaderValue::from_str(&signature)?);

    let response = client
        .post("https://energy.store/api/createOrder")
        .headers(headers)
        .body(json_data)
        .send()
        .await?;

    let response_text = response.text().await?;
    println!("{}", response_text);

    Ok(())
}

import hashlib
import hmac
import json
import requests

API_ID = 1
API_KEY = "YOUR_API_KEY_HERE"

data = {
    'orderID': 'Unique identifier of your order'
}

sorted_data = dict(sorted(data.items()))
json_data = json.dumps(sorted_data, ensure_ascii=False, separators=(',', ':'))

signature = hmac.new(API_KEY.encode(), json_data.encode(), hashlib.sha256).hexdigest()

headers = {
    "Content-Type": "application/json",
    "X-API-ID": str(API_ID),
    "SIGNATURE": signature
}

url = "https://energy.store/api/checkOrder"
response = requests.post(url, headers=headers, data=json_data)

print(response.text)

const axios = require('axios');
const crypto = require('crypto');

const API_ID = 1;
const API_KEY = "YOUR_API_KEY_HERE";

let data = {
    orderID: 'Unique identifier of your order'
};

let sortedKeys = Object.keys(data).sort();
let sortedData = {};
sortedKeys.forEach(key => {
  sortedData[key] = data[key];
});

const jsonData = JSON.stringify(sortedData);

const signature = crypto
  .createHmac('sha256', API_KEY)
  .update(jsonData)
  .digest('hex');

const headers = {
  "Content-Type": "application/json",
  "X-API-ID": API_ID.toString(),
  "SIGNATURE": signature
};

axios.post("https://energy.store/api/checkOrder", jsonData, { headers })
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error.response ? error.response.data : error.message);
  });

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

class CheckOrderExample
{
    static async Task Main()
    {
        int API_ID = 1;
        string API_KEY = "YOUR_API_KEY_HERE";

        var data = new {
            orderID = "Unique identifier of your order"
        };

        var jsonData = JsonSerializer.Serialize(data);

        var keyBytes = Encoding.UTF8.GetBytes(API_KEY);
        var messageBytes = Encoding.UTF8.GetBytes(jsonData);

        using var hmac = new HMACSHA256(keyBytes);
        var hashBytes = hmac.ComputeHash(messageBytes);
        var signature = BitConverter.ToString(hashBytes).Replace("-", "").ToLower();

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("X-API-ID", API_ID.ToString());
        client.DefaultRequestHeaders.Add("SIGNATURE", signature);

        var content = new StringContent(jsonData, Encoding.UTF8, "application/json");
        var response = await client.PostAsync("https://energy.store/api/checkOrder", content);

        var responseContent = await response.Content.ReadAsStringAsync();
        Console.WriteLine(responseContent);
    }
}

package main

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    apiID := 1
    apiKey := "YOUR_API_KEY_HERE"

    data := map[string]interface{}{
        "orderID": "Unique identifier of your order",
    }

    jsonData, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    h := hmac.New(sha256.New, []byte(apiKey))
    h.Write(jsonData)
    signature := hex.EncodeToString(h.Sum(nil))

    req, err := http.NewRequest("POST", "https://energy.store/api/checkOrder", bytes.NewBuffer(jsonData))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-API-ID", fmt.Sprintf("%d", apiID))
    req.Header.Set("SIGNATURE", signature)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

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

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

import com.fasterxml.jackson.databind.ObjectMapper;

public class CheckOrderExample {
    public static void main(String[] args) throws Exception {
        int API_ID = 1;
        String API_KEY = "YOUR_API_KEY_HERE";

        Map data = new HashMap<>();
        data.put("orderID", "Unique identifier of your order");

        ObjectMapper mapper = new ObjectMapper();
        String jsonData = mapper.writeValueAsString(data);

        String signature = calculateHMAC(API_KEY, jsonData);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://energy.store/api/checkOrder"))
                .header("Content-Type", "application/json")
                .header("X-API-ID", String.valueOf(API_ID))
                .header("SIGNATURE", signature)
                .POST(HttpRequest.BodyPublishers.ofString(jsonData))
                .build();

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

    private static String calculateHMAC(String key, String data) throws NoSuchAlgorithmException, InvalidKeyException {
        Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
        SecretKeySpec secret_key = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
        sha256_HMAC.init(secret_key);

        byte[] hash = sha256_HMAC.doFinal(data.getBytes(StandardCharsets.UTF_8));
        StringBuilder hexString = new StringBuilder();
        for (byte b : hash) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) hexString.append('0');
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import java.security.InvalidKeyException
import java.security.NoSuchAlgorithmException
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec

fun main() {
    val API_ID = 1
    val API_KEY = "YOUR_API_KEY_HERE"

    val data = JSONObject().apply {
        put("orderID", "Unique identifier of your order")
    }

    val jsonData = data.toString()
    val signature = calculateHMAC(API_KEY, jsonData)

    val client = OkHttpClient()
    val mediaType = "application/json; charset=utf-8".toMediaType()
    val body = jsonData.toRequestBody(mediaType)

    val request = Request.Builder()
        .url("https://energy.store/api/checkOrder")
        .addHeader("Content-Type", "application/json")
        .addHeader("X-API-ID", API_ID.toString())
        .addHeader("SIGNATURE", signature)
        .post(body)
        .build()

    client.newCall(request).execute().use { response ->
        println(response.body?.string())
    }
}

@Throws(NoSuchAlgorithmException::class, InvalidKeyException::class)
fun calculateHMAC(key: String, data: String): String {
    val secretKeySpec = SecretKeySpec(key.toByteArray(), "HmacSHA256")
    val mac = Mac.getInstance("HmacSHA256")
    mac.init(secretKeySpec)
    val hmacBytes = mac.doFinal(data.toByteArray())
    return hmacBytes.joinToString("") { "%02x".format(it) }
}

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

API_ID = 1
API_KEY = "YOUR_API_KEY_HERE"

data = {
  orderID: 'Unique identifier of your order'
}

sorted_data = data.sort.to_h
json_data = sorted_data.to_json

digest = OpenSSL::Digest.new('sha256')
signature = OpenSSL::HMAC.hexdigest(digest, API_KEY, json_data)

uri = URI.parse('https://energy.store/api/checkOrder')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri.path)
request['Content-Type'] = 'application/json'
request['X-API-ID'] = API_ID.to_s
request['SIGNATURE'] = signature
request.body = json_data

response = http.request(request)
puts response.body

use hmac::{Hmac, Mac, NewMac};
use sha2::Sha256;
use serde::{Deserialize, Serialize};
use std::error::Error;
use std::collections::BTreeMap;
use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};

type HmacSha256 = Hmac;

#[derive(Serialize, Deserialize)]
struct CheckOrderRequest {
    orderID: String,
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    let api_id = 1;
    let api_key = "YOUR_API_KEY_HERE";

    let req_data = CheckOrderRequest {
        orderID: "Unique identifier of your order".to_string(),
    };

    let json_data = serde_json::to_string(&req_data)?;

    let mut mac = HmacSha256::new_from_slice(api_key.as_bytes())?;
    mac.update(json_data.as_bytes());
    let result = mac.finalize();
    let signature_bytes = result.into_bytes();
    let signature = hex::encode(signature_bytes);

    let client = reqwest::Client::new();

    let mut headers = HeaderMap::new();
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
    headers.insert("X-API-ID", HeaderValue::from_str(&api_id.to_string())?);
    headers.insert("SIGNATURE", HeaderValue::from_str(&signature)?);

    let response = client
        .post("https://energy.store/api/checkOrder")
        .headers(headers)
        .body(json_data)
        .send()
        .await?;

    println!("{}", response.text().await?);

    Ok(())
}

import json
import hmac
import hashlib
from flask import Flask, request, jsonify

app = Flask(__name__)
API_KEY = 'YOUR_API_KEY_HERE'

def log_json_data(data):
    with open('callback_log.txt', 'a', encoding='utf-8') as f:
        f.write(json.dumps(data, ensure_ascii=False, indent=4) + '\\n')

@app.route('/callback', methods=['POST'])
def callback():
    json_data = request.get_json()
    if not json_data:
        return jsonify({'status': 'error', 'message': 'No JSON data received'}), 400

    received_signature = request.headers.get('SIGNATURE', '')

    sorted_data = dict(sorted(json_data.items()))
    recalculated_signature = hmac.new(
        API_KEY.encode('utf-8'),
        json.dumps(sorted_data, ensure_ascii=False, separators=(',', ':')).encode('utf-8'),
        hashlib.sha256
    ).hexdigest()

    if hmac.compare_digest(received_signature, recalculated_signature):
        log_json_data(json_data)
        return jsonify({'status': 'success', 'message': 'Signature is valid, data logged.'})
    else:
        return jsonify({'status': 'error', 'message': 'Invalid signature.'}), 403

if __name__ == '__main__':
    app.run(port=5000, debug=True)

const express = require('express');
const crypto = require('crypto');
const fs = require('fs');

const app = express();
app.use(express.json());

const API_KEY = 'YOUR_API_KEY_HERE';

function logJsonData(data) {
    fs.appendFileSync('callback_log.txt', JSON.stringify(data, null, 4) + '\\n');
}

app.post('/callback', (req, res) => {
    const receivedSignature = req.headers['signature'] || '';
    const jsonData = req.body;

    let sortedKeys = Object.keys(jsonData).sort();
    let sortedData = {};
    sortedKeys.forEach(key => {
      sortedData[key] = jsonData[key];
    });

    const recalculatedSignature = crypto
      .createHmac('sha256', API_KEY)
      .update(JSON.stringify(sortedData))
      .digest('hex');

    if (crypto.timingSafeEqual(Buffer.from(receivedSignature), Buffer.from(recalculatedSignature))) {
        logJsonData(jsonData);
        return res.json({ status: 'success', message: 'Signature is valid, data logged.' });
    } else {
        return res.status(403).json({ status: 'error', message: 'Invalid signature.' });
    }
});

app.listen(3000, () => {
    console.log('Callback server listening on port 3000');
});

using System;
using System.IO;
using System.Linq;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;

class Program
{
    static readonly string API_KEY = "YOUR_API_KEY_HERE";

    static void Main(string[] args)
    {
        HttpListener listener = new HttpListener();
        listener.Prefixes.Add("http://*:8080/callback/");
        listener.Start();
        Console.WriteLine("Server started. Listening on port 8080...");

        while (true)
        {
            var context = listener.GetContext();
            var request = context.Request;
            var response = context.Response;

            if (request.HttpMethod == "POST")
            {
                using var reader = new StreamReader(request.InputStream, request.ContentEncoding);
                string body = reader.ReadToEnd();

                string receivedSignature = request.Headers["SIGNATURE"] ?? "";

                var jsonData = JsonSerializer.Deserialize>(body);

                var sorted = jsonData.OrderBy(k => k.Key).ToDictionary(k => k.Key, v => v.Value);
                string sortedJson = JsonSerializer.Serialize(sorted);

                string recalculatedSignature = CalculateHMAC(API_KEY, sortedJson);

                if (recalculatedSignature == receivedSignature)
                {
                    File.AppendAllText("callback_log.txt", JsonSerializer.Serialize(jsonData, new JsonSerializerOptions { WriteIndented = true }) + Environment.NewLine);
                    byte[] responseBytes = Encoding.UTF8.GetBytes("{\"status\":\"success\",\"message\":\"Signature is valid\"}");
                    response.StatusCode = 200;
                    response.OutputStream.Write(responseBytes, 0, responseBytes.Length);
                }
                else
                {
                    byte[] responseBytes = Encoding.UTF8.GetBytes("{\"status\":\"error\",\"message\":\"Invalid signature\"}");
                    response.StatusCode = 403;
                    response.OutputStream.Write(responseBytes, 0, responseBytes.Length);
                }

                response.Close();
            }
            else
            {
                response.StatusCode = 405;
                response.Close();
            }
        }
    }

    static string CalculateHMAC(string key, string data)
    {
        using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(key));
        byte[] hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(data));
        StringBuilder sb = new StringBuilder();
        foreach (var b in hash)
            sb.Append(b.ToString("x2"));
        return sb.ToString();
    }
}

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "sort"
)

var API_KEY = "YOUR_API_KEY_HERE"

func main() {
    http.HandleFunc("/callback", callbackHandler)
    fmt.Println("Callback server started on port 8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func callbackHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    body, err := ioutil.ReadAll(r.Body)
    if err != nil {
        http.Error(w, "Failed to read body", http.StatusBadRequest)
        return
    }
    defer r.Body.Close()

    receivedSignature := r.Header.Get("SIGNATURE")

    var jsonData map[string]interface{}
    if err := json.Unmarshal(body, &jsonData); err != nil {
        http.Error(w, "Invalid JSON", http.StatusBadRequest)
        return
    }

    keys := make([]string, 0, len(jsonData))
    for k := range jsonData {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    sortedData := make(map[string]interface{})
    for _, k := range keys {
        sortedData[k] = jsonData[k]
    }
    sortedBytes, _ := json.Marshal(sortedData)

    mac := hmac.New(sha256.New, []byte(API_KEY))
    mac.Write(sortedBytes)
    recalculatedSignature := hex.EncodeToString(mac.Sum(nil))

    if recalculatedSignature == receivedSignature {
        logData, _ := json.MarshalIndent(jsonData, "", "  ")
        ioutil.WriteFile("callback_log.txt", []byte(fmt.Sprintf("%s\n", logData)), 0644)

        w.WriteHeader(http.StatusOK)
        w.Write([]byte(`{"status":"success","message":"Signature is valid"}`))
    } else {
        w.WriteHeader(http.StatusForbidden)
        w.Write([]byte(`{"status":"error","message":"Invalid signature"}`))
    }
}

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.*;
import com.fasterxml.jackson.databind.ObjectMapper;

public class CallbackJava {

    private static final String API_KEY = "YOUR_API_KEY_HERE";

    public static void main(String[] args) throws IOException {
        HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);
        server.createContext("/callback", new CallbackHandler());
        server.start();
        System.out.println("Java callback server started on port 8080");
    }

    static class CallbackHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            if (!exchange.getRequestMethod().equalsIgnoreCase("POST")) {
                exchange.sendResponseHeaders(405, -1);
                return;
            }

            InputStream requestBody = exchange.getRequestBody();
            String body = new String(requestBody.readAllBytes(), StandardCharsets.UTF_8);

            String receivedSignature = exchange.getRequestHeaders().getFirst("SIGNATURE");
            if (receivedSignature == null) {
                receivedSignature = "";
            }

            ObjectMapper mapper = new ObjectMapper();
            Map jsonData;
            try {
                jsonData = mapper.readValue(body, Map.class);
            } catch (Exception e) {
                exchange.sendResponseHeaders(400, -1);
                return;
            }

            Map sortedMap = new TreeMap<>(jsonData);
            String sortedJson = mapper.writeValueAsString(sortedMap);

            String recalculatedSignature;
            try {
                recalculatedSignature = calculateHmac(API_KEY, sortedJson);
            } catch (Exception e) {
                exchange.sendResponseHeaders(500, -1);
                return;
            }

            if (recalculatedSignature.equals(receivedSignature)) {
                try (FileWriter fw = new FileWriter("callback_log.txt", true)) {
                    fw.write(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(jsonData) + "\n");
                }
                String resp = "{\"status\":\"success\",\"message\":\"Signature is valid\"}";
                exchange.sendResponseHeaders(200, resp.length());
                exchange.getResponseBody().write(resp.getBytes(StandardCharsets.UTF_8));
            } else {
                String resp = "{\"status\":\"error\",\"message\":\"Invalid signature\"}";
                exchange.sendResponseHeaders(403, resp.length());
                exchange.getResponseBody().write(resp.getBytes(StandardCharsets.UTF_8));
            }

            exchange.close();
        }
    }

    static String calculateHmac(String key, String data) throws NoSuchAlgorithmException, InvalidKeyException {
        Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
        sha256_HMAC.init(secretKeySpec);
        byte[] hash = sha256_HMAC.doFinal(data.getBytes(StandardCharsets.UTF_8));

        StringBuilder hexString = new StringBuilder();
        for (byte b : hash) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) hexString.append('0');
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

import com.sun.net.httpserver.HttpExchange
import com.sun.net.httpserver.HttpHandler
import com.sun.net.httpserver.HttpServer
import java.io.*
import java.net.InetSocketAddress
import java.nio.charset.StandardCharsets
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import com.fasterxml.jackson.databind.ObjectMapper
import java.security.InvalidKeyException
import java.security.NoSuchAlgorithmException
import java.util.*

val API_KEY = "YOUR_API_KEY_HERE"

fun main() {
    val server = HttpServer.create(InetSocketAddress(8080), 0)
    server.createContext("/callback", CallbackHandler())
    server.start()
    println("Kotlin callback server started on port 8080")
}

class CallbackHandler : HttpHandler {
    override fun handle(exchange: HttpExchange) {
        if (exchange.requestMethod != "POST") {
            exchange.sendResponseHeaders(405, -1)
            return
        }

        val body = exchange.requestBody.readBytes().toString(Charsets.UTF_8)
        var receivedSignature = exchange.requestHeaders.getFirst("SIGNATURE") ?: ""

        val mapper = ObjectMapper()
        val jsonData: Map = try {
            mapper.readValue(body, Map::class.java) as Map
        } catch (e: Exception) {
            exchange.sendResponseHeaders(400, -1)
            exchange.close()
            return
        }

        val sortedMap = TreeMap(jsonData)
        val sortedJson = mapper.writeValueAsString(sortedMap)

        val recalculatedSignature = calculateHmac(API_KEY, sortedJson)
        if (recalculatedSignature == receivedSignature) {
            File("callback_log.txt").appendText(
                mapper.writerWithDefaultPrettyPrinter().writeValueAsString(jsonData) + "\n"
            )
            val resp = """{"status":"success","message":"Signature is valid"}"""
            exchange.sendResponseHeaders(200, resp.length.toLong())
            exchange.responseBody.write(resp.toByteArray(StandardCharsets.UTF_8))
        } else {
            val resp = """{"status":"error","message":"Invalid signature"}"""
            exchange.sendResponseHeaders(403, resp.length.toLong())
            exchange.responseBody.write(resp.toByteArray(StandardCharsets.UTF_8))
        }
        exchange.close()
    }
}

@Throws(NoSuchAlgorithmException::class, InvalidKeyException::class)
fun calculateHmac(key: String, data: String): String {
    val mac = Mac.getInstance("HmacSHA256")
    mac.init(SecretKeySpec(key.toByteArray(), "HmacSHA256"))
    val hash = mac.doFinal(data.toByteArray())
    return hash.joinToString("") { "%02x".format(it) }
}

require 'webrick'
require 'json'
require 'openssl'

API_KEY = 'YOUR_API_KEY_HERE'

class CallbackServlet < WEBrick::HTTPServlet::AbstractServlet
  def do_POST(req, res)
    received_signature = req.header['signature']&.first || ''

    body = req.body
    begin
      data = JSON.parse(body)
    rescue
      res.status = 400
      res.body = '{"status":"error","message":"Invalid JSON"}'
      return
    end

    sorted_data = data.sort.to_h
    sorted_json = JSON.dump(sorted_data)

    digest = OpenSSL::Digest::SHA256.new
    recalculated_signature = OpenSSL::HMAC.hexdigest(digest, API_KEY, sorted_json)

    if recalculated_signature == received_signature
      File.open('callback_log.txt', 'a') do |f|
        f.puts JSON.pretty_generate(data)
      end
      res.status = 200
      res.body = '{"status":"success","message":"Signature is valid"}'
    else
      res.status = 403
      res.body = '{"status":"error","message":"Invalid signature"}'
    end
  end
end

server = WEBrick::HTTPServer.new(:Port => 8080)
server.mount '/callback', CallbackServlet
trap('INT') { server.shutdown }
server.start

use std::collections::BTreeMap;
use std::io::Read;
use std::net::TcpListener;
use std::sync::Arc;
use std::{fs::OpenOptions, io::Write};

use hmac::{Hmac, Mac, NewMac};
use rouille::{Request, Response};
use serde_json::Value;
use sha2::Sha256;

static API_KEY: &str = "YOUR_API_KEY_HERE";

type HmacSha256 = Hmac;

fn main() {
    let address = "0.0.0.0:8080";
    println!("Listening on {}", address);

    rouille::start_server(address, move |request| {
        rouille::log(request, std::io::stdout(), || {
            if request.url() == "/callback" && request.method() == "POST" {
                handle_callback(request)
            } else {
                Response::empty_404()
            }
        })
    });
}

fn handle_callback(request: &Request) -> Response {
    let body = request.data().expect("Failed to read body");
    let mut buf = Vec::new();
    let mut reader = body.take(10_000_000);
    reader.read_to_end(&mut buf).unwrap();

    let received_signature = request.header("SIGNATURE").unwrap_or("");

    let json: Value = match serde_json::from_slice(&buf) {
        Ok(val) => val,
        Err(_) => return Response::text("Invalid JSON").with_status_code(400),
    };

    let map = match json.as_object() {
        Some(m) => m,
        None => return Response::text("JSON is not an object").with_status_code(400),
    };

    let mut sorted = BTreeMap::new();
    for (k, v) in map.iter() {
        sorted.insert(k, v);
    }

    let sorted_json = serde_json::to_string(&sorted).unwrap();

    let mut mac = HmacSha256::new_from_slice(API_KEY.as_bytes()).unwrap();
    mac.update(sorted_json.as_bytes());
    let signature_bytes = mac.finalize().into_bytes();
    let recalculated_signature = hex::encode(signature_bytes);

    if recalculated_signature == received_signature {
        let mut file = OpenOptions::new()
            .create(true)
            .append(true)
            .open("callback_log.txt")
            .unwrap();
        let _ = writeln!(file, "{}", serde_json::to_string_pretty(&json).unwrap());

        Response::text(r#"{"status":"success","message":"Signature is valid"}"#)
    } else {
        Response::text(r#"{"status":"error","message":"Invalid signature"}"#).with_status_code(403)
    }
}

import hashlib
import hmac
import json
import requests

API_ID = 1
API_KEY = "YOUR_API_KEY_HERE"

data = {
    'address': 'TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
}

sorted_data = dict(sorted(data.items()))
json_data = json.dumps(sorted_data, ensure_ascii=False, separators=(',', ':'))

signature = hmac.new(API_KEY.encode(), json_data.encode(), hashlib.sha256).hexdigest()

headers = {
    "Content-Type": "application/json",
    "X-API-ID": str(API_ID),
    "SIGNATURE": signature
}

url = "https://energy.store/api/checkAddress"
response = requests.post(url, headers=headers, data=json_data)

print(response.text)

const axios = require('axios');
const crypto = require('crypto');

const API_ID = 1;
const API_KEY = "YOUR_API_KEY_HERE";

let data = {
    address: 'TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
};

let sortedKeys = Object.keys(data).sort();
let sortedData = {};
sortedKeys.forEach(key => {
  sortedData[key] = data[key];
});

const jsonData = JSON.stringify(sortedData);

const signature = crypto
  .createHmac('sha256', API_KEY)
  .update(jsonData)
  .digest('hex');

const headers = {
  "Content-Type": "application/json",
  "X-API-ID": API_ID.toString(),
  "SIGNATURE": signature
};

axios.post("https://energy.store/api/checkAddress", jsonData, { headers })
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error.response ? error.response.data : error.message);
  });

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

class CheckAddressExample
{
    static async Task Main()
    {
        int API_ID = 1;
        string API_KEY = "YOUR_API_KEY_HERE";

        var data = new {
            address = "TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
        };

        var jsonData = JsonSerializer.Serialize(data);

        var keyBytes = Encoding.UTF8.GetBytes(API_KEY);
        var messageBytes = Encoding.UTF8.GetBytes(jsonData);

        using var hmac = new HMACSHA256(keyBytes);
        var hashBytes = hmac.ComputeHash(messageBytes);
        var signature = BitConverter.ToString(hashBytes).Replace("-", "").ToLower();

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("X-API-ID", API_ID.ToString());
        client.DefaultRequestHeaders.Add("SIGNATURE", signature);

        var content = new StringContent(jsonData, Encoding.UTF8, "application/json");
        var response = await client.PostAsync("https://energy.store/api/checkAddress", content);

        var responseContent = await response.Content.ReadAsStringAsync();
        Console.WriteLine(responseContent);
    }
}

package main

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    apiID := 1
    apiKey := "YOUR_API_KEY_HERE"

    data := map[string]interface{}{
        "address": "TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
    }

    jsonData, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    h := hmac.New(sha256.New, []byte(apiKey))
    h.Write(jsonData)
    signature := hex.EncodeToString(h.Sum(nil))

    req, err := http.NewRequest("POST", "https://energy.store/api/checkAddress", bytes.NewBuffer(jsonData))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-API-ID", fmt.Sprintf("%d", apiID))
    req.Header.Set("SIGNATURE", signature)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

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

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

import com.fasterxml.jackson.databind.ObjectMapper;

public class CheckAddressExample {
    public static void main(String[] args) throws Exception {
        int API_ID = 1;
        String API_KEY = "YOUR_API_KEY_HERE";

        Map data = new HashMap<>();
        data.put("address", "TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");

        ObjectMapper mapper = new ObjectMapper();
        String jsonData = mapper.writeValueAsString(data);

        String signature = calculateHMAC(API_KEY, jsonData);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://energy.store/api/checkAddress"))
                .header("Content-Type", "application/json")
                .header("X-API-ID", String.valueOf(API_ID))
                .header("SIGNATURE", signature)
                .POST(HttpRequest.BodyPublishers.ofString(jsonData))
                .build();

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

    private static String calculateHMAC(String key, String data) throws NoSuchAlgorithmException, InvalidKeyException {
        Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
        SecretKeySpec secret_key = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
        sha256_HMAC.init(secret_key);

        byte[] hash = sha256_HMAC.doFinal(data.getBytes(StandardCharsets.UTF_8));
        StringBuilder hexString = new StringBuilder();
        for (byte b : hash) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) hexString.append('0');
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import java.security.InvalidKeyException
import java.security.NoSuchAlgorithmException
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec

fun main() {
    val API_ID = 1
    val API_KEY = "YOUR_API_KEY_HERE"

    val data = JSONObject().apply {
        put("address", "TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
    }

    val jsonData = data.toString()
    val signature = calculateHmac(API_KEY, jsonData)

    val client = OkHttpClient()
    val mediaType = "application/json; charset=utf-8".toMediaType()
    val body = jsonData.toRequestBody(mediaType)

    val request = Request.Builder()
        .url("https://energy.store/api/checkAddress")
        .addHeader("Content-Type", "application/json")
        .addHeader("X-API-ID", API_ID.toString())
        .addHeader("SIGNATURE", signature)
        .post(body)
        .build()

    client.newCall(request).execute().use { response ->
        println(response.body?.string())
    }
}

@Throws(NoSuchAlgorithmException::class, InvalidKeyException::class)
fun calculateHmac(key: String, data: String): String {
    val mac = Mac.getInstance("HmacSHA256")
    mac.init(SecretKeySpec(key.toByteArray(), "HmacSHA256"))
    val hash = mac.doFinal(data.toByteArray())
    return hash.joinToString("") { "%02x".format(it) }
}

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

API_ID = 1
API_KEY = "YOUR_API_KEY_HERE"

data = {
  address: 'TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
}

sorted_data = data.sort.to_h
json_data = sorted_data.to_json

digest = OpenSSL::Digest.new('sha256')
signature = OpenSSL::HMAC.hexdigest(digest, API_KEY, json_data)

uri = URI.parse('https://energy.store/api/checkAddress')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri.path)
request['Content-Type'] = 'application/json'
request['X-API-ID'] = API_ID.to_s
request['SIGNATURE'] = signature
request.body = json_data

response = http.request(request)
puts response.body

use hmac::{Hmac, Mac, NewMac};
use sha2::Sha256;
use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
use serde::{Deserialize, Serialize};
use std::error::Error;

type HmacSha256 = Hmac;

#[derive(Serialize, Deserialize)]
struct CheckAddressRequest {
    address: String,
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    let api_id = 1;
    let api_key = "YOUR_API_KEY_HERE";

    let req_data = CheckAddressRequest {
        address: "TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX".to_string(),
    };

    let json_data = serde_json::to_string(&req_data)?;

    let mut mac = HmacSha256::new_from_slice(api_key.as_bytes())?;
    mac.update(json_data.as_bytes());
    let result = mac.finalize();
    let signature_bytes = result.into_bytes();
    let signature = hex::encode(signature_bytes);

    let client = reqwest::Client::new();

    let mut headers = HeaderMap::new();
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
    headers.insert("X-API-ID", HeaderValue::from_str(&api_id.to_string())?);
    headers.insert("SIGNATURE", HeaderValue::from_str(&signature)?);

    let response = client
        .post("https://energy.store/api/checkAddress")
        .headers(headers)
        .body(json_data)
        .send()
        .await?;

    let response_text = response.text().await?;
    println!("{}", response_text);

    Ok(())
}