import java.math.BigInteger;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.SignatureException;


public static String generateXpaytoken(String resourcePath, String queryString, String requestBody, String sharedSecret) throws SignatureException {  
    String timestamp = timeStamp();  
    String beforeHash = timestamp + resourcePath + queryString + requestBody;
    String hash = hmacSha256Digest(beforeHash, sharedSecret);  
    String token = "xv2:" + timestamp + ":" + hash;  
    return token;  
}  

private static String timeStamp() {  
        return String.valueOf(System.currentTimeMillis()/ 1000L);  
    }  

private static String hmacSha256Digest(String data, String sharedSecret)  
        throws SignatureException {  
    return getDigest("HmacSHA256", sharedSecret, data, true);  
}  

private static String getDigest(String algorithm, String sharedSecret, String data,  boolean toLower) throws SignatureException {  
    try {  
        Mac sha256HMAC = Mac.getInstance(algorithm);  
        SecretKeySpec secretKey = new SecretKeySpec(sharedSecret.getBytes(StandardCharsets.UTF_8), algorithm);  
        sha256HMAC.init(secretKey);  

        byte[] hashByte = sha256HMAC.doFinal(data.getBytes(StandardCharsets.UTF_8));  
        String hashString = toHex(hashByte);  

        return toLower ? hashString.toLowerCase() : hashString;
    } catch (Exception e) {  
        throw new SignatureException(e);  
    }  
}  

private static String toHex(byte[] bytes) {  
    BigInteger bi = new BigInteger(1, bytes);  
    return String.format("%0" + (bytes.length << 1) + "X", bi);  
}
		

from calendar import timegm  
from datetime import datetime  
from hashlib import sha256  
import hmac  

def _get_x_pay_token(shared_secret, resource_path, query_string, body):  
    timestamp = str(timegm(datetime.utcnow().timetuple()))  
    pre_hash_string = timestamp + resource_path + query_string + body  
    hash_string = hmac.new(shared_secret,  
                           msg=pre_hash_string,  
                           digestmod=sha256).hexdigest()  
    return 'xv2:' + timestamp + ':' + hash_string
		

var timestamp = Math.floor(Date.now() / 1000);  
var preHashString = timestamp + resourcePath + queryParams + postBody;  
var crypto = require('crypto');  
var hashString = crypto.createHmac('SHA256', sharedSecret).update(preHashString).digest('hex');  
var xPayToken = 'xv2:' + timestamp + ':' + hashString;
		

def get_xpay_token(shared_secret, resource_path, query_string, request_body) 
require 'digest' 
timestamp = Time.now.getutc.to_i.to_s 
hash_input = timestamp + resource_path + query_string + request_body 
hash_output = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'), shared_secret, hash_input) 
return "xv2:" + timestamp + ":" + hash_output  
end
		

private static string getTimestamp() { 
    long timeStamp = ((long) DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds) / 1000; 
    return timeStamp.ToString(); 
} 

private static string getHash(string data) { 
    var hashString = new HMACSHA256(Encoding.ASCII.GetBytes(SHARED_SECRET)); 
    var hashbytes = hashString.ComputeHash(Encoding.ASCII.GetBytes(data)); 
    string digest = String.Empty; 

    foreach (byte b in hashbytes) { 
        digest += b.ToString("x2"); 
    } 

    return digest; 
} 

private static string getXPayToken(string resourcePath, string queryString, string requestBody) { 
    string timestamp = getTimestamp(); 
    string sourceString = timestamp + resourcePath + queryString  + requestBody; 
    string hash = getHash(sourceString); 
    string token = "xv2:" + timestamp + ":" + hash; 
    return token; 
}
		

$time = time(); 
$ pre_hash_string = $time.$resource_path.$query_string.$body; 
$hashtoken = "xv2:".$time.":".hash_hmac('sha256', $ pre_hash_string, $secret);