POST {casino_URL}?request=tournamentWin&version=1.2
Content-Type: application/json
X-Groove-Signature: a268e60d3179de79196db9552d234c90715c9b9359b7c4ae3dca62afa1bf096c
Original-Brand-ID: 12345

{
  "tournament_id":         "123456-13456-123456-123456",
  "tournament_start_date": "2025-08-27 00:00:00",
  "tournament_end_date":   "2025-08-27 00:00:00",
  "tournament_position":   1,
  "tournament_name":       "Summer Slots Championship",
  "template_id":           "1",
  "prize_type":            1,
  "player_id":             "12345",
  "casino_id":             12345,
  "points":                1500,
  "prize_value":           100.5,
  "prize_name":            "Grand Prize",
  "total_rounds":          10,
  "total_bets":            100,
  "total_wins":            2,
  "timestamp":             "2025-08-27 00:00:00",
  "transaction_id":        "123456-13456-123456-123456_12345_12345"
}

{
  "transaction_id": "11111-11111-11111-11111",
  "code": 200,
  "status": "Success",
  "timestamp": "2025-08-27 00:00:00"
}

{
  "transaction_id": "11111-11111-11111-11111",
  "code": 200,
  "status": "Success - Duplicate",
  "timestamp": "2025-08-27 00:00:00"
}

signature = HMAC_SHA256(concatenated_body_values, security_key)

12345123451500Grand Prize1100.512025-08-27 00:00:001001022025-08-27 00:00:00123456-13456-123456-123456Summer Slots Championship12025-08-27 00:00:00123456-13456-123456-123456_12345_12345

X-Groove-Signature: a268e60d3179de79196db9552d234c90715c9b9359b7c4ae3dca62afa1bf096c

import hmac
import hashlib


def compute_tournament_signature(body: dict, security_key: str) -> str:
    param_map = {}
    for key, value in body.items():
        if key == "request":  # shared rule; not present in this body
            continue
        sort_key = "gameid" if key == "nogsgameid" else key
        param_map[sort_key] = _stringify(value)

    # Sort by field name, then concatenate the values only
    concatenated = "".join(param_map[k] for k in sorted(param_map))

    return hmac.new(
        security_key.encode("utf-8"),
        concatenated.encode("utf-8"),
        hashlib.sha256,
    ).hexdigest()


def _stringify(value) -> str:
    if isinstance(value, bool):
        return "true" if value else "false"
    if isinstance(value, float) and value.is_integer():
        return str(int(value))  # 100.0 -> "100"
    return str(value)           # 100.5 -> "100.5", ints/strings as-is


# Example usage
security_key = "test_key"
body = {
    "tournament_id": "123456-13456-123456-123456",
    "tournament_start_date": "2025-08-27 00:00:00",
    "tournament_end_date": "2025-08-27 00:00:00",
    "tournament_position": 1,
    "tournament_name": "Summer Slots Championship",
    "template_id": "1",
    "prize_type": 1,
    "player_id": "12345",
    "casino_id": 12345,
    "points": 1500,
    "prize_value": 100.5,
    "prize_name": "Grand Prize",
    "total_rounds": 10,
    "total_bets": 100,
    "total_wins": 2,
    "timestamp": "2025-08-27 00:00:00",
    "transaction_id": "123456-13456-123456-123456_12345_12345",
}
print("X-Groove-Signature:", compute_tournament_signature(body, security_key))
# X-Groove-Signature: a268e60d3179de79196db9552d234c90715c9b9359b7c4ae3dca62afa1bf096c

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"sort"
	"strings"
)

func computeTournamentSignature(body []byte, securityKey string) (string, error) {
	var fields map[string]interface{}
	if err := json.Unmarshal(body, &fields); err != nil {
		return "", err
	}

	paramMap := make(map[string]string)
	for key, value := range fields {
		if key == "request" { // shared rule; not present in this body
			continue
		}
		sortKey := key
		if key == "nogsgameid" {
			sortKey = "gameid"
		}
		paramMap[sortKey] = fmt.Sprintf("%v", value)
	}

	// Sort by field name, then concatenate the values only
	keys := make([]string, 0, len(paramMap))
	for k := range paramMap {
		keys = append(keys, k)
	}
	sort.Strings(keys)

	var concatenated strings.Builder
	for _, k := range keys {
		concatenated.WriteString(paramMap[k])
	}

	h := hmac.New(sha256.New, []byte(securityKey))
	h.Write([]byte(concatenated.String()))
	return hex.EncodeToString(h.Sum(nil)), nil
}

func main() {
	securityKey := "test_key"
	body := []byte(`{"tournament_id":"123456-13456-123456-123456","tournament_start_date":"2025-08-27 00:00:00","tournament_end_date":"2025-08-27 00:00:00","tournament_position":1,"tournament_name":"Summer Slots Championship","template_id":"1","prize_type":1,"player_id":"12345","casino_id":12345,"points":1500,"prize_value":100.5,"prize_name":"Grand Prize","total_rounds":10,"total_bets":100,"total_wins":2,"timestamp":"2025-08-27 00:00:00","transaction_id":"123456-13456-123456-123456_12345_12345"}`)
	signature, _ := computeTournamentSignature(body, securityKey)
	fmt.Printf("X-Groove-Signature: %s\n", signature)
	// X-Groove-Signature: a268e60d3179de79196db9552d234c90715c9b9359b7c4ae3dca62afa1bf096c
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.TreeMap;

public class GrooveTournamentSignature {

    public static String computeSignature(Map<String, Object> body, String securityKey) throws Exception {
        // TreeMap keeps the field names sorted alphabetically
        TreeMap<String, String> params = new TreeMap<>();
        for (Map.Entry<String, Object> entry : body.entrySet()) {
            String key = entry.getKey();
            if (key.equals("request")) {        // shared rule; not present in this body
                continue;
            }
            if (key.equals("nogsgameid")) {
                key = "gameid";
            }
            params.put(key, stringify(entry.getValue()));
        }

        // Concatenate the values only
        StringBuilder concatenated = new StringBuilder();
        for (String value : params.values()) {
            concatenated.append(value);
        }

        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(securityKey.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
        byte[] hash = mac.doFinal(concatenated.toString().getBytes(StandardCharsets.UTF_8));

        StringBuilder hex = new StringBuilder();
        for (byte b : hash) {
            hex.append(String.format("%02x", b));
        }
        return hex.toString();
    }

    private static String stringify(Object value) {
        if (value == null) {
            return "";
        }
        if (value instanceof Boolean) {
            return (Boolean) value ? "true" : "false";
        }
        if (value instanceof Double || value instanceof Float) {
            // numbers without trailing zeros: 100.0 -> "100", 100.5 -> "100.5"
            return BigDecimal.valueOf(((Number) value).doubleValue()).stripTrailingZeros().toPlainString();
        }
        return value.toString();
    }

    public static void main(String[] args) throws Exception {
        String securityKey = "test_key";
        Map<String, Object> body = new TreeMap<>();
        body.put("tournament_id", "123456-13456-123456-123456");
        body.put("tournament_start_date", "2025-08-27 00:00:00");
        body.put("tournament_end_date", "2025-08-27 00:00:00");
        body.put("tournament_position", 1);
        body.put("tournament_name", "Summer Slots Championship");
        body.put("template_id", "1");
        body.put("prize_type", 1);
        body.put("player_id", "12345");
        body.put("casino_id", 12345);
        body.put("points", 1500);
        body.put("prize_value", 100.5);
        body.put("prize_name", "Grand Prize");
        body.put("total_rounds", 10);
        body.put("total_bets", 100);
        body.put("total_wins", 2);
        body.put("timestamp", "2025-08-27 00:00:00");
        body.put("transaction_id", "123456-13456-123456-123456_12345_12345");

        System.out.println("X-Groove-Signature: " + computeSignature(body, securityKey));
        // X-Groove-Signature: a268e60d3179de79196db9552d234c90715c9b9359b7c4ae3dca62afa1bf096c
    }
}

import { createHmac } from "crypto";

function computeTournamentSignature(body: Record<string, unknown>, securityKey: string): string {
  const paramMap: Record<string, string> = {};
  for (const [key, value] of Object.entries(body)) {
    if (key === "request") continue; // shared rule; not present in this body
    const sortKey = key === "nogsgameid" ? "gameid" : key;
    paramMap[sortKey] = stringify(value);
  }

  // Sort by field name, then concatenate the values only
  const concatenated = Object.keys(paramMap)
    .sort()
    .map((k) => paramMap[k])
    .join("");

  return createHmac("sha256", securityKey).update(concatenated, "utf8").digest("hex");
}

function stringify(value: unknown): string {
  if (typeof value === "boolean") return value ? "true" : "false";
  return String(value); // numbers: no quotes, no trailing zeros; strings: as-is
}

// Example usage
const securityKey = "test_key";
const body = {
  tournament_id: "123456-13456-123456-123456",
  tournament_start_date: "2025-08-27 00:00:00",
  tournament_end_date: "2025-08-27 00:00:00",
  tournament_position: 1,
  tournament_name: "Summer Slots Championship",
  template_id: "1",
  prize_type: 1,
  player_id: "12345",
  casino_id: 12345,
  points: 1500,
  prize_value: 100.5,
  prize_name: "Grand Prize",
  total_rounds: 10,
  total_bets: 100,
  total_wins: 2,
  timestamp: "2025-08-27 00:00:00",
  transaction_id: "123456-13456-123456-123456_12345_12345",
};
console.log("X-Groove-Signature:", computeTournamentSignature(body, securityKey));
// X-Groove-Signature: a268e60d3179de79196db9552d234c90715c9b9359b7c4ae3dca62afa1bf096c