API Documentation

const crypto = require('crypto');

// Configuration
const API_BASE_URL = 'http://kyc.muiaa.com/api/v1';
const API_KEY_ID = 'ak_live_YOUR_API_KEY_ID';
const SECRET_KEY = 'sk_live_YOUR_SECRET_KEY';

/**
 * Generate HMAC-SHA256 signature for request
 */
function signRequest(secretKey, method, path, body, timestamp) {
    const message = `${method}\n${path}\n${body}\n${timestamp}`;
    const signature = crypto
        .createHmac('sha256', secretKey)
        .update(message)
        .digest('hex');
    return `sha256=${signature}`;
}

/**
 * Create a new verification session
 */
async function createVerificationSession(countryCode = 'US') {
    const method = 'POST';
    const path = '/api/v1/verifications/';
    const body = JSON.stringify({ country_code: countryCode });
    const timestamp = Math.floor(Date.now() / 1000).toString();
    
    const signature = signRequest(SECRET_KEY, method, path, body, timestamp);
    
    const response = await fetch(`${API_BASE_URL}/verifications/`, {
        method: 'POST',
        headers: {
            'Authorization': `Bearer ${API_KEY_ID}`,
            'X-Signature': signature,
            'X-Timestamp': timestamp,
            'Content-Type': 'application/json'
        },
        body: body
    });
    
    return await response.json();
}

// Usage
createVerificationSession('US')
    .then(result => console.log(result))
    .catch(error => console.error('Error:', error));

import * as crypto from 'crypto';

// Configuration
const API_BASE_URL: string = 'http://kyc.muiaa.com/api/v1';
const API_KEY_ID: string = 'ak_live_YOUR_API_KEY_ID';
const SECRET_KEY: string = 'sk_live_YOUR_SECRET_KEY';

interface VerificationRequest {
    country_code: string;
}

interface VerificationResponse {
    session_id: string;
    status: string;
    country_code: string;
    created_at: string;
    expires_at: string;
    kyc_template_url: string;
}

/**
 * Generate HMAC-SHA256 signature for request
 */
function signRequest(
    secretKey: string,
    method: string,
    path: string,
    body: string,
    timestamp: string
): string {
    const message = `${method}\n${path}\n${body}\n${timestamp}`;
    const signature = crypto
        .createHmac('sha256', secretKey)
        .update(message)
        .digest('hex');
    return `sha256=${signature}`;
}

/**
 * Create a new verification session
 */
async function createVerificationSession(
    countryCode: string = 'US'
): Promise {
    const method = 'POST';
    const path = '/api/v1/verifications/';
    const body = JSON.stringify({ country_code: countryCode });
    const timestamp = Math.floor(Date.now() / 1000).toString();
    
    const signature = signRequest(SECRET_KEY, method, path, body, timestamp);
    
    const response = await fetch(`${API_BASE_URL}/verifications/`, {
        method: 'POST',
        headers: {
            'Authorization': `Bearer ${API_KEY_ID}`,
            'X-Signature': signature,
            'X-Timestamp': timestamp,
            'Content-Type': 'application/json'
        },
        body: body
    });
    
    if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    return await response.json() as VerificationResponse;
}

// Usage
createVerificationSession('US')
    .then((result: VerificationResponse) => console.log(result))
    .catch((error: Error) => console.error('Error:', error));

// Cargo.toml dependencies:
// [dependencies]
// reqwest = { version = "0.11", features = ["json"] }
// hmac = "0.12"
// sha2 = "0.10"
// hex = "0.4"
// serde = { version = "1.0", features = ["derive"] }
// serde_json = "1.0"
// tokio = { version = "1", features = ["full"] }

use hmac::{Hmac, Mac};
use reqwest::Client;
use serde::{Deserialize, Serialize};
use sha2::Sha256;
use std::time::{SystemTime, UNIX_EPOCH};

type HmacSha256 = Hmac;

// Configuration
const API_BASE_URL: &str = "http://kyc.muiaa.com/api/v1";
const API_KEY_ID: &str = "ak_live_YOUR_API_KEY_ID";
const SECRET_KEY: &str = "sk_live_YOUR_SECRET_KEY";

#[derive(Serialize)]
struct VerificationRequest {
    country_code: String,
}

#[derive(Deserialize)]
struct VerificationResponse {
    session_id: String,
    status: String,
    country_code: String,
    created_at: String,
    expires_at: String,
    kyc_template_url: String,
}

/// Generate HMAC-SHA256 signature for request
fn sign_request(
    secret_key: &str,
    method: &str,
    path: &str,
    body: &str,
    timestamp: &str,
) -> String {
    let message = format!("{}\n{}\n{}\n{}", method, path, body, timestamp);
    let mut mac = HmacSha256::new_from_slice(secret_key.as_bytes())
        .expect("HMAC can take key of any size");
    mac.update(message.as_bytes());
    let signature = hex::encode(mac.finalize().into_bytes());
    format!("sha256={}", signature)
}

/// Create a new verification session
async fn create_verification_session(
    country_code: &str,
) -> Result> {
    let method = "POST";
    let path = "/api/v1/verifications/";
    let body = serde_json::to_string(&VerificationRequest {
        country_code: country_code.to_string(),
    })?;
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)?
        .as_secs()
        .to_string();
    
    let signature = sign_request(SECRET_KEY, method, path, &body, ×tamp);
    
    let client = Client::new();
    let response = client
        .post(&format!("{}/verifications/", API_BASE_URL))
        .header("Authorization", format!("Bearer {}", API_KEY_ID))
        .header("X-Signature", signature)
        .header("X-Timestamp", timestamp)
        .header("Content-Type", "application/json")
        .body(body)
        .send()
        .await?;
    
    let result: VerificationResponse = response.json().await?;
    Ok(result)
}

// Usage
#[tokio::main]
async fn main() -> Result<(), Box> {
    let result = create_verification_session("US").await?;
    println!("{:?}", result);
    Ok(())
}