# Get Public Market Data
# Endpoint: /api/v3/ticker/24hr

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/api/v3/ticker/24hr"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/api/v3/ticker/24hr"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/api/v3/ticker/24hr";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

# Get Public Market Data
# Endpoint: /api/v3/ticker/24hr

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/api/v3/ticker/24hr"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/api/v3/ticker/24hr"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/api/v3/ticker/24hr";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

# Get Public Market Data
# Endpoint: /api/v3/ticker/24hr

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/api/v3/ticker/24hr"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/api/v3/ticker/24hr"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/api/v3/ticker/24hr";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

# Get Public Market Data
# Endpoint: /api/v3/ticker/24hr

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/api/v3/ticker/24hr"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/api/v3/ticker/24hr"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/api/v3/ticker/24hr";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

# Get Public Market Data
# Endpoint: /api/v3/ticker/24hr

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/api/v3/ticker/24hr"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/api/v3/ticker/24hr"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/api/v3/ticker/24hr";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

# Get Public Market Data
# Endpoint: /api/v3/ticker/24hr

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/api/v3/ticker/24hr"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/api/v3/ticker/24hr"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/api/v3/ticker/24hr";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

# Get Public Market Data
# Endpoint: /api/v3/ticker/24hr

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/api/v3/ticker/24hr"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/api/v3/ticker/24hr"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/api/v3/ticker/24hr";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

# Get Public Market Data
# Endpoint: /api/v3/ticker/24hr

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/api/v3/ticker/24hr"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/api/v3/ticker/24hr"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Public Market Data
// Endpoint: /api/v3/ticker/24hr
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/api/v3/ticker/24hr";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

#!/usr/bin/env python3
"""
Sample: Spot Account Data
Demonstrates how to fetch Spot account information (balances).
"""

import requests
import time
from eth_account import Account
from eth_account.messages import encode_defunct
from eth_account.messages import encode_typed_data

CONFIG = {
    'BASE_URL': 'https://www.asterdex-testnet.com/api/v3',
    'USER_WALLET': 'YOUR_USER_WALLET',
    'AGENT_WALLET': 'YOUR_AGENT_WALLET',
    'AGENT_PRIVATE_KEY': 'YOUR_AGENT_PRIVATE_KEY'
}

def sign_spot_request(endpoint):
    """Sign a Spot API request for account data."""
    nonce = str(int(time.time() * 1000000))
    param_string = f"nonce={nonce}&user={CONFIG['USER_WALLET']}&signer={CONFIG['AGENT_WALLET']}"
    
    domain = {
        'name': 'AsterSignTransaction',
        'version': '1',
        'chainId': 714,
        'verifyingContract': '0x0000000000000000000000000000000000000000'
    }
    
    types = {
        'EIP712Domain': [
            {'name': 'name', 'type': 'string'},
            {'name': 'version', 'type': 'string'},
            {'name': 'chainId', 'type': 'uint256'},
            {'name': 'verifyingContract', 'type': 'address'}
        ],
        'Message': [{'name': 'msg', 'type': 'string'}]
    }
    
    message = {'msg': param_string}
    structured_data = {'types': types, 'primaryType': 'Message', 'domain': domain, 'message': message}
    
    account = Account.from_key(CONFIG['AGENT_PRIVATE_KEY'].strip())
    signable_message = encode_typed_data(full_message=structured_data)
    signed_message = account.sign_message(signable_message)
    signature = signed_message.signature.hex()
    
    return f"{CONFIG['BASE_URL']}{endpoint}?{param_string}&signature={signature}"

def get_spot_account():
    """Fetch Spot account information."""
    print("🚀 Spot Account Data...")
    
    try:
        url = sign_spot_request('/account')
        response = requests.get(url)
        response.raise_for_status()
        data = response.json()
        
        print("✅ Account Balances:")
        if 'balances' in data:
            for bal in data['balances']:
                free_amt = float(bal.get('free', 0))
                locked_amt = float(bal.get('locked', 0))
                if free_amt > 0 or locked_amt > 0:
                    print(f"   {bal['asset']}: Free={free_amt}, Locked={locked_amt}")
        else:
            print("   (No balances found)")
                
    except requests.exceptions.HTTPError as e:
        print(f"❌ HTTP Error: {e}")
        print(e.response.text if e.response else "")
    except Exception as e:
        print(f"❌ Error: {e}")

if __name__ == '__main__':
    get_spot_account()

// Sample: Futures Operations
// See README.md for setup instructions
package main

import (
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
    "github.com/ethereum/go-ethereum/common/math"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/signer/core/apitypes"
)

type Config struct {
    BaseURL, UserWallet, AgentWallet, AgentPrivateKey string
}

var config = Config{
    BaseURL: "https://www.asterdex-testnet.com/fapi/v3",
    UserWallet: "YOUR_USER_WALLET",
    AgentWallet: "YOUR_AGENT_WALLET",
    AgentPrivateKey: "YOUR_AGENT_PRIVATE_KEY",
}

func signRequest(params map[string]string) (string, error) {
    nonce := fmt.Sprintf("%d", time.Now().UnixNano()/1000)
    keys := []string{"symbol", "side", "type", "quantity", "price", "timeInForce", "leverage", "orderId"}
    var valParts []string
    for _, key := range keys {
        if val, ok := params[key]; ok && val != "" {
            valParts = append(valParts, fmt.Sprintf("%s=%s", key, val))
        }
    }
    val := ""
    for i, part := range valParts {
        if i > 0 { val += "&" }
        val += part
    }
    if stopPrice, ok := params["stopPrice"]; ok {
        val += fmt.Sprintf("&stopPrice=%s", stopPrice)
    }
    val += fmt.Sprintf("&nonce=%s&user=%s&signer=%s", nonce, config.UserWallet, config.AgentWallet)
    
    domain := apitypes.TypedDataDomain{Name: "AsterSignTransaction", Version: "1", ChainId: math.NewHexOrDecimal256(714), VerifyingContract: "0x0000000000000000000000000000000000000000"}
    typedData := apitypes.TypedData{Types: apitypes.Types{"EIP712Domain": []apitypes.Type{{Name: "name", Type: "string"}, {Name: "version", Type: "string"}, {Name: "chainId", Type: "uint256"}, {Name: "verifyingContract", Type: "address"}}, "Message": []apitypes.Type{{Name: "msg", Type: "string"}}}, PrimaryType: "Message", Domain: domain, Message: apitypes.TypedDataMessage{"msg": val}}
    
    privKeyBytes, _ := hex.DecodeString(config.AgentPrivateKey)
    privKey, _ := crypto.ToECDSA(privKeyBytes)
    domainSeparator, _ := typedData.HashStruct("EIP712Domain", typedData.Domain.Map())
    typedDataHash, _ := typedData.HashStruct(typedData.PrimaryType, typedData.Message)
    rawData := []byte(fmt.Sprintf("\x19\x01%s%s", string(domainSeparator), string(typedDataHash)))
    challengeHash := crypto.Keccak256Hash(rawData)
    signature, _ := crypto.Sign(challengeHash.Bytes(), privKey)
    signature[64] += 27
    
    return fmt.Sprintf("%s/order?%s&signature=0x%s", config.BaseURL, val, hex.EncodeToString(signature)), nil
}

func main() {
    fmt.Println("🚀 Running sample...")
    params := map[string]string{"symbol": "BTCUSDT", "side": "BUY", "type": "LIMIT", "quantity": "0.001", "price": "90000", "timeInForce": "GTC"}
    url, _ := signRequest(params)
    resp, _ := http.Post(url, "application/json", nil)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var result map[string]interface{}
    json.Unmarshal(body, &result)
    fmt.Printf("✅ Result: %v\n", result)
}

// Sample: Futures/Spot Operations
// See README.md for dependencies
use ethers::signers::{LocalWallet, Signer};
use ethers::contract::Eip712;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};

const BASE_URL: &str = "https://www.asterdex-testnet.com/fapi/v3/";
const USER_WALLET: &str = "YOUR_USER_WALLET";
const AGENT_WALLET: &str = "YOUR_AGENT_WALLET";
const AGENT_PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

#[derive(Debug, Clone, Serialize, Deserialize, Eip712, ethers::contract::EthAbiType)]
#[eip712(name = "AsterSignTransaction", version = "1", chain_id = 714, verifying_contract = "0x0000000000000000000000000000000000000000")]
struct Message { msg: String }

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Running sample...");
    let params = HashMap::from([("symbol", "BTCUSDT"), ("side", "BUY"), ("type", "LIMIT"), ("quantity", "0.001"), ("price", "90000"), ("timeInForce", "GTC")]);
    let nonce = SystemTime::now().duration_since(UNIX_EPOCH)?.as_micros().to_string();
    let keys = ["symbol", "side", "type", "quantity", "price", "timeInForce"];
    let mut val_parts = Vec::new();
    for key in keys.iter() {
        if let Some(value) = params.get(key) {
            val_parts.push(format!("{}={}", key, value));
        }
    }
    let val = format!("{}&nonce={}&user={}&signer={}", val_parts.join("&"), nonce, USER_WALLET, AGENT_WALLET);
    let message = Message { msg: val.clone() };
    let wallet: LocalWallet = AGENT_PRIVATE_KEY.parse()?;
    let signature = wallet.sign_typed_data(&message).await?;
    let url = format!("{}order?{}&signature=0x{}", BASE_URL, val, hex::encode(signature.to_vec()));
    
    let client = reqwest::Client::new();
    let response = client.post(&url).send().await?;
    let body: serde_json::Value = response.json().await?;
    println!("✅ Result: {:?}", body);
    Ok(())
}

#!/usr/bin/env python3
"""
Sample: Spot LIMIT BUY Order
Demonstrates how to place a limit buy order on AsterDex Spot API.
"""

import requests
import time
from eth_account import Account
from eth_account.messages import encode_defunct
from eth_account.messages import encode_typed_data
from urllib.parse import urlencode

CONFIG = {
    'BASE_URL': 'https://www.asterdex-testnet.com/api/v3',
    'USER_WALLET': 'YOUR_USER_WALLET',
    'AGENT_WALLET': 'YOUR_AGENT_WALLET',
    'AGENT_PRIVATE_KEY': 'YOUR_AGENT_PRIVATE_KEY'
}

def sign_spot_request(params):
    """Sign a Spot API request using EIP-712."""
    nonce = str(int(time.time() * 1000000))
    
    param_parts = []
    for key in ['symbol', 'side', 'type', 'quantity', 'quoteOrderQty', 'price', 'timeInForce', 'orderId']:
        if key in params and params[key] is not None:
            param_parts.append(f"{key}={params[key]}")
    
    param_string = '&'.join(param_parts)
    param_string += f"&nonce={nonce}&user={CONFIG['USER_WALLET']}&signer={CONFIG['AGENT_WALLET']}"
    
    domain = {
        'name': 'AsterSignTransaction',
        'version': '1',
        'chainId': 714,
        'verifyingContract': '0x0000000000000000000000000000000000000000'
    }
    
    types = {
        'EIP712Domain': [
            {'name': 'name', 'type': 'string'},
            {'name': 'version', 'type': 'string'},
            {'name': 'chainId', 'type': 'uint256'},
            {'name': 'verifyingContract', 'type': 'address'}
        ],
        'Message': [{'name': 'msg', 'type': 'string'}]
    }
    
    message = {'msg': param_string}
    structured_data = {'types': types, 'primaryType': 'Message', 'domain': domain, 'message': message}
    
    account = Account.from_key(CONFIG['AGENT_PRIVATE_KEY'].strip())
    signable_message = encode_typed_data(full_message=structured_data)
    signed_message = account.sign_message(signable_message)
    signature = signed_message.signature.hex()
    
    return {**params, 'nonce': nonce, 'user': CONFIG['USER_WALLET'], 
            'signer': CONFIG['AGENT_WALLET'], 'signature': signature}

def place_limit_buy():
    """Place a Spot LIMIT BUY order."""
    print("🚀 Placing Spot LIMIT BUY...")
    
    # Get current price
    try:
        price_res = requests.get(f"{CONFIG['BASE_URL']}/ticker/price?symbol=ASTERUSDT")
        current_price = float(price_res.json()['price'])
        print(f"ℹ️  Current Price: {current_price}")
    except:
        current_price = 0.5
    
    limit_price = round(current_price * 0.95, 4)  # 5% below market
    quantity = round(10 / limit_price, 1)  # Buy ~10 USDT worth
    
    params = {
        'symbol': 'ASTERUSDT',
        'side': 'BUY',
        'type': 'LIMIT',
        'quantity': str(quantity),
        'price': str(limit_price),
        'timeInForce': 'GTC'
    }
    
    signed_body = sign_spot_request(params)
    
    try:
        response = requests.post(
            f"{CONFIG['BASE_URL']}/order",
            data=urlencode(signed_body),
            headers={'Content-Type': 'application/x-www-form-urlencoded'}
        )
        response.raise_for_status()
        data = response.json()
        print(f"✅ Limit Buy Placed: ID {data.get('orderId')}")
    except requests.exceptions.HTTPError as e:
        print(f"❌ Failed: {e}")
        print(e.response.text if e.response else "")
    except Exception as e:
        print(f"❌ Error: {e}")

if __name__ == '__main__':
    place_limit_buy()

// Sample: Futures Operations
// See README.md for setup instructions
package main

import (
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
    "github.com/ethereum/go-ethereum/common/math"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/signer/core/apitypes"
)

type Config struct {
    BaseURL, UserWallet, AgentWallet, AgentPrivateKey string
}

var config = Config{
    BaseURL: "https://www.asterdex-testnet.com/fapi/v3",
    UserWallet: "YOUR_USER_WALLET",
    AgentWallet: "YOUR_AGENT_WALLET",
    AgentPrivateKey: "YOUR_AGENT_PRIVATE_KEY",
}

func signRequest(params map[string]string) (string, error) {
    nonce := fmt.Sprintf("%d", time.Now().UnixNano()/1000)
    keys := []string{"symbol", "side", "type", "quantity", "price", "timeInForce", "leverage", "orderId"}
    var valParts []string
    for _, key := range keys {
        if val, ok := params[key]; ok && val != "" {
            valParts = append(valParts, fmt.Sprintf("%s=%s", key, val))
        }
    }
    val := ""
    for i, part := range valParts {
        if i > 0 { val += "&" }
        val += part
    }
    if stopPrice, ok := params["stopPrice"]; ok {
        val += fmt.Sprintf("&stopPrice=%s", stopPrice)
    }
    val += fmt.Sprintf("&nonce=%s&user=%s&signer=%s", nonce, config.UserWallet, config.AgentWallet)
    
    domain := apitypes.TypedDataDomain{Name: "AsterSignTransaction", Version: "1", ChainId: math.NewHexOrDecimal256(714), VerifyingContract: "0x0000000000000000000000000000000000000000"}
    typedData := apitypes.TypedData{Types: apitypes.Types{"EIP712Domain": []apitypes.Type{{Name: "name", Type: "string"}, {Name: "version", Type: "string"}, {Name: "chainId", Type: "uint256"}, {Name: "verifyingContract", Type: "address"}}, "Message": []apitypes.Type{{Name: "msg", Type: "string"}}}, PrimaryType: "Message", Domain: domain, Message: apitypes.TypedDataMessage{"msg": val}}
    
    privKeyBytes, _ := hex.DecodeString(config.AgentPrivateKey)
    privKey, _ := crypto.ToECDSA(privKeyBytes)
    domainSeparator, _ := typedData.HashStruct("EIP712Domain", typedData.Domain.Map())
    typedDataHash, _ := typedData.HashStruct(typedData.PrimaryType, typedData.Message)
    rawData := []byte(fmt.Sprintf("\x19\x01%s%s", string(domainSeparator), string(typedDataHash)))
    challengeHash := crypto.Keccak256Hash(rawData)
    signature, _ := crypto.Sign(challengeHash.Bytes(), privKey)
    signature[64] += 27
    
    return fmt.Sprintf("%s/order?%s&signature=0x%s", config.BaseURL, val, hex.EncodeToString(signature)), nil
}

func main() {
    fmt.Println("🚀 Running sample...")
    params := map[string]string{"symbol": "BTCUSDT", "side": "BUY", "type": "LIMIT", "quantity": "0.001", "price": "90000", "timeInForce": "GTC"}
    url, _ := signRequest(params)
    resp, _ := http.Post(url, "application/json", nil)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var result map[string]interface{}
    json.Unmarshal(body, &result)
    fmt.Printf("✅ Result: %v\n", result)
}

// Sample: Futures/Spot Operations
// See README.md for dependencies
use ethers::signers::{LocalWallet, Signer};
use ethers::contract::Eip712;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};

const BASE_URL: &str = "https://www.asterdex-testnet.com/fapi/v3/";
const USER_WALLET: &str = "YOUR_USER_WALLET";
const AGENT_WALLET: &str = "YOUR_AGENT_WALLET";
const AGENT_PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

#[derive(Debug, Clone, Serialize, Deserialize, Eip712, ethers::contract::EthAbiType)]
#[eip712(name = "AsterSignTransaction", version = "1", chain_id = 714, verifying_contract = "0x0000000000000000000000000000000000000000")]
struct Message { msg: String }

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Running sample...");
    let params = HashMap::from([("symbol", "BTCUSDT"), ("side", "BUY"), ("type", "LIMIT"), ("quantity", "0.001"), ("price", "90000"), ("timeInForce", "GTC")]);
    let nonce = SystemTime::now().duration_since(UNIX_EPOCH)?.as_micros().to_string();
    let keys = ["symbol", "side", "type", "quantity", "price", "timeInForce"];
    let mut val_parts = Vec::new();
    for key in keys.iter() {
        if let Some(value) = params.get(key) {
            val_parts.push(format!("{}={}", key, value));
        }
    }
    let val = format!("{}&nonce={}&user={}&signer={}", val_parts.join("&"), nonce, USER_WALLET, AGENT_WALLET);
    let message = Message { msg: val.clone() };
    let wallet: LocalWallet = AGENT_PRIVATE_KEY.parse()?;
    let signature = wallet.sign_typed_data(&message).await?;
    let url = format!("{}order?{}&signature=0x{}", BASE_URL, val, hex::encode(signature.to_vec()));
    
    let client = reqwest::Client::new();
    let response = client.post(&url).send().await?;
    let body: serde_json::Value = response.json().await?;
    println!("✅ Result: {:?}", body);
    Ok(())
}

# Cancel Spot Order
# Endpoint: /api/v3/order

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/api/v3/order"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        "symbol": "BTCUSDT",
        "orderId": 123456
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Cancel Spot Order
// Endpoint: /api/v3/order

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/api/v3/order"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    params.Add("symbol", "BTCUSDT")
    params.Add("orderId", "123456")
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Cancel Spot Order
// Endpoint: /api/v3/order
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/api/v3/order";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    params.insert("symbol", "BTCUSDT");
    params.insert("orderId", "123456");

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

#!/usr/bin/env python3
"""
Sample: Spot Cancel All Orders
Demonstrates how to cancel all open orders for a symbol on AsterDex Spot API.
"""

import requests
import time
from eth_account import Account
from eth_account.messages import encode_defunct
from eth_account.messages import encode_typed_data

CONFIG = {
    'BASE_URL': 'https://www.asterdex-testnet.com/api/v3',
    'USER_WALLET': 'YOUR_USER_WALLET',
    'AGENT_WALLET': 'YOUR_AGENT_WALLET',
    'AGENT_PRIVATE_KEY': 'YOUR_AGENT_PRIVATE_KEY'
}

def sign_spot_request(params):
    """Sign a Spot API request using EIP-712."""
    nonce = str(int(time.time() * 1000000))
    
    param_parts = []
    for key in ['symbol', 'side', 'type', 'quantity', 'quoteOrderQty', 'price', 'timeInForce', 'orderId']:
        if key in params and params[key] is not None:
            param_parts.append(f"{key}={params[key]}")
    
    param_string = '&'.join(param_parts)
    param_string += f"&nonce={nonce}&user={CONFIG['USER_WALLET']}&signer={CONFIG['AGENT_WALLET']}"
    
    domain = {
        'name': 'AsterSignTransaction',
        'version': '1',
        'chainId': 714,
        'verifyingContract': '0x0000000000000000000000000000000000000000'
    }
    
    types = {
        'EIP712Domain': [
            {'name': 'name', 'type': 'string'},
            {'name': 'version', 'type': 'string'},
            {'name': 'chainId', 'type': 'uint256'},
            {'name': 'verifyingContract', 'type': 'address'}
        ],
        'Message': [{'name': 'msg', 'type': 'string'}]
    }
    
    message = {'msg': param_string}
    structured_data = {'types': types, 'primaryType': 'Message', 'domain': domain, 'message': message}
    
    account = Account.from_key(CONFIG['AGENT_PRIVATE_KEY'].strip())
    signable_message = encode_typed_data(full_message=structured_data)
    signed_message = account.sign_message(signable_message)
    signature = signed_message.signature.hex()
    
    return f"{CONFIG['BASE_URL']}/openOrders?{param_string}&signature={signature}"

def cancel_all():
    """Cancel all open orders for ASTERUSDT."""
    print("🚀 Cancelling All Open Spot Orders...")
    
    params = {'symbol': 'ASTERUSDT'}
    
    try:
        url = sign_spot_request(params)
        response = requests.delete(url)
        response.raise_for_status()
        data = response.json()
        print(f"✅ Success: {len(data)} orders cancelled")
        print(data)
    except requests.exceptions.HTTPError as e:
        print(f"❌ HTTP Error: {e}")
        print(e.response.text if e.response else "")
    except Exception as e:
        print(f"❌ Error: {e}")

if __name__ == '__main__':
    cancel_all()

// Sample: Futures Operations
// See README.md for setup instructions
package main

import (
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
    "github.com/ethereum/go-ethereum/common/math"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/signer/core/apitypes"
)

type Config struct {
    BaseURL, UserWallet, AgentWallet, AgentPrivateKey string
}

var config = Config{
    BaseURL: "https://www.asterdex-testnet.com/fapi/v3",
    UserWallet: "YOUR_USER_WALLET",
    AgentWallet: "YOUR_AGENT_WALLET",
    AgentPrivateKey: "YOUR_AGENT_PRIVATE_KEY",
}

func signRequest(params map[string]string) (string, error) {
    nonce := fmt.Sprintf("%d", time.Now().UnixNano()/1000)
    keys := []string{"symbol", "side", "type", "quantity", "price", "timeInForce", "leverage", "orderId"}
    var valParts []string
    for _, key := range keys {
        if val, ok := params[key]; ok && val != "" {
            valParts = append(valParts, fmt.Sprintf("%s=%s", key, val))
        }
    }
    val := ""
    for i, part := range valParts {
        if i > 0 { val += "&" }
        val += part
    }
    if stopPrice, ok := params["stopPrice"]; ok {
        val += fmt.Sprintf("&stopPrice=%s", stopPrice)
    }
    val += fmt.Sprintf("&nonce=%s&user=%s&signer=%s", nonce, config.UserWallet, config.AgentWallet)
    
    domain := apitypes.TypedDataDomain{Name: "AsterSignTransaction", Version: "1", ChainId: math.NewHexOrDecimal256(714), VerifyingContract: "0x0000000000000000000000000000000000000000"}
    typedData := apitypes.TypedData{Types: apitypes.Types{"EIP712Domain": []apitypes.Type{{Name: "name", Type: "string"}, {Name: "version", Type: "string"}, {Name: "chainId", Type: "uint256"}, {Name: "verifyingContract", Type: "address"}}, "Message": []apitypes.Type{{Name: "msg", Type: "string"}}}, PrimaryType: "Message", Domain: domain, Message: apitypes.TypedDataMessage{"msg": val}}
    
    privKeyBytes, _ := hex.DecodeString(config.AgentPrivateKey)
    privKey, _ := crypto.ToECDSA(privKeyBytes)
    domainSeparator, _ := typedData.HashStruct("EIP712Domain", typedData.Domain.Map())
    typedDataHash, _ := typedData.HashStruct(typedData.PrimaryType, typedData.Message)
    rawData := []byte(fmt.Sprintf("\x19\x01%s%s", string(domainSeparator), string(typedDataHash)))
    challengeHash := crypto.Keccak256Hash(rawData)
    signature, _ := crypto.Sign(challengeHash.Bytes(), privKey)
    signature[64] += 27
    
    return fmt.Sprintf("%s/order?%s&signature=0x%s", config.BaseURL, val, hex.EncodeToString(signature)), nil
}

func main() {
    fmt.Println("🚀 Running sample...")
    params := map[string]string{"symbol": "BTCUSDT", "side": "BUY", "type": "LIMIT", "quantity": "0.001", "price": "90000", "timeInForce": "GTC"}
    url, _ := signRequest(params)
    resp, _ := http.Post(url, "application/json", nil)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var result map[string]interface{}
    json.Unmarshal(body, &result)
    fmt.Printf("✅ Result: %v\n", result)
}

// Sample: Futures/Spot Operations
// See README.md for dependencies
use ethers::signers::{LocalWallet, Signer};
use ethers::contract::Eip712;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};

const BASE_URL: &str = "https://www.asterdex-testnet.com/fapi/v3/";
const USER_WALLET: &str = "YOUR_USER_WALLET";
const AGENT_WALLET: &str = "YOUR_AGENT_WALLET";
const AGENT_PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

#[derive(Debug, Clone, Serialize, Deserialize, Eip712, ethers::contract::EthAbiType)]
#[eip712(name = "AsterSignTransaction", version = "1", chain_id = 714, verifying_contract = "0x0000000000000000000000000000000000000000")]
struct Message { msg: String }

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Running sample...");
    let params = HashMap::from([("symbol", "BTCUSDT"), ("side", "BUY"), ("type", "LIMIT"), ("quantity", "0.001"), ("price", "90000"), ("timeInForce", "GTC")]);
    let nonce = SystemTime::now().duration_since(UNIX_EPOCH)?.as_micros().to_string();
    let keys = ["symbol", "side", "type", "quantity", "price", "timeInForce"];
    let mut val_parts = Vec::new();
    for key in keys.iter() {
        if let Some(value) = params.get(key) {
            val_parts.push(format!("{}={}", key, value));
        }
    }
    let val = format!("{}&nonce={}&user={}&signer={}", val_parts.join("&"), nonce, USER_WALLET, AGENT_WALLET);
    let message = Message { msg: val.clone() };
    let wallet: LocalWallet = AGENT_PRIVATE_KEY.parse()?;
    let signature = wallet.sign_typed_data(&message).await?;
    let url = format!("{}order?{}&signature=0x{}", BASE_URL, val, hex::encode(signature.to_vec()));
    
    let client = reqwest::Client::new();
    let response = client.post(&url).send().await?;
    let body: serde_json::Value = response.json().await?;
    println!("✅ Result: {:?}", body);
    Ok(())
}

# Get Open Spot Orders
# Endpoint: /api/v3/openOrders

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/api/v3/openOrders"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        "symbol": "BTCUSDT"
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Open Spot Orders
// Endpoint: /api/v3/openOrders

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/api/v3/openOrders"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    params.Add("symbol", "BTCUSDT")
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Open Spot Orders
// Endpoint: /api/v3/openOrders
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/api/v3/openOrders";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    params.insert("symbol", "BTCUSDT");

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

# Get Spot Order History
# Endpoint: /api/v3/allOrders

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/api/v3/allOrders"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        "symbol": "BTCUSDT"
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Spot Order History
// Endpoint: /api/v3/allOrders

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/api/v3/allOrders"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    params.Add("symbol", "BTCUSDT")
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Spot Order History
// Endpoint: /api/v3/allOrders
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/api/v3/allOrders";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    params.insert("symbol", "BTCUSDT");

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

#!/usr/bin/env python3
"""
Sample: Futures Account Data
Demonstrates how to fetch Futures account information (balance, positions).
"""

import requests
import time
from eth_account import Account
from eth_account.messages import encode_defunct
from eth_account.messages import encode_typed_data

CONFIG = {
    'BASE_URL': 'https://www.asterdex-testnet.com/fapi/v3',
    'USER_WALLET': 'YOUR_USER_WALLET',
    'AGENT_WALLET': 'YOUR_AGENT_WALLET',
    'AGENT_PRIVATE_KEY': 'YOUR_AGENT_PRIVATE_KEY'
}

def sign_futures_request(endpoint):
    """Sign a Futures API request for account data (no business params)."""
    nonce = str(int(time.time() * 1000000))
    param_string = f"nonce={nonce}&user={CONFIG['USER_WALLET']}&signer={CONFIG['AGENT_WALLET']}"
    
    # EIP-712 Domain and Types
    domain_data = {
        'name': 'AsterSignTransaction',
        'version': '1',
        'chainId': 714,
        'verifyingContract': '0x0000000000000000000000000000000000000000'
    }
    
    types = {
        'EIP712Domain': [
            {'name': 'name', 'type': 'string'},
            {'name': 'version', 'type': 'string'},
            {'name': 'chainId', 'type': 'uint256'},
            {'name': 'verifyingContract', 'type': 'address'}
        ],
        'Message': [{'name': 'msg', 'type': 'string'}]
    }
    
    structured_data = {
        'types': types,
        'primaryType': 'Message',
        'domain': domain_data,
        'message': {'msg': param_string}
    }
    
    # Sign using sign_typed_data (requires eth_account >= 0.5.0)
    account = Account.from_key(CONFIG['AGENT_PRIVATE_KEY'].strip())
    signable_message = encode_typed_data(full_message=structured_data)
    signed_message = account.sign_message(signable_message)
    signature = signed_message.signature.hex()
    
    return f"{CONFIG['BASE_URL']}{endpoint}?{param_string}&signature={signature}"

def run():
    print("🚀 Futures Account Data...")
    try:
        url = sign_futures_request('/account')
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        data = response.json()
        print(f"✅ Balance: {data.get('totalWalletBalance', 'N/A')}")
    except Exception as e:
        print(f"❌ Error: {e}")

if __name__ == '__main__':
    run()

// Sample: Futures Account Data
// Demonstrates how to fetch Futures account information.

package main

import (
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
		"time"

	"github.com/ethereum/go-ethereum/common/math"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/ethereum/go-ethereum/signer/core/apitypes"
)

type Config struct {
	BaseURL          string
	UserWallet       string
	AgentWallet      string
	AgentPrivateKey  string
}

var config = Config{
	BaseURL:         "https://www.asterdex-testnet.com/fapi/v3",
	UserWallet:      "YOUR_USER_WALLET",
	AgentWallet:     "YOUR_AGENT_WALLET",
	AgentPrivateKey: "YOUR_AGENT_PRIVATE_KEY",
}

func signFuturesRequest(endpoint string) (string, error) {
	nonce := fmt.Sprintf("%d", time.Now().UnixNano()/1000)
	paramString := fmt.Sprintf("nonce=%s&user=%s&signer=%s", nonce, config.UserWallet, config.AgentWallet)
	
	domain := apitypes.TypedDataDomain{
		Name:              "AsterSignTransaction",
		Version:           "1",
		ChainId:           math.NewHexOrDecimal256(714),
		VerifyingContract: "0x0000000000000000000000000000000000000000",
	}
	
	typedData := apitypes.TypedData{
		Types: apitypes.Types{
			"EIP712Domain": []apitypes.Type{
				{Name: "name", Type: "string"},
				{Name: "version", Type: "string"},
				{Name: "chainId", Type: "uint256"},
				{Name: "verifyingContract", Type: "address"},
			},
			"Message": []apitypes.Type{
				{Name: "msg", Type: "string"},
			},
		},
		PrimaryType: "Message",
		Domain:      domain,
		Message: apitypes.TypedDataMessage{
			"msg": paramString,
		},
	}
	
	privKeyBytes, _ := hex.DecodeString(config.AgentPrivateKey)
	privKey, _ := crypto.ToECDSA(privKeyBytes)
	
	domainSeparator, _ := typedData.HashStruct("EIP712Domain", typedData.Domain.Map())
	typedDataHash, _ := typedData.HashStruct(typedData.PrimaryType, typedData.Message)
	
	rawData := []byte(fmt.Sprintf("\x19\x01%s%s", string(domainSeparator), string(typedDataHash)))
	challengeHash := crypto.Keccak256Hash(rawData)
	
	signature, _ := crypto.Sign(challengeHash.Bytes(), privKey)
	signature[64] += 27
	
	return fmt.Sprintf("%s%s?%s&signature=0x%s", config.BaseURL, endpoint, paramString, hex.EncodeToString(signature)), nil
}

func main() {
	fmt.Println("🚀 Futures Account Data...")
	
	url, _ := signFuturesRequest("/account")
	
	resp, err := http.Get(url)
	if err != nil {
		fmt.Printf("❌ Request error: %v\\n", err)
		return
	}
	defer resp.Body.Close()
	
	body, _ := io.ReadAll(resp.Body)
	
	var result map[string]interface{}
	json.Unmarshal(body, &result)
	
	fmt.Printf("✅ Wallet Balance: %v\\n", result["totalWalletBalance"])
	fmt.Printf("✅ Cross Wallet Balance: %v\\n", result["totalCrossWalletBalance"])
}

// Sample: Futures Account Data
// See README.md for dependencies
use ethers::signers::{LocalWallet, Signer};
use ethers::contract::Eip712;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};

// Fix URL with trailing slash
const BASE_URL: &str = "https://www.asterdex-testnet.com/fapi/v3/";
const USER_WALLET: &str = "YOUR_USER_WALLET";
const AGENT_WALLET: &str = "YOUR_AGENT_WALLET";
const AGENT_PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

#[derive(Debug, Clone, Serialize, Deserialize, Eip712, ethers::contract::EthAbiType)]
#[eip712(name = "AsterSignTransaction", version = "1", chain_id = 714, verifying_contract = "0x0000000000000000000000000000000000000000")]
struct Message { msg: String }

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Running Futures Account Data sample...");

    // 1. Prepare Parameters (Account Data usually needs no params, just auth)
    let nonce = SystemTime::now().duration_since(UNIX_EPOCH)?.as_micros().to_string();
    
    // Construct param string for signing
    // For account data, usually: nonce=...&user=...&signer=...
    let val = format!("nonce={}&user={}&signer={}", nonce, USER_WALLET, AGENT_WALLET);
    
    let message = Message { msg: val.clone() };
    let wallet: LocalWallet = AGENT_PRIVATE_KEY.parse()?;
    
    // 2. Sign
    let signature = wallet.sign_typed_data(&message).await?;
    
    // 3. Construct URL (GET request)
    // BASE_URL already has slash (fixed above)
    let url = format!("{}account?{}&signature=0x{}", BASE_URL, val, hex::encode(signature.to_vec()));
    
    println!("Requesting: {}", url);

    let client = reqwest::Client::new();
    // GET request
    let response = client.get(&url).send().await?;
    
    if !response.status().is_success() {
        println!("❌ Request failed: {:?}", response.status());
        let text = response.text().await?;
        println!("Body: {}", text);
        return Ok(());
    }

    let body: serde_json::Value = response.json().await?;
    println!("✅ Result: {:?}", body);
    Ok(())
}

#!/usr/bin/env python3
"""
Sample: Futures LIMIT BUY Order
Demonstrates how to place a limit buy order on AsterDex Futures API using EIP-712 signing.
"""

import requests
import time
from eth_account import Account
from eth_account.messages import encode_defunct
from eth_account.messages import encode_typed_data

CONFIG = {
    'BASE_URL': 'https://www.asterdex-testnet.com/fapi/v3',
    'USER_WALLET': 'YOUR_USER_WALLET',  # Replace with your connected wallet address
    'AGENT_WALLET': 'YOUR_AGENT_WALLET',  # The agent wallet you authorized
    'AGENT_PRIVATE_KEY': 'YOUR_AGENT_PRIVATE_KEY'  # Keep this secret!
}

def sign_futures_request(params):
    """Sign a Futures API request using EIP-712 typed data signing."""
    nonce = str(int(time.time() * 1000000))
    
    # STRICT KEYS LIST (order matters!)
    STRICT_KEYS = ['symbol', 'side', 'type', 'quantity', 'price', 'timeInForce', 'leverage', 'orderId']
    val_parts = []
    
    for key in STRICT_KEYS:
        if key in params and params[key] is not None:
            val_parts.append(f"{key}={params[key]}")
    
    val = '&'.join(val_parts)
    val += f"&nonce={nonce}&user={CONFIG['USER_WALLET']}&signer={CONFIG['AGENT_WALLET']}"
    
    # EIP-712 Domain
    domain = {
        'name': 'AsterSignTransaction',
        'version': '1',
        'chainId': 714,
        'verifyingContract': '0x0000000000000000000000000000000000000000'
    }
    
    # Message Types
    types = {
        'EIP712Domain': [
            {'name': 'name', 'type': 'string'},
            {'name': 'version', 'type': 'string'},
            {'name': 'chainId', 'type': 'uint256'},
            {'name': 'verifyingContract', 'type': 'address'}
        ],
        'Message': [
            {'name': 'msg', 'type': 'string'}
        ]
    }
    
    # Message Value
    message = {'msg': val}
    
    # Create structured data
    structured_data = {
        'types': types,
        'primaryType': 'Message',
        'domain': domain,
        'message': message
    }
    
    # Sign
    account = Account.from_key(CONFIG['AGENT_PRIVATE_KEY'].strip())
    signable_message = encode_typed_data(full_message=structured_data)
    signed_message = account.sign_message(signable_message)
    signature = signed_message.signature.hex()
    
    return f"{CONFIG['BASE_URL']}/order?{val}&signature={signature}"

def run():
    """Place a Futures LIMIT BUY order."""
    print("🚀 Placing Futures LIMIT BUY...")
    
    params = {
        'symbol': 'BTCUSDT',
        'side': 'BUY',
        'type': 'LIMIT',
        'quantity': '0.001',
        'price': '90000',
        'timeInForce': 'GTC'
    }
    
    try:
        url = sign_futures_request(params)
        response = requests.post(url)
        response.raise_for_status()
        data = response.json()
        print(f"✅ Success: Order ID {data.get('orderId')}")
        print(data)
    except requests.exceptions.HTTPError as e:
        print(f"❌ HTTP Error: {e}")
        print(e.response.text if e.response else "No response")
    except Exception as e:
        print(f"❌ Error: {e}")

if __name__ == '__main__':
    run()

// Sample: Futures LIMIT BUY Order
// Demonstrates how to place a limit buy order on AsterDex Futures API using EIP-712 signing.

package main

import (
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"strings"
	"time"

	"github.com/ethereum/go-ethereum/common/math"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/ethereum/go-ethereum/signer/core/apitypes"
)

type Config struct {
	BaseURL          string
	UserWallet       string
	AgentWallet      string
	AgentPrivateKey  string
}

var config = Config{
	BaseURL:         "https://www.asterdex-testnet.com/fapi/v3",
	UserWallet:      "YOUR_USER_WALLET",
	AgentWallet:     "YOUR_AGENT_WALLET",
	AgentPrivateKey: "YOUR_AGENT_PRIVATE_KEY", // Without 0x prefix
}

func signFuturesRequest(params map[string]string) (string, error) {
	nonce := fmt.Sprintf("%d", time.Now().UnixNano()/1000)
	
	// STRICT KEYS ORDER
	strictKeys := []string{"symbol", "side", "type", "quantity", "price", "timeInForce", "leverage", "orderId"}
	var valParts []string
	
	for _, key := range strictKeys {
		if val, ok := params[key]; ok && val != "" {
			valParts = append(valParts, fmt.Sprintf("%s=%s", key, val))
		}
	}
	
	val := strings.Join(valParts, "&")
	val += fmt.Sprintf("&nonce=%s&user=%s&signer=%s", nonce, config.UserWallet, config.AgentWallet)
	
	// EIP-712 Domain
	domain := apitypes.TypedDataDomain{
		Name:              "AsterSignTransaction",
		Version:           "1",
		ChainId:           math.NewHexOrDecimal256(714),
		VerifyingContract: "0x0000000000000000000000000000000000000000",
	}
	
	// Message Types
	typedData := apitypes.TypedData{
		Types: apitypes.Types{
			"EIP712Domain": []apitypes.Type{
				{Name: "name", Type: "string"},
				{Name: "version", Type: "string"},
				{Name: "chainId", Type: "uint256"},
				{Name: "verifyingContract", Type: "address"},
			},
			"Message": []apitypes.Type{
				{Name: "msg", Type: "string"},
			},
		},
		PrimaryType: "Message",
		Domain:      domain,
		Message: apitypes.TypedDataMessage{
			"msg": val,
		},
	}
	
	// Sign
	privKeyBytes, err := hex.DecodeString(config.AgentPrivateKey)
	if err != nil {
		return "", err
	}
	privKey, err := crypto.ToECDSA(privKeyBytes)
	if err != nil {
		return "", err
	}
	
	domainSeparator, err := typedData.HashStruct("EIP712Domain", typedData.Domain.Map())
	if err != nil {
		return "", err
	}
	
	typedDataHash, err := typedData.HashStruct(typedData.PrimaryType, typedData.Message)
	if err != nil {
		return "", err
	}
	
	rawData := []byte(fmt.Sprintf("\x19\x01%s%s", string(domainSeparator), string(typedDataHash)))
	challengeHash := crypto.Keccak256Hash(rawData)
	
	signature, err := crypto.Sign(challengeHash.Bytes(), privKey)
	if err != nil {
		return "", err
	}
	
	signature[64] += 27 // v value adjustment
	
	return fmt.Sprintf("%s/order?%s&signature=0x%s", config.BaseURL, val, hex.EncodeToString(signature)), nil
}

func main() {
	fmt.Println("🚀 Placing Futures LIMIT BUY...")
	
	params := map[string]string{
		"symbol":      "BTCUSDT",
		"side":        "BUY",
		"type":        "LIMIT",
		"quantity":    "0.001",
		"price":       "90000",
		"timeInForce": "GTC",
	}
	
	url, err := signFuturesRequest(params)
	if err != nil {
		fmt.Printf("❌ Signing error: %v\\n", err)
		return
	}
	
	resp, err := http.Post(url, "application/json", nil)
	if err != nil {
		fmt.Printf("❌ Request error: %v\\n", err)
		return
	}
	defer resp.Body.Close()
	
	body, _ := io.ReadAll(resp.Body)
	
	if resp.StatusCode >= 400 {
		fmt.Printf("❌ HTTP %d: %s\\n", resp.StatusCode, string(body))
		return
	}
	
	var result map[string]interface{}
	json.Unmarshal(body, &result)
	fmt.Printf("✅ Success: Order ID %v\\n", result["orderId"])
	fmt.Printf("%s\\n", string(body))
}

// Sample: Futures LIMIT BUY Order
// Demonstrates how to place a limit buy order on AsterDex Futures API.

use ethers::contract::Eip712;
use ethers::core::types::U256;
use ethers::signers::{LocalWallet, Signer};
use ethers::types::H160;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};

const BASE_URL: &str = "https://www.asterdex-testnet.com/fapi/v3/";
const USER_WALLET: &str = "YOUR_USER_WALLET";
const AGENT_WALLET: &str = "YOUR_AGENT_WALLET";
const AGENT_PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

#[derive(Debug, Clone, Serialize, Deserialize, Eip712, ethers::contract::EthAbiType)]
#[eip712(
    name = "AsterSignTransaction",
    version = "1",
    chain_id = 714,
    verifying_contract = "0x0000000000000000000000000000000000000000"
)]

struct Message {
    msg: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Placing Futures LIMIT BUY...");
    
    let params = HashMap::from([
        ("symbol", "BTCUSDT"),
        ("side", "BUY"),
        ("type", "LIMIT"),
        ("quantity", "0.001"),
        ("price", "90000"),
        ("timeInForce", "GTC"),
    ]);
    
    let url = sign_futures_request(params).await?;
    
    let client = reqwest::Client::new();
    let response = client.post(&url).send().await?;
    
    if !response.status().is_success() {
        let error_text = response.text().await?;
        println!("❌ HTTP Error: {}", error_text);
        return Ok(());
    }
    
    let body: serde_json::Value = response.json().await?;
    println!("✅ Success: Order ID {:?}", body["orderId"]);
    println!("{}", serde_json::to_string_pretty(&body)?);
    
    Ok(())
}

async fn sign_futures_request(params: HashMap<&str, &str>) -> Result<String, Box<dyn std::error::Error>> {
    let nonce = SystemTime::now().duration_since(UNIX_EPOCH)?.as_micros().to_string();
    
    let strict_keys = ["symbol", "side", "type", "quantity", "price", "timeInForce", "leverage", "orderId"];
    let mut val_parts = Vec::new();
    
    for key in strict_keys.iter() {
        if let Some(value) = params.get(key) {
            val_parts.push(format!("{}={}", key, value));
        }
    }
    
    let val = format!(
        "{}&nonce={}&user={}&signer={}",
        val_parts.join("&"),
        nonce,
        USER_WALLET,
        AGENT_WALLET
    );
    
    let message = Message { msg: val.clone() };
    
    let wallet: LocalWallet = AGENT_PRIVATE_KEY.parse()?;
    let signature = wallet.sign_typed_data(&message).await?;
    
    Ok(format!("{}order?{}&signature=0x{}", BASE_URL, val, hex::encode(signature.to_vec())))
}

# Cancel Futures Order
# Endpoint: /fapi/v3/order

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/fapi/v3/order"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        "symbol": "BTCUSDT",
        "orderId": 123456
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Cancel Futures Order
// Endpoint: /fapi/v3/order

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/fapi/v3/order"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    params.Add("symbol", "BTCUSDT")
    params.Add("orderId", "123456")
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Cancel Futures Order
// Endpoint: /fapi/v3/order
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/fapi/v3/order";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    params.insert("symbol", "BTCUSDT");
    params.insert("orderId", "123456");

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

#!/usr/bin/env python3
"""
Sample: Futures Cancel All Orders
Demonstrates how to cancel all open orders for a symbol on AsterDex Futures API.
"""

import requests
import time
from eth_account import Account
from eth_account.messages import encode_defunct
from eth_account.messages import encode_typed_data

CONFIG = {
    'BASE_URL': 'https://www.asterdex-testnet.com/fapi/v3',
    'USER_WALLET': 'YOUR_USER_WALLET',
    'AGENT_WALLET': 'YOUR_AGENT_WALLET',
    'AGENT_PRIVATE_KEY': 'YOUR_AGENT_PRIVATE_KEY'
}

def sign_futures_request(params):
    """Sign a Futures API request using EIP-712."""
    nonce = str(int(time.time() * 1000000))
    
    STRICT_KEYS = ['symbol', 'side', 'type', 'quantity', 'price', 'timeInForce', 'leverage', 'orderId']
    val_parts = []
    
    for key in STRICT_KEYS:
        if key in params and params[key] is not None:
            val_parts.append(f"{key}={params[key]}")
    
    val = '&'.join(val_parts)
    val += f"&nonce={nonce}&user={CONFIG['USER_WALLET']}&signer={CONFIG['AGENT_WALLET']}"
    
    domain = {
        'name': 'AsterSignTransaction',
        'version': '1',
        'chainId': 714,
        'verifyingContract': '0x0000000000000000000000000000000000000000'
    }
    
    types = {
        'EIP712Domain': [
            {'name': 'name', 'type': 'string'},
            {'name': 'version', 'type': 'string'},
            {'name': 'chainId', 'type': 'uint256'},
            {'name': 'verifyingContract', 'type': 'address'}
        ],
        'Message': [{'name': 'msg', 'type': 'string'}]
    }
    
    message = {'msg': val}
    structured_data = {'types': types, 'primaryType': 'Message', 'domain': domain, 'message': message}
    
    account = Account.from_key(CONFIG['AGENT_PRIVATE_KEY'].strip())
    signable_message = encode_typed_data(full_message=structured_data)
    signed_message = account.sign_message(signable_message)
    signature = signed_message.signature.hex()
    
    return f"{CONFIG['BASE_URL']}/allOpenOrders?{val}&signature={signature}"

def cancel_all():
    """Cancel all open orders for BTCUSDT."""
    print("🚀 Cancelling All Open Orders...")
    
    params = {'symbol': 'BTCUSDT'}
    
    try:
        url = sign_futures_request(params)
        response = requests.delete(url)
        response.raise_for_status()
        data = response.json()
        print(f"✅ Success: {len(data)} orders cancelled")
        print(data)
    except requests.exceptions.HTTPError as e:
        print(f"❌ HTTP Error: {e}")
        print(e.response.text if e.response else "")
    except Exception as e:
        print(f"❌ Error: {e}")

if __name__ == '__main__':
    cancel_all()

// Sample: Futures Operations
// See README.md for setup instructions
package main

import (
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
    "github.com/ethereum/go-ethereum/common/math"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/signer/core/apitypes"
)

type Config struct {
    BaseURL, UserWallet, AgentWallet, AgentPrivateKey string
}

var config = Config{
    BaseURL: "https://www.asterdex-testnet.com/fapi/v3",
    UserWallet: "YOUR_USER_WALLET",
    AgentWallet: "YOUR_AGENT_WALLET",
    AgentPrivateKey: "YOUR_AGENT_PRIVATE_KEY",
}

func signRequest(params map[string]string) (string, error) {
    nonce := fmt.Sprintf("%d", time.Now().UnixNano()/1000)
    keys := []string{"symbol", "side", "type", "quantity", "price", "timeInForce", "leverage", "orderId"}
    var valParts []string
    for _, key := range keys {
        if val, ok := params[key]; ok && val != "" {
            valParts = append(valParts, fmt.Sprintf("%s=%s", key, val))
        }
    }
    val := ""
    for i, part := range valParts {
        if i > 0 { val += "&" }
        val += part
    }
    if stopPrice, ok := params["stopPrice"]; ok {
        val += fmt.Sprintf("&stopPrice=%s", stopPrice)
    }
    val += fmt.Sprintf("&nonce=%s&user=%s&signer=%s", nonce, config.UserWallet, config.AgentWallet)
    
    domain := apitypes.TypedDataDomain{Name: "AsterSignTransaction", Version: "1", ChainId: math.NewHexOrDecimal256(714), VerifyingContract: "0x0000000000000000000000000000000000000000"}
    typedData := apitypes.TypedData{Types: apitypes.Types{"EIP712Domain": []apitypes.Type{{Name: "name", Type: "string"}, {Name: "version", Type: "string"}, {Name: "chainId", Type: "uint256"}, {Name: "verifyingContract", Type: "address"}}, "Message": []apitypes.Type{{Name: "msg", Type: "string"}}}, PrimaryType: "Message", Domain: domain, Message: apitypes.TypedDataMessage{"msg": val}}
    
    privKeyBytes, _ := hex.DecodeString(config.AgentPrivateKey)
    privKey, _ := crypto.ToECDSA(privKeyBytes)
    domainSeparator, _ := typedData.HashStruct("EIP712Domain", typedData.Domain.Map())
    typedDataHash, _ := typedData.HashStruct(typedData.PrimaryType, typedData.Message)
    rawData := []byte(fmt.Sprintf("\x19\x01%s%s", string(domainSeparator), string(typedDataHash)))
    challengeHash := crypto.Keccak256Hash(rawData)
    signature, _ := crypto.Sign(challengeHash.Bytes(), privKey)
    signature[64] += 27
    
    return fmt.Sprintf("%s/order?%s&signature=0x%s", config.BaseURL, val, hex.EncodeToString(signature)), nil
}

func main() {
    fmt.Println("🚀 Running sample...")
    params := map[string]string{"symbol": "BTCUSDT", "side": "BUY", "type": "LIMIT", "quantity": "0.001", "price": "90000", "timeInForce": "GTC"}
    url, _ := signRequest(params)
    resp, _ := http.Post(url, "application/json", nil)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var result map[string]interface{}
    json.Unmarshal(body, &result)
    fmt.Printf("✅ Result: %v\n", result)
}

// Sample: Futures/Spot Operations
// See README.md for dependencies
use ethers::signers::{LocalWallet, Signer};
use ethers::contract::Eip712;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};

const BASE_URL: &str = "https://www.asterdex-testnet.com/fapi/v3/";
const USER_WALLET: &str = "YOUR_USER_WALLET";
const AGENT_WALLET: &str = "YOUR_AGENT_WALLET";
const AGENT_PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

#[derive(Debug, Clone, Serialize, Deserialize, Eip712, ethers::contract::EthAbiType)]
#[eip712(name = "AsterSignTransaction", version = "1", chain_id = 714, verifying_contract = "0x0000000000000000000000000000000000000000")]
struct Message { msg: String }

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Running sample...");
    let params = HashMap::from([("symbol", "BTCUSDT"), ("side", "BUY"), ("type", "LIMIT"), ("quantity", "0.001"), ("price", "90000"), ("timeInForce", "GTC")]);
    let nonce = SystemTime::now().duration_since(UNIX_EPOCH)?.as_micros().to_string();
    let keys = ["symbol", "side", "type", "quantity", "price", "timeInForce"];
    let mut val_parts = Vec::new();
    for key in keys.iter() {
        if let Some(value) = params.get(key) {
            val_parts.push(format!("{}={}", key, value));
        }
    }
    let val = format!("{}&nonce={}&user={}&signer={}", val_parts.join("&"), nonce, USER_WALLET, AGENT_WALLET);
    let message = Message { msg: val.clone() };
    let wallet: LocalWallet = AGENT_PRIVATE_KEY.parse()?;
    let signature = wallet.sign_typed_data(&message).await?;
    let url = format!("{}order?{}&signature=0x{}", BASE_URL, val, hex::encode(signature.to_vec()));
    
    let client = reqwest::Client::new();
    let response = client.post(&url).send().await?;
    let body: serde_json::Value = response.json().await?;
    println!("✅ Result: {:?}", body);
    Ok(())
}

# Get Open Futures Orders
# Endpoint: /fapi/v3/openOrders

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/fapi/v3/openOrders"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        "symbol": "BTCUSDT"
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Open Futures Orders
// Endpoint: /fapi/v3/openOrders

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/fapi/v3/openOrders"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    params.Add("symbol", "BTCUSDT")
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Open Futures Orders
// Endpoint: /fapi/v3/openOrders
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/fapi/v3/openOrders";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    params.insert("symbol", "BTCUSDT");

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

#!/usr/bin/env python3
"""
Sample: Futures Algo Orders (Combined)
Demonstrates placing multiple algo order types.
"""

import requests
import time
from eth_account import Account
from eth_account.messages import encode_defunct
from eth_account.messages import encode_typed_data

CONFIG = {
    'BASE_URL': 'https://www.asterdex-testnet.com/fapi/v3',
    'USER_WALLET': 'YOUR_USER_WALLET',
    'AGENT_WALLET': 'YOUR_AGENT_WALLET',
    'AGENT_PRIVATE_KEY': 'YOUR_AGENT_PRIVATE_KEY'
}

def sign_algo_request(params):
    nonce = str(int(time.time() * 1000000))
    STRICT_KEYS = ['symbol', 'side', 'type', 'quantity', 'price', 'timeInForce', 'leverage', 'orderId']
    val_parts = []
    for key in STRICT_KEYS:
        if key in params and params[key]:
            val_parts.append(f"{key}={params[key]}")
    val = '&'.join(val_parts)
    if 'stopPrice' in params:
        val += f"&stopPrice={params['stopPrice']}"
    val += f"&nonce={nonce}&user={CONFIG['USER_WALLET']}&signer={CONFIG['AGENT_WALLET']}"
    
    domain = {'name': 'AsterSignTransaction', 'version': '1', 'chainId': 714, 'verifyingContract': '0x0000000000000000000000000000000000000000'}
    types = {
        'EIP712Domain': [{'name': 'name', 'type': 'string'}, {'name': 'version', 'type': 'string'}, {'name': 'chainId', 'type': 'uint256'}, {'name': 'verifyingContract', 'type': 'address'}],
        'Message': [{'name': 'msg', 'type': 'string'}]
    }
    structured_data = {'types': types, 'primaryType': 'Message', 'domain': domain, 'message': {'msg': val}}
    account = Account.from_key(CONFIG['AGENT_PRIVATE_KEY'].strip())
    signature = account.sign_message(encode_defunct(text=param_string)).signature.hex()[2:]
    return f"{CONFIG['BASE_URL']}/order?{val}&signature={signature}"

print("🚀 Placing Algo Orders...")
for order_type, stop_price in [('STOP_MARKET', '90000'), ('TAKE_PROFIT_MARKET', '100000')]:
    params = {'symbol': 'BTCUSDT', 'side': 'SELL', 'type': order_type, 'quantity': '0.001', 'stopPrice': stop_price, 'timeInForce': 'GTC'}
    try:
        url = sign_algo_request(params)
        res = requests.post(url)
        res.raise_for_status()
        print(f"✅ {order_type}: {res.json().get('orderId')}")
    except Exception as e:
        print(f"❌ {order_type} failed: {e}")

// Sample: Futures Operations
// See README.md for setup instructions
package main

import (
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
    "github.com/ethereum/go-ethereum/common/math"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/signer/core/apitypes"
)

type Config struct {
    BaseURL, UserWallet, AgentWallet, AgentPrivateKey string
}

var config = Config{
    BaseURL: "https://www.asterdex-testnet.com/fapi/v3",
    UserWallet: "YOUR_USER_WALLET",
    AgentWallet: "YOUR_AGENT_WALLET",
    AgentPrivateKey: "YOUR_AGENT_PRIVATE_KEY",
}

func signRequest(params map[string]string) (string, error) {
    nonce := fmt.Sprintf("%d", time.Now().UnixNano()/1000)
    keys := []string{"symbol", "side", "type", "quantity", "price", "timeInForce", "leverage", "orderId"}
    var valParts []string
    for _, key := range keys {
        if val, ok := params[key]; ok && val != "" {
            valParts = append(valParts, fmt.Sprintf("%s=%s", key, val))
        }
    }
    val := ""
    for i, part := range valParts {
        if i > 0 { val += "&" }
        val += part
    }
    if stopPrice, ok := params["stopPrice"]; ok {
        val += fmt.Sprintf("&stopPrice=%s", stopPrice)
    }
    val += fmt.Sprintf("&nonce=%s&user=%s&signer=%s", nonce, config.UserWallet, config.AgentWallet)
    
    domain := apitypes.TypedDataDomain{Name: "AsterSignTransaction", Version: "1", ChainId: math.NewHexOrDecimal256(714), VerifyingContract: "0x0000000000000000000000000000000000000000"}
    typedData := apitypes.TypedData{Types: apitypes.Types{"EIP712Domain": []apitypes.Type{{Name: "name", Type: "string"}, {Name: "version", Type: "string"}, {Name: "chainId", Type: "uint256"}, {Name: "verifyingContract", Type: "address"}}, "Message": []apitypes.Type{{Name: "msg", Type: "string"}}}, PrimaryType: "Message", Domain: domain, Message: apitypes.TypedDataMessage{"msg": val}}
    
    privKeyBytes, _ := hex.DecodeString(config.AgentPrivateKey)
    privKey, _ := crypto.ToECDSA(privKeyBytes)
    domainSeparator, _ := typedData.HashStruct("EIP712Domain", typedData.Domain.Map())
    typedDataHash, _ := typedData.HashStruct(typedData.PrimaryType, typedData.Message)
    rawData := []byte(fmt.Sprintf("\x19\x01%s%s", string(domainSeparator), string(typedDataHash)))
    challengeHash := crypto.Keccak256Hash(rawData)
    signature, _ := crypto.Sign(challengeHash.Bytes(), privKey)
    signature[64] += 27
    
    return fmt.Sprintf("%s/order?%s&signature=0x%s", config.BaseURL, val, hex.EncodeToString(signature)), nil
}

func main() {
    fmt.Println("🚀 Running sample...")
    params := map[string]string{"symbol": "BTCUSDT", "side": "BUY", "type": "LIMIT", "quantity": "0.001", "price": "90000", "timeInForce": "GTC"}
    url, _ := signRequest(params)
    resp, _ := http.Post(url, "application/json", nil)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var result map[string]interface{}
    json.Unmarshal(body, &result)
    fmt.Printf("✅ Result: %v\n", result)
}

// Sample: Futures/Spot Operations
// See README.md for dependencies
use ethers::signers::{LocalWallet, Signer};
use ethers::contract::Eip712;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};

const BASE_URL: &str = "https://www.asterdex-testnet.com/fapi/v3/";
const USER_WALLET: &str = "YOUR_USER_WALLET";
const AGENT_WALLET: &str = "YOUR_AGENT_WALLET";
const AGENT_PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

#[derive(Debug, Clone, Serialize, Deserialize, Eip712, ethers::contract::EthAbiType)]
#[eip712(name = "AsterSignTransaction", version = "1", chain_id = 714, verifying_contract = "0x0000000000000000000000000000000000000000")]
struct Message { msg: String }

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Running sample...");
    let params = HashMap::from([("symbol", "BTCUSDT"), ("side", "BUY"), ("type", "LIMIT"), ("quantity", "0.001"), ("price", "90000"), ("timeInForce", "GTC")]);
    let nonce = SystemTime::now().duration_since(UNIX_EPOCH)?.as_micros().to_string();
    let keys = ["symbol", "side", "type", "quantity", "price", "timeInForce"];
    let mut val_parts = Vec::new();
    for key in keys.iter() {
        if let Some(value) = params.get(key) {
            val_parts.push(format!("{}={}", key, value));
        }
    }
    let val = format!("{}&nonce={}&user={}&signer={}", val_parts.join("&"), nonce, USER_WALLET, AGENT_WALLET);
    let message = Message { msg: val.clone() };
    let wallet: LocalWallet = AGENT_PRIVATE_KEY.parse()?;
    let signature = wallet.sign_typed_data(&message).await?;
    let url = format!("{}order?{}&signature=0x{}", BASE_URL, val, hex::encode(signature.to_vec()));
    
    let client = reqwest::Client::new();
    let response = client.post(&url).send().await?;
    let body: serde_json::Value = response.json().await?;
    println!("✅ Result: {:?}", body);
    Ok(())
}

# Get Position Risk
# Endpoint: /fapi/v3/positionRisk

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/fapi/v3/positionRisk"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        "symbol": "BTCUSDT"
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Position Risk
// Endpoint: /fapi/v3/positionRisk

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/fapi/v3/positionRisk"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    params.Add("symbol", "BTCUSDT")
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Position Risk
// Endpoint: /fapi/v3/positionRisk
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/fapi/v3/positionRisk";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    params.insert("symbol", "BTCUSDT");

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

# Get Income History
# Endpoint: /fapi/v3/income

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/fapi/v3/income"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Income History
// Endpoint: /fapi/v3/income

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/fapi/v3/income"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Income History
// Endpoint: /fapi/v3/income
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/fapi/v3/income";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}

# Get Funding Rate
# Endpoint: /fapi/v3/fundingRate

import requests
import time
import hmac
import hashlib
from urllib.parse import urlencode

BASE_URL = "https://www.asterdex-testnet.com"
KEY = "YOUR_AGENT_WALLET"
PRIVATE_KEY = "YOUR_AGENT_PRIVATE_KEY"

def get_signature(timestamp, method, path, query_string, private_key):
    payload = f"{timestamp}{method}{path}{query_string}"
    return hmac.new(private_key.encode(), payload.encode(), hashlib.sha256).hexdigest()

def main():
    endpoint = "/fapi/v3/fundingRate"
    timestamp = str(int(time.time() * 1000))
    
    params = {
        "timestamp": timestamp,
        "symbol": "BTCUSDT"
    }
    
    query_string = urlencode(params)
    signature = get_signature(timestamp, "GET", endpoint, query_string, PRIVATE_KEY)
    
    headers = {
        "X-Aster-Client-Id": KEY,
        "X-Aster-Timestamp": timestamp,
        "X-Aster-Signature": signature
    }
    
    try:
        response = requests.get(f"{BASE_URL}{endpoint}?{query_string}", headers=headers)
        print("Response:", response.json())
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Get Funding Rate
// Endpoint: /fapi/v3/fundingRate

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    BaseURL    = "https://www.asterdex-testnet.com"
    PublicKey  = "YOUR_AGENT_WALLET"
    PrivateKey = "YOUR_AGENT_PRIVATE_KEY"
)

func getSignature(timestamp, method, path, query string, secret string) string {
    payload := fmt.Sprintf("%s%s%s%s", timestamp, method, path, query)
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    endpoint := "/fapi/v3/fundingRate"
    timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
    
    params := url.Values{}
    params.Add("timestamp", timestamp)
    params.Add("symbol", "BTCUSDT")
    
    qs := params.Encode()
    signature := getSignature(timestamp, "GET", endpoint, qs, PrivateKey)
    
    req, _ := http.NewRequest("GET", BaseURL+endpoint+"?"+qs, nil)
    req.Header.Set("X-Aster-Client-Id", PublicKey)
    req.Header.Set("X-Aster-Timestamp", timestamp)
    req.Header.Set("X-Aster-Signature", signature)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

// Get Funding Rate
// Endpoint: /fapi/v3/fundingRate
// Add to Cargo.toml: reqwest = {{ version = "0.11", features = ["json"] }}, tokio = {{ version = "1", features = ["full"] }}, hmac = "0.12", sha2="0.10", hex="0.4"

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use hex;

const BASE_URL: &str = "https://www.asterdex-testnet.com";
const PUBLIC_KEY: &str = "YOUR_AGENT_WALLET";
const PRIVATE_KEY: &str = "YOUR_AGENT_PRIVATE_KEY";

type HmacSha256 = Hmac<Sha256>;

fn get_signature(timestamp: &str, method: &str, path: &str, query: &str, secret: &str) -> String {
    let payload = format!("{}{}{}{}", timestamp, method, path, query);
    let mut mac = HmacSha256::new_from_slice(secret.as_bytes()).expect("HMAC can take key of any size");
    mac.update(payload.as_bytes());
    hex::encode(mac.finalize().into_bytes())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = "/fapi/v3/fundingRate";
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
        .to_string();

    let mut params = HashMap::new();
    params.insert("timestamp", timestamp.as_str());
    params.insert("symbol", "BTCUSDT");

    // Sort and encode query string (simplified)
    let query_string = serde_urlencoded::to_string(&params)?;
    let signature = get_signature(&timestamp, "GET", endpoint, &query_string, PRIVATE_KEY);

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{}{}?{}", BASE_URL, endpoint, query_string))
        .header("X-Aster-Client-Id", PUBLIC_KEY)
        .header("X-Aster-Timestamp", timestamp)
        .header("X-Aster-Signature", signature)
        .send()
        .await?
        .text()
        .await?;

    println!("Response: {}", resp);
    Ok(())
}