X-Groove-Signature: <generated_signature>

signature = HMAC_SHA256(concatenated_values, security_key)

{
    "code": 1001,
    "status": "Invalid signature",
    "message": "invalid signature"
}

import hmac
import hashlib
from urllib.parse import urlparse, parse_qs

def generate_signature(url, security_key):
    # Parse URL and extract query parameters
    parsed = urlparse(url)
    params = parse_qs(parsed.query)
    
    # Create parameter dictionary (handle single values)
    param_dict = {}
    for key, value_list in params.items():
        # Skip 'request' parameter
        if key == 'request':
            continue
        # Treat 'nogsgameid' as 'gameid' for sorting
        sort_key = 'gameid' if key == 'nogsgameid' else key
        param_dict[sort_key] = value_list[0] if value_list else ''
    
    # Sort parameters alphabetically and concatenate values
    sorted_params = sorted(param_dict.items())
    concatenated = ''.join([value for key, value in sorted_params])
    
    # Generate HMAC-SHA256
    signature = hmac.new(
        security_key.encode('utf-8'),
        concatenated.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()
    
    return signature

# Example usage
security_key = "test_key"
url = "/groove?request=wager&gamesessionid=123_jdhdujdk&accountid=111&device=desktop&gameid=80102&apiversion=1.2&betamount=10.0&roundid=nc8n4nd87&transactionid=trx_id"
signature = generate_signature(url, security_key)
print(f"X-Groove-Signature: {signature}")

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "net/url"
    "sort"
    "strings"
)

func generateSignature(requestURL string, securityKey string) string {
    // Parse URL
    u, _ := url.Parse(requestURL)
    params := u.Query()
    
    // Create parameter map for sorting
    paramMap := make(map[string]string)
    for key, values := range params {
        // Skip 'request' parameter
        if key == "request" {
            continue
        }
        // Treat 'nogsgameid' as 'gameid' for sorting
        sortKey := key
        if key == "nogsgameid" {
            sortKey = "gameid"
        }
        if len(values) > 0 {
            paramMap[sortKey] = values[0]
        }
    }
    
    // Sort keys alphabetically
    var keys []string
    for k := range paramMap {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    
    // Concatenate values in sorted order
    var concatenated strings.Builder
    for _, key := range keys {
        concatenated.WriteString(paramMap[key])
    }
    
    // Generate HMAC-SHA256
    h := hmac.New(sha256.New, []byte(securityKey))
    h.Write([]byte(concatenated.String()))
    signature := hex.EncodeToString(h.Sum(nil))
    
    return signature
}

// Example usage
func main() {
    securityKey := "test_key"
    url := "/groove?request=wager&gamesessionid=123_jdhdujdk&accountid=111&device=desktop&gameid=80102&apiversion=1.2&betamount=10.0&roundid=nc8n4nd87&transactionid=trx_id"
    signature := generateSignature(url, securityKey)
    fmt.Printf("X-Groove-Signature: %s\n", signature)
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public class GrooveSignature {
    
    public static String generateSignature(String url, String securityKey) throws Exception {
        // Parse query parameters
        String query = url.substring(url.indexOf("?") + 1);
        Map<String, String> params = new LinkedHashMap<>();
        
        for (String param : query.split("&")) {
            String[] keyValue = param.split("=");
            String key = URLDecoder.decode(keyValue[0], StandardCharsets.UTF_8.name());
            String value = keyValue.length > 1 ? 
                URLDecoder.decode(keyValue[1], StandardCharsets.UTF_8.name()) : "";
            
            // Skip 'request' parameter
            if (!key.equals("request")) {
                // Treat 'nogsgameid' as 'gameid' for sorting
                String sortKey = key.equals("nogsgameid") ? "gameid" : key;
                params.put(sortKey, value);
            }
        }
        
        // Sort parameters alphabetically
        Map<String, String> sortedParams = new TreeMap<>(params);
        
        // Concatenate values
        StringBuilder concatenated = new StringBuilder();
        for (String value : sortedParams.values()) {
            concatenated.append(value);
        }
        
        // Generate HMAC-SHA256
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKey = new SecretKeySpec(
            securityKey.getBytes(StandardCharsets.UTF_8), 
            "HmacSHA256"
        );
        mac.init(secretKey);
        byte[] hash = mac.doFinal(concatenated.toString().getBytes(StandardCharsets.UTF_8));
        
        // Convert to hex string
        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();
    }
    
    // Example usage
    public static void main(String[] args) throws Exception {
        String securityKey = "test_key";
        String url = "/groove?request=wager&gamesessionid=123_jdhdujdk&accountid=111&device=desktop&gameid=80102&apiversion=1.2&betamount=10.0&roundid=nc8n4nd87&transactionid=trx_id";
        String signature = generateSignature(url, securityKey);
        System.out.println("X-Groove-Signature: " + signature);
    }
}