Creation of a crypto wallet
Endpoint
POSThttps://api-merchant.alikassa.com/v1/account/crypto-wallet📋
Headers
| Header | Value |
|---|---|
| Content-Type | application/json |
| Account | Your account uuid, you can find in Accounts |
| Sign | Request signature |
Parameters
| Name | Description |
|---|---|
| service | Takes the following values: • tron_usdt_hpp • eth_usdt_hpp • btc_btc_hpp |
Response
| Name | Description |
|---|---|
| success | Takes the following values: • true - request completed successfully • false - request completed with an error |
| address | Сrypto wallet address |
Response Examples
Successful Response (HTTP CODE 200)
{
"success": true,
"address": "***"
}
Error Response (HTTP CODE 400)
{
"success": false,
"message": "***"
}
Important Notes
caution
When requested, use the payment certificate
Example Implementation
function createCryptoWallet(string $method, string $account, array $data)
{
$data = json_encode($data);
$privateKey = openssl_pkey_get_private(
file_get_contents(__DIR__ . '/cert/payment/private.pem'),
file_get_contents(__DIR__ . '/cert/payment/password.txt')
);
if ($privateKey === false) {
throw new \Exception('Error cert.');
}
openssl_sign($data, $sign, $privateKey);
$sign = base64_encode($sign);
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api-merchant.alikassa.com/' . $method);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Content-Type: application/json',
'Account: ' . $account,
'Sign: ' . $sign,
]);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_USERAGENT, 'AliKassa2.0 API');
curl_setopt($ch, CURLOPT_TIMEOUT, 30);
$response = curl_exec($ch);
return json_decode($response, true);
}
$cryptoWallet = createCryptoWallet(
'v1/account/crypto-wallet',
'93d5df06-996c-48c3-9847-348d6b580b80',
["service" => "tron_usdt_hpp"]
);
var_dump($cryptoWallet);
import { readFileSync } from 'fs';
import { createSign } from 'crypto';
import https from 'https';
async function createCryptoWallet(method, account, data) {
const body = JSON.stringify(data);
const keyPem = readFileSync('cert/payment/private.pem', 'utf8');
const passphrase = readFileSync('cert/payment/password.txt', 'utf8').trim();
const signer = createSign('SHA256');
signer.update(body);
signer.end();
const sign = signer.sign({ key: keyPem, passphrase }, 'base64');
const options = {
hostname: 'api-merchant.alikassa.com',
path: `/${method}`,
method: 'POST',
headers: {
'Content-Type': 'application/json',
Account: account,
Sign: sign,
'User-Agent': 'AliKassa2.0 API',
},
timeout: 30000,
};
return new Promise((resolve, reject) => {
const req = https.request(options, (res) => {
let data = '';
res.on('data', (chunk) => (data += chunk));
res.on('end', () => resolve(JSON.parse(data)));
});
req.on('error', reject);
req.write(body);
req.end();
});
}
(async () => {
const cryptoWallet = await createCryptoWallet(
'v1/account/crypto-wallet',
'93d5df06-996c-48c3-9847-348d6b580b80',
{ service: 'tron_usdt_hpp' }
);
console.log(cryptoWallet);
})();
import json
import base64
import requests
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding
def create_crypto_wallet(method: str, account: str, data: dict):
payload = json.dumps(data).encode('utf-8')
password = open('cert/payment/password.txt','rb').read().strip()
private_key = serialization.load_pem_private_key(
open('cert/payment/private.pem','rb').read(),
password=password
)
signature = private_key.sign(payload, padding.PKCS1v15(), hashes.SHA256())
sign = base64.b64encode(signature).decode('utf-8')
headers = {
'Content-Type': 'application/json',
'Account': account,
'Sign': sign,
'User-Agent': 'AliKassa2.0 API',
}
resp = requests.post(f'https://api-merchant.alikassa.com/{method}', data=payload, headers=headers, timeout=30)
return resp.json()
crypto_wallet = create_crypto_wallet(
'v1/account/crypto-wallet',
'93d5df06-996c-48c3-9847-348d6b580b80',
{'service': 'tron_usdt_hpp'}
)
print(crypto_wallet)
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.Signature;
import java.util.Base64;
import java.util.Map;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.bouncycastle.openssl.PEMEncryptedKeyPair;
import org.bouncycastle.openssl.PEMParser;
import org.bouncycastle.openssl.jcajce.JcePEMDecryptorProviderBuilder;
import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;
public class Example {
public static void main(String[] args) throws Exception {
ObjectMapper mapper = new ObjectMapper();
Map<String,Object> data = Map.of("service", "tron_usdt_hpp");
byte[] jsonBytes = mapper.writeValueAsBytes(data);
char[] pass = Files.readString(Paths.get("cert/payment/password.txt")).toCharArray();
PEMParser parser = new PEMParser(Files.newBufferedReader(Paths.get("cert/payment/private.pem")));
PEMEncryptedKeyPair ckp = (PEMEncryptedKeyPair) parser.readObject();
var privateKey = new JcaPEMKeyConverter()
.getKeyPair(ckp.decryptKeyPair(new JcePEMDecryptorProviderBuilder().build(pass)))
.getPrivate();
Signature sig = Signature.getInstance("SHA256withRSA");
sig.initSign(privateKey);
sig.update(jsonBytes);
String sign = Base64.getEncoder().encodeToString(sig.sign());
HttpRequest req = HttpRequest.newBuilder()
.uri(java.net.URI.create("https://api-merchant.alikassa.com/v1/account/crypto-wallet"))
.header("Content-Type","application/json")
.header("Account","93d5df06-996c-48c3-9847-348d6b580b80")
.header("Sign",sign)
.header("User-Agent","AliKassa2.0 API")
.POST(HttpRequest.BodyPublishers.ofString(new String(jsonBytes, StandardCharsets.UTF_8)))
.build();
var client = HttpClient.newHttpClient();
var response = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(mapper.readValue(response.body(), Map.class));
}
}
package main
import (
"bytes"
"crypto"
"crypto/rand"
"crypto/rsa"
"crypto/sha256"
"crypto/x509"
"encoding/base64"
"encoding/json"
"encoding/pem"
"io/ioutil"
"net/http"
"time"
"fmt"
)
func signData(data []byte) string {
pemBytes, _ := ioutil.ReadFile("cert/payment/private.pem")
passBytes, _ := ioutil.ReadFile("cert/payment/password.txt")
block, _ := pem.Decode(pemBytes)
der, _ := x509.DecryptPEMBlock(block, passBytes)
priv, _ := x509.ParsePKCS1PrivateKey(der)
hash := sha256.Sum256(data)
sigBytes, _ := rsa.SignPKCS1v15(rand.Reader, priv, crypto.SHA256, hash[:])
return base64.StdEncoding.EncodeToString(sigBytes)
}
func createCryptoWallet(method, account string, data interface{}) (map[string]interface{}, error) {
jsonBytes, _ := json.Marshal(data)
sign := signData(jsonBytes)
req, _ := http.NewRequest("POST", "https://api-merchant.alikassa.com/"+method, bytes.NewReader(jsonBytes))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Account", account)
req.Header.Set("Sign", sign)
req.Header.Set("User-Agent", "AliKassa2.0 API")
client := &http.Client{Timeout: 30 * time.Second}
resp, _ := client.Do(req)
defer resp.Body.Close()
var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
return result, nil
}
func main() {
cryptoWallet, _ := createCryptoWallet("v1/account/crypto-wallet", "93d5df06-996c-48c3-9847-348d6b580b80", map[string]interface{}{
"service": "tron_usdt_hpp",
})
fmt.Println(cryptoWallet)
}