mirror of
https://github.com/laoxong/nofx.git
synced 2026-06-04 09:58:22 +08:00
feat(trader): add Indodax exchange integration (#1400)
* feat(trader): add Indodax exchange integration - Add IndodaxTrader implementing types.Trader interface for spot trading - Support HMAC-SHA512 authentication with Key/Sign headers - Map spot buy/sell to OpenLong/CloseLong, stub futures-only methods - Wire up auto_trader.go, trader_manager.go, store/exchange.go - Add Indodax to frontend ExchangeConfigModal and ExchangeIcons - Add integration tests with env-var based credentials - Add Indodax logo assets (PNG + SVG) * fix: type validation at server.go for indodax exchange
This commit is contained in:
Muhammad Syaiful Anwar
committed by
GitHub
GitHub
parent
3358c5a53e
commit
27a7491cd1
@@ -0,0 +1,878 @@
|
||||
package indodax
|
||||
|
||||
import (
|
||||
"crypto/hmac"
|
||||
"crypto/sha512"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"math"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"nofx/logger"
|
||||
"nofx/trader/types"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Indodax API endpoints
|
||||
const (
|
||||
indodaxBaseURL = "https://indodax.com"
|
||||
indodaxPublicAPI = "/api"
|
||||
indodaxPrivateAPI = "/tapi"
|
||||
)
|
||||
|
||||
// IndodaxTrader implements types.Trader interface for Indodax Spot Exchange
|
||||
// Indodax is Indonesia's largest crypto exchange, supporting IDR (Indonesian Rupiah) pairs.
|
||||
// Since Indodax is spot-only, futures-specific methods (OpenShort, CloseShort, leverage, etc.)
|
||||
// are gracefully stubbed.
|
||||
type IndodaxTrader struct {
|
||||
apiKey string
|
||||
secretKey string
|
||||
|
||||
httpClient *http.Client
|
||||
nonce int64
|
||||
nonceMutex sync.Mutex
|
||||
|
||||
// Cache for pair info
|
||||
pairCache map[string]*IndodaxPair
|
||||
pairCacheMutex sync.RWMutex
|
||||
pairCacheTime time.Time
|
||||
|
||||
// Cache for balance
|
||||
cachedBalance map[string]interface{}
|
||||
cachedPositions []map[string]interface{}
|
||||
balanceCacheTime time.Time
|
||||
positionCacheTime time.Time
|
||||
cacheDuration time.Duration
|
||||
cacheMutex sync.RWMutex
|
||||
}
|
||||
|
||||
// IndodaxPair represents a trading pair on Indodax
|
||||
type IndodaxPair struct {
|
||||
ID string `json:"id"`
|
||||
Symbol string `json:"symbol"`
|
||||
BaseCurrency string `json:"base_currency"`
|
||||
TradedCurrency string `json:"traded_currency"`
|
||||
TradedCurrencyUnit string `json:"traded_currency_unit"`
|
||||
Description string `json:"description"`
|
||||
TickerID string `json:"ticker_id"`
|
||||
VolumePrecision int `json:"volume_precision"`
|
||||
PricePrecision float64 `json:"price_precision"`
|
||||
PriceRound int `json:"price_round"`
|
||||
Pricescale float64 `json:"pricescale"`
|
||||
TradeMinBaseCurrency float64 `json:"trade_min_base_currency"`
|
||||
TradeMinTradedCurrency float64 `json:"trade_min_traded_currency"`
|
||||
}
|
||||
|
||||
// IndodaxResponse represents the standard Indodax private API response
|
||||
type IndodaxResponse struct {
|
||||
Success int `json:"success"`
|
||||
Return json.RawMessage `json:"return,omitempty"`
|
||||
Error string `json:"error,omitempty"`
|
||||
ErrorCode string `json:"error_code,omitempty"`
|
||||
}
|
||||
|
||||
// IndodaxTicker represents ticker data
|
||||
type IndodaxTicker struct {
|
||||
High string `json:"high"`
|
||||
Low string `json:"low"`
|
||||
Last string `json:"last"`
|
||||
Buy string `json:"buy"`
|
||||
Sell string `json:"sell"`
|
||||
ServerTime int64 `json:"server_time"`
|
||||
}
|
||||
|
||||
// IndodaxTickerResponse wraps ticker response
|
||||
type IndodaxTickerResponse struct {
|
||||
Ticker IndodaxTicker `json:"ticker"`
|
||||
}
|
||||
|
||||
// NewIndodaxTrader creates a new Indodax trader instance
|
||||
func NewIndodaxTrader(apiKey, secretKey string) *IndodaxTrader {
|
||||
return &IndodaxTrader{
|
||||
apiKey: apiKey,
|
||||
secretKey: secretKey,
|
||||
httpClient: &http.Client{Timeout: 30 * time.Second},
|
||||
nonce: time.Now().UnixMilli(),
|
||||
pairCache: make(map[string]*IndodaxPair),
|
||||
cacheDuration: 15 * time.Second,
|
||||
}
|
||||
}
|
||||
|
||||
// getNonce returns a unique incrementing nonce for each request
|
||||
func (t *IndodaxTrader) getNonce() int64 {
|
||||
t.nonceMutex.Lock()
|
||||
defer t.nonceMutex.Unlock()
|
||||
t.nonce++
|
||||
return t.nonce
|
||||
}
|
||||
|
||||
// sign generates HMAC-SHA512 signature for request body
|
||||
func (t *IndodaxTrader) sign(body string) string {
|
||||
mac := hmac.New(sha512.New, []byte(t.secretKey))
|
||||
mac.Write([]byte(body))
|
||||
return hex.EncodeToString(mac.Sum(nil))
|
||||
}
|
||||
|
||||
// doPublicRequest makes a public API GET request
|
||||
func (t *IndodaxTrader) doPublicRequest(path string) ([]byte, error) {
|
||||
reqURL := indodaxBaseURL + indodaxPublicAPI + path
|
||||
|
||||
req, err := http.NewRequest("GET", reqURL, nil)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to create request: %w", err)
|
||||
}
|
||||
|
||||
resp, err := t.httpClient.Do(req)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("request failed: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
data, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read response: %w", err)
|
||||
}
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(data))
|
||||
}
|
||||
|
||||
return data, nil
|
||||
}
|
||||
|
||||
// doPrivateRequest makes a signed private API POST request
|
||||
func (t *IndodaxTrader) doPrivateRequest(params url.Values) ([]byte, error) {
|
||||
reqURL := indodaxBaseURL + indodaxPrivateAPI
|
||||
|
||||
// Add nonce
|
||||
params.Set("nonce", strconv.FormatInt(t.getNonce(), 10))
|
||||
|
||||
body := params.Encode()
|
||||
signature := t.sign(body)
|
||||
|
||||
req, err := http.NewRequest("POST", reqURL, strings.NewReader(body))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to create request: %w", err)
|
||||
}
|
||||
|
||||
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
||||
req.Header.Set("Key", t.apiKey)
|
||||
req.Header.Set("Sign", signature)
|
||||
|
||||
resp, err := t.httpClient.Do(req)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("request failed: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
data, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read response: %w", err)
|
||||
}
|
||||
|
||||
if resp.StatusCode == http.StatusTooManyRequests {
|
||||
return nil, fmt.Errorf("rate limit exceeded, please try again later")
|
||||
}
|
||||
|
||||
// Parse response to check success
|
||||
var apiResp IndodaxResponse
|
||||
if err := json.Unmarshal(data, &apiResp); err != nil {
|
||||
return nil, fmt.Errorf("failed to parse response: %w (body: %s)", err, string(data))
|
||||
}
|
||||
|
||||
if apiResp.Success != 1 {
|
||||
return nil, fmt.Errorf("API error: %s (code: %s)", apiResp.Error, apiResp.ErrorCode)
|
||||
}
|
||||
|
||||
return apiResp.Return, nil
|
||||
}
|
||||
|
||||
// convertSymbol converts standard symbol to Indodax format
|
||||
// e.g. BTCIDR -> btc_idr, ETHIDR -> eth_idr
|
||||
func (t *IndodaxTrader) convertSymbol(symbol string) string {
|
||||
s := strings.ToLower(symbol)
|
||||
|
||||
// Already in Indodax format (contains underscore)
|
||||
if strings.Contains(s, "_") {
|
||||
return s
|
||||
}
|
||||
|
||||
// Try to split by known base currencies
|
||||
for _, base := range []string{"idr", "btc", "usdt"} {
|
||||
if strings.HasSuffix(s, base) {
|
||||
traded := strings.TrimSuffix(s, base)
|
||||
if traded != "" {
|
||||
return traded + "_" + base
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return s
|
||||
}
|
||||
|
||||
// convertSymbolBack converts Indodax format back to standard
|
||||
// e.g. btc_idr -> BTCIDR
|
||||
func (t *IndodaxTrader) convertSymbolBack(indodaxSymbol string) string {
|
||||
return strings.ToUpper(strings.ReplaceAll(indodaxSymbol, "_", ""))
|
||||
}
|
||||
|
||||
// getCoinFromSymbol extracts the traded currency from a symbol
|
||||
// e.g. btc_idr -> btc, eth_idr -> eth
|
||||
func (t *IndodaxTrader) getCoinFromSymbol(symbol string) string {
|
||||
pair := t.convertSymbol(symbol)
|
||||
parts := strings.Split(pair, "_")
|
||||
if len(parts) >= 1 {
|
||||
return parts[0]
|
||||
}
|
||||
return strings.ToLower(symbol)
|
||||
}
|
||||
|
||||
// loadPairs loads trading pair information from the public API
|
||||
func (t *IndodaxTrader) loadPairs() error {
|
||||
t.pairCacheMutex.RLock()
|
||||
if len(t.pairCache) > 0 && time.Since(t.pairCacheTime) < 5*time.Minute {
|
||||
t.pairCacheMutex.RUnlock()
|
||||
return nil
|
||||
}
|
||||
t.pairCacheMutex.RUnlock()
|
||||
|
||||
data, err := t.doPublicRequest("/pairs")
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to load pairs: %w", err)
|
||||
}
|
||||
|
||||
var pairs []IndodaxPair
|
||||
if err := json.Unmarshal(data, &pairs); err != nil {
|
||||
return fmt.Errorf("failed to parse pairs: %w", err)
|
||||
}
|
||||
|
||||
t.pairCacheMutex.Lock()
|
||||
defer t.pairCacheMutex.Unlock()
|
||||
|
||||
t.pairCache = make(map[string]*IndodaxPair)
|
||||
for i := range pairs {
|
||||
p := pairs[i]
|
||||
t.pairCache[p.TickerID] = &p
|
||||
// Also index by ID (e.g. "btcidr")
|
||||
t.pairCache[p.ID] = &p
|
||||
}
|
||||
t.pairCacheTime = time.Now()
|
||||
|
||||
logger.Infof("[Indodax] Loaded %d trading pairs", len(pairs))
|
||||
return nil
|
||||
}
|
||||
|
||||
// getPair gets pair info for a symbol
|
||||
func (t *IndodaxTrader) getPair(symbol string) (*IndodaxPair, error) {
|
||||
if err := t.loadPairs(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
pairID := t.convertSymbol(symbol)
|
||||
|
||||
t.pairCacheMutex.RLock()
|
||||
defer t.pairCacheMutex.RUnlock()
|
||||
|
||||
if pair, ok := t.pairCache[pairID]; ok {
|
||||
return pair, nil
|
||||
}
|
||||
|
||||
// Try without underscore
|
||||
noUnderscore := strings.ReplaceAll(pairID, "_", "")
|
||||
if pair, ok := t.pairCache[noUnderscore]; ok {
|
||||
return pair, nil
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("pair not found: %s", symbol)
|
||||
}
|
||||
|
||||
// clearCache clears cached data
|
||||
func (t *IndodaxTrader) clearCache() {
|
||||
t.cacheMutex.Lock()
|
||||
defer t.cacheMutex.Unlock()
|
||||
t.cachedBalance = nil
|
||||
t.cachedPositions = nil
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// types.Trader interface implementation
|
||||
// ============================================================
|
||||
|
||||
// GetBalance gets account balance from Indodax
|
||||
func (t *IndodaxTrader) GetBalance() (map[string]interface{}, error) {
|
||||
// Check cache
|
||||
t.cacheMutex.RLock()
|
||||
if t.cachedBalance != nil && time.Since(t.balanceCacheTime) < t.cacheDuration {
|
||||
cached := t.cachedBalance
|
||||
t.cacheMutex.RUnlock()
|
||||
return cached, nil
|
||||
}
|
||||
t.cacheMutex.RUnlock()
|
||||
|
||||
params := url.Values{}
|
||||
params.Set("method", "getInfo")
|
||||
|
||||
data, err := t.doPrivateRequest(params)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to get account info: %w", err)
|
||||
}
|
||||
|
||||
var result struct {
|
||||
ServerTime int64 `json:"server_time"`
|
||||
Balance map[string]interface{} `json:"balance"`
|
||||
BalanceHold map[string]interface{} `json:"balance_hold"`
|
||||
UserID string `json:"user_id"`
|
||||
Name string `json:"name"`
|
||||
Email string `json:"email"`
|
||||
}
|
||||
|
||||
if err := json.Unmarshal(data, &result); err != nil {
|
||||
return nil, fmt.Errorf("failed to parse balance: %w", err)
|
||||
}
|
||||
|
||||
// Calculate total balance in IDR
|
||||
idrBalance := parseFloat(result.Balance["idr"])
|
||||
idrHold := parseFloat(result.BalanceHold["idr"])
|
||||
totalIDR := idrBalance + idrHold
|
||||
|
||||
balance := map[string]interface{}{
|
||||
"totalWalletBalance": totalIDR,
|
||||
"availableBalance": idrBalance,
|
||||
"totalUnrealizedProfit": 0.0,
|
||||
"totalEquity": totalIDR,
|
||||
"balance": totalIDR,
|
||||
"idr_balance": idrBalance,
|
||||
"idr_hold": idrHold,
|
||||
"currency": "IDR",
|
||||
"user_id": result.UserID,
|
||||
"server_time": result.ServerTime,
|
||||
}
|
||||
|
||||
// Add individual crypto balances
|
||||
for currency, amount := range result.Balance {
|
||||
if currency != "idr" {
|
||||
balance["balance_"+currency] = parseFloat(amount)
|
||||
}
|
||||
}
|
||||
for currency, amount := range result.BalanceHold {
|
||||
if currency != "idr" {
|
||||
balance["hold_"+currency] = parseFloat(amount)
|
||||
}
|
||||
}
|
||||
|
||||
// Update cache
|
||||
t.cacheMutex.Lock()
|
||||
t.cachedBalance = balance
|
||||
t.balanceCacheTime = time.Now()
|
||||
t.cacheMutex.Unlock()
|
||||
|
||||
return balance, nil
|
||||
}
|
||||
|
||||
// GetPositions returns currently held crypto balances as "positions"
|
||||
// Since Indodax is spot-only, each non-zero crypto balance is treated as a position
|
||||
func (t *IndodaxTrader) GetPositions() ([]map[string]interface{}, error) {
|
||||
// Check cache
|
||||
t.cacheMutex.RLock()
|
||||
if t.cachedPositions != nil && time.Since(t.positionCacheTime) < t.cacheDuration {
|
||||
cached := t.cachedPositions
|
||||
t.cacheMutex.RUnlock()
|
||||
return cached, nil
|
||||
}
|
||||
t.cacheMutex.RUnlock()
|
||||
|
||||
params := url.Values{}
|
||||
params.Set("method", "getInfo")
|
||||
|
||||
data, err := t.doPrivateRequest(params)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to get positions: %w", err)
|
||||
}
|
||||
|
||||
var result struct {
|
||||
Balance map[string]interface{} `json:"balance"`
|
||||
BalanceHold map[string]interface{} `json:"balance_hold"`
|
||||
}
|
||||
|
||||
if err := json.Unmarshal(data, &result); err != nil {
|
||||
return nil, fmt.Errorf("failed to parse positions: %w", err)
|
||||
}
|
||||
|
||||
var positions []map[string]interface{}
|
||||
|
||||
for currency, amountRaw := range result.Balance {
|
||||
if currency == "idr" {
|
||||
continue
|
||||
}
|
||||
|
||||
amount := parseFloat(amountRaw)
|
||||
holdAmount := parseFloat(result.BalanceHold[currency])
|
||||
totalAmount := amount + holdAmount
|
||||
|
||||
if totalAmount <= 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
// Get market price for this coin
|
||||
markPrice, _ := t.GetMarketPrice(strings.ToUpper(currency) + "IDR")
|
||||
|
||||
// Calculate position value in IDR
|
||||
notionalValue := totalAmount * markPrice
|
||||
|
||||
position := map[string]interface{}{
|
||||
"symbol": strings.ToUpper(currency) + "IDR",
|
||||
"side": "LONG",
|
||||
"positionAmt": totalAmount,
|
||||
"entryPrice": markPrice, // Spot doesn't track entry price
|
||||
"markPrice": markPrice,
|
||||
"unRealizedProfit": 0.0, // Spot doesn't track unrealized PnL
|
||||
"leverage": 1.0,
|
||||
"mgnMode": "spot",
|
||||
"notionalValue": notionalValue,
|
||||
"currency": currency,
|
||||
"available": amount,
|
||||
"hold": holdAmount,
|
||||
}
|
||||
|
||||
positions = append(positions, position)
|
||||
}
|
||||
|
||||
// Update cache
|
||||
t.cacheMutex.Lock()
|
||||
t.cachedPositions = positions
|
||||
t.positionCacheTime = time.Now()
|
||||
t.cacheMutex.Unlock()
|
||||
|
||||
return positions, nil
|
||||
}
|
||||
|
||||
// OpenLong opens a spot buy order
|
||||
func (t *IndodaxTrader) OpenLong(symbol string, quantity float64, leverage int) (map[string]interface{}, error) {
|
||||
t.clearCache()
|
||||
|
||||
pair := t.convertSymbol(symbol)
|
||||
coin := t.getCoinFromSymbol(symbol)
|
||||
|
||||
// Get market price to calculate IDR amount
|
||||
price, err := t.GetMarketPrice(symbol)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to get market price: %w", err)
|
||||
}
|
||||
|
||||
params := url.Values{}
|
||||
params.Set("method", "trade")
|
||||
params.Set("pair", pair)
|
||||
params.Set("type", "buy")
|
||||
params.Set("price", strconv.FormatFloat(price, 'f', 0, 64))
|
||||
params.Set(coin, strconv.FormatFloat(quantity, 'f', 8, 64))
|
||||
params.Set("order_type", "limit")
|
||||
|
||||
data, err := t.doPrivateRequest(params)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to place buy order: %w", err)
|
||||
}
|
||||
|
||||
var result map[string]interface{}
|
||||
if err := json.Unmarshal(data, &result); err != nil {
|
||||
return nil, fmt.Errorf("failed to parse trade response: %w", err)
|
||||
}
|
||||
|
||||
logger.Infof("[Indodax] Buy order placed: %s qty=%.8f price=%.0f", symbol, quantity, price)
|
||||
|
||||
return map[string]interface{}{
|
||||
"orderId": result["order_id"],
|
||||
"symbol": symbol,
|
||||
"side": "BUY",
|
||||
"price": price,
|
||||
"qty": quantity,
|
||||
"status": "NEW",
|
||||
}, nil
|
||||
}
|
||||
|
||||
// OpenShort is not supported on Indodax (spot-only exchange)
|
||||
func (t *IndodaxTrader) OpenShort(symbol string, quantity float64, leverage int) (map[string]interface{}, error) {
|
||||
return nil, fmt.Errorf("short selling is not supported on Indodax (spot-only exchange)")
|
||||
}
|
||||
|
||||
// CloseLong closes a spot position by selling
|
||||
func (t *IndodaxTrader) CloseLong(symbol string, quantity float64) (map[string]interface{}, error) {
|
||||
t.clearCache()
|
||||
|
||||
pair := t.convertSymbol(symbol)
|
||||
coin := t.getCoinFromSymbol(symbol)
|
||||
|
||||
// If quantity is 0, sell all available balance
|
||||
if quantity <= 0 {
|
||||
balance, err := t.GetBalance()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to get balance for close all: %w", err)
|
||||
}
|
||||
available := parseFloat(balance["balance_"+coin])
|
||||
if available <= 0 {
|
||||
return nil, fmt.Errorf("no %s balance to sell", coin)
|
||||
}
|
||||
quantity = available
|
||||
}
|
||||
|
||||
// Get market price
|
||||
price, err := t.GetMarketPrice(symbol)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to get market price: %w", err)
|
||||
}
|
||||
|
||||
params := url.Values{}
|
||||
params.Set("method", "trade")
|
||||
params.Set("pair", pair)
|
||||
params.Set("type", "sell")
|
||||
params.Set("price", strconv.FormatFloat(price, 'f', 0, 64))
|
||||
params.Set(coin, strconv.FormatFloat(quantity, 'f', 8, 64))
|
||||
params.Set("order_type", "limit")
|
||||
|
||||
data, err := t.doPrivateRequest(params)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to place sell order: %w", err)
|
||||
}
|
||||
|
||||
var result map[string]interface{}
|
||||
if err := json.Unmarshal(data, &result); err != nil {
|
||||
return nil, fmt.Errorf("failed to parse trade response: %w", err)
|
||||
}
|
||||
|
||||
logger.Infof("[Indodax] Sell order placed: %s qty=%.8f price=%.0f", symbol, quantity, price)
|
||||
|
||||
return map[string]interface{}{
|
||||
"orderId": result["order_id"],
|
||||
"symbol": symbol,
|
||||
"side": "SELL",
|
||||
"price": price,
|
||||
"qty": quantity,
|
||||
"status": "NEW",
|
||||
}, nil
|
||||
}
|
||||
|
||||
// CloseShort is not supported on Indodax (spot-only exchange)
|
||||
func (t *IndodaxTrader) CloseShort(symbol string, quantity float64) (map[string]interface{}, error) {
|
||||
return nil, fmt.Errorf("short selling is not supported on Indodax (spot-only exchange)")
|
||||
}
|
||||
|
||||
// SetLeverage is a no-op for Indodax (spot-only, no leverage)
|
||||
func (t *IndodaxTrader) SetLeverage(symbol string, leverage int) error {
|
||||
logger.Infof("[Indodax] SetLeverage ignored (spot-only exchange, no leverage support)")
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetMarginMode is a no-op for Indodax (spot-only, no margin)
|
||||
func (t *IndodaxTrader) SetMarginMode(symbol string, isCrossMargin bool) error {
|
||||
logger.Infof("[Indodax] SetMarginMode ignored (spot-only exchange, no margin support)")
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetMarketPrice gets the current market price for a symbol
|
||||
func (t *IndodaxTrader) GetMarketPrice(symbol string) (float64, error) {
|
||||
pairID := strings.ToLower(strings.ReplaceAll(t.convertSymbol(symbol), "_", ""))
|
||||
|
||||
data, err := t.doPublicRequest("/ticker/" + pairID)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("failed to get ticker: %w", err)
|
||||
}
|
||||
|
||||
var tickerResp IndodaxTickerResponse
|
||||
if err := json.Unmarshal(data, &tickerResp); err != nil {
|
||||
return 0, fmt.Errorf("failed to parse ticker: %w", err)
|
||||
}
|
||||
|
||||
price, err := strconv.ParseFloat(tickerResp.Ticker.Last, 64)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("failed to parse price '%s': %w", tickerResp.Ticker.Last, err)
|
||||
}
|
||||
|
||||
return price, nil
|
||||
}
|
||||
|
||||
// SetStopLoss is not supported on Indodax (spot-only exchange)
|
||||
func (t *IndodaxTrader) SetStopLoss(symbol string, positionSide string, quantity, stopPrice float64) error {
|
||||
return fmt.Errorf("stop-loss orders are not supported on Indodax (spot-only exchange)")
|
||||
}
|
||||
|
||||
// SetTakeProfit is not supported on Indodax (spot-only exchange)
|
||||
func (t *IndodaxTrader) SetTakeProfit(symbol string, positionSide string, quantity, takeProfitPrice float64) error {
|
||||
return fmt.Errorf("take-profit orders are not supported on Indodax (spot-only exchange)")
|
||||
}
|
||||
|
||||
// CancelStopLossOrders is a no-op for Indodax
|
||||
func (t *IndodaxTrader) CancelStopLossOrders(symbol string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// CancelTakeProfitOrders is a no-op for Indodax
|
||||
func (t *IndodaxTrader) CancelTakeProfitOrders(symbol string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// CancelAllOrders cancels all open orders for a given symbol
|
||||
func (t *IndodaxTrader) CancelAllOrders(symbol string) error {
|
||||
t.clearCache()
|
||||
|
||||
pair := t.convertSymbol(symbol)
|
||||
|
||||
// First get open orders
|
||||
params := url.Values{}
|
||||
params.Set("method", "openOrders")
|
||||
params.Set("pair", pair)
|
||||
|
||||
data, err := t.doPrivateRequest(params)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to get open orders: %w", err)
|
||||
}
|
||||
|
||||
var result struct {
|
||||
Orders []struct {
|
||||
OrderID json.Number `json:"order_id"`
|
||||
Type string `json:"type"`
|
||||
OrderType string `json:"order_type"`
|
||||
} `json:"orders"`
|
||||
}
|
||||
|
||||
if err := json.Unmarshal(data, &result); err != nil {
|
||||
return fmt.Errorf("failed to parse open orders: %w", err)
|
||||
}
|
||||
|
||||
// Cancel each order
|
||||
for _, order := range result.Orders {
|
||||
cancelParams := url.Values{}
|
||||
cancelParams.Set("method", "cancelOrder")
|
||||
cancelParams.Set("pair", pair)
|
||||
cancelParams.Set("order_id", order.OrderID.String())
|
||||
cancelParams.Set("type", order.Type)
|
||||
|
||||
if _, err := t.doPrivateRequest(cancelParams); err != nil {
|
||||
logger.Warnf("[Indodax] Failed to cancel order %s: %v", order.OrderID, err)
|
||||
} else {
|
||||
logger.Infof("[Indodax] Cancelled order: %s", order.OrderID)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// CancelStopOrders is a no-op for Indodax (no stop orders)
|
||||
func (t *IndodaxTrader) CancelStopOrders(symbol string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// FormatQuantity formats quantity to correct precision for Indodax
|
||||
func (t *IndodaxTrader) FormatQuantity(symbol string, quantity float64) (string, error) {
|
||||
pair, err := t.getPair(symbol)
|
||||
if err != nil {
|
||||
// Default: 8 decimal places
|
||||
return strconv.FormatFloat(quantity, 'f', 8, 64), nil
|
||||
}
|
||||
|
||||
precision := pair.PriceRound
|
||||
if precision <= 0 {
|
||||
precision = 8
|
||||
}
|
||||
|
||||
// Round down to avoid exceeding balance
|
||||
factor := math.Pow(10, float64(precision))
|
||||
rounded := math.Floor(quantity*factor) / factor
|
||||
|
||||
return strconv.FormatFloat(rounded, 'f', precision, 64), nil
|
||||
}
|
||||
|
||||
// GetOrderStatus gets the status of a specific order
|
||||
func (t *IndodaxTrader) GetOrderStatus(symbol string, orderID string) (map[string]interface{}, error) {
|
||||
pair := t.convertSymbol(symbol)
|
||||
|
||||
params := url.Values{}
|
||||
params.Set("method", "getOrder")
|
||||
params.Set("pair", pair)
|
||||
params.Set("order_id", orderID)
|
||||
|
||||
data, err := t.doPrivateRequest(params)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to get order status: %w", err)
|
||||
}
|
||||
|
||||
var result struct {
|
||||
Order struct {
|
||||
OrderID string `json:"order_id"`
|
||||
Price string `json:"price"`
|
||||
Type string `json:"type"`
|
||||
Status string `json:"status"`
|
||||
SubmitTime string `json:"submit_time"`
|
||||
FinishTime string `json:"finish_time"`
|
||||
ClientOrderID string `json:"client_order_id"`
|
||||
} `json:"order"`
|
||||
}
|
||||
|
||||
if err := json.Unmarshal(data, &result); err != nil {
|
||||
return nil, fmt.Errorf("failed to parse order: %w", err)
|
||||
}
|
||||
|
||||
// Map Indodax status to standard status
|
||||
status := "NEW"
|
||||
switch result.Order.Status {
|
||||
case "filled":
|
||||
status = "FILLED"
|
||||
case "cancelled":
|
||||
status = "CANCELED"
|
||||
case "open":
|
||||
status = "NEW"
|
||||
}
|
||||
|
||||
price, _ := strconv.ParseFloat(result.Order.Price, 64)
|
||||
|
||||
return map[string]interface{}{
|
||||
"status": status,
|
||||
"avgPrice": price,
|
||||
"executedQty": 0.0, // Indodax doesn't return executed qty in getOrder
|
||||
"commission": 0.0,
|
||||
"orderId": result.Order.OrderID,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// GetClosedPnL gets closed position PnL records (trade history)
|
||||
func (t *IndodaxTrader) GetClosedPnL(startTime time.Time, limit int) ([]types.ClosedPnLRecord, error) {
|
||||
// Indodax trade history is limited to 7 days range
|
||||
params := url.Values{}
|
||||
params.Set("method", "tradeHistory")
|
||||
params.Set("pair", "btc_idr") // Default pair; Indodax requires a pair
|
||||
if limit > 0 {
|
||||
params.Set("count", strconv.Itoa(limit))
|
||||
}
|
||||
if !startTime.IsZero() {
|
||||
params.Set("since", strconv.FormatInt(startTime.Unix(), 10))
|
||||
}
|
||||
|
||||
data, err := t.doPrivateRequest(params)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to get trade history: %w", err)
|
||||
}
|
||||
|
||||
var result struct {
|
||||
Trades []struct {
|
||||
TradeID string `json:"trade_id"`
|
||||
OrderID string `json:"order_id"`
|
||||
Type string `json:"type"`
|
||||
Price string `json:"price"`
|
||||
Fee string `json:"fee"`
|
||||
TradeTime string `json:"trade_time"`
|
||||
ClientOrderID string `json:"client_order_id"`
|
||||
} `json:"trades"`
|
||||
}
|
||||
|
||||
if err := json.Unmarshal(data, &result); err != nil {
|
||||
// Trade history might return empty, that's fine
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
var records []types.ClosedPnLRecord
|
||||
for _, trade := range result.Trades {
|
||||
price, _ := strconv.ParseFloat(trade.Price, 64)
|
||||
fee, _ := strconv.ParseFloat(trade.Fee, 64)
|
||||
tradeTime, _ := strconv.ParseInt(trade.TradeTime, 10, 64)
|
||||
|
||||
side := "long"
|
||||
if trade.Type == "sell" {
|
||||
side = "long" // Selling from a spot position is closing long
|
||||
}
|
||||
|
||||
records = append(records, types.ClosedPnLRecord{
|
||||
Symbol: "BTCIDR",
|
||||
Side: side,
|
||||
ExitPrice: price,
|
||||
Fee: fee,
|
||||
ExitTime: time.Unix(tradeTime, 0),
|
||||
OrderID: trade.OrderID,
|
||||
CloseType: "manual",
|
||||
})
|
||||
}
|
||||
|
||||
return records, nil
|
||||
}
|
||||
|
||||
// GetOpenOrders gets open/pending orders
|
||||
func (t *IndodaxTrader) GetOpenOrders(symbol string) ([]types.OpenOrder, error) {
|
||||
pair := t.convertSymbol(symbol)
|
||||
|
||||
params := url.Values{}
|
||||
params.Set("method", "openOrders")
|
||||
if pair != "" {
|
||||
params.Set("pair", pair)
|
||||
}
|
||||
|
||||
data, err := t.doPrivateRequest(params)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to get open orders: %w", err)
|
||||
}
|
||||
|
||||
var result struct {
|
||||
Orders []struct {
|
||||
OrderID json.Number `json:"order_id"`
|
||||
ClientOrderID string `json:"client_order_id"`
|
||||
SubmitTime string `json:"submit_time"`
|
||||
Price string `json:"price"`
|
||||
Type string `json:"type"`
|
||||
OrderType string `json:"order_type"`
|
||||
} `json:"orders"`
|
||||
}
|
||||
|
||||
if err := json.Unmarshal(data, &result); err != nil {
|
||||
return nil, fmt.Errorf("failed to parse open orders: %w", err)
|
||||
}
|
||||
|
||||
var orders []types.OpenOrder
|
||||
for _, order := range result.Orders {
|
||||
price, _ := strconv.ParseFloat(order.Price, 64)
|
||||
|
||||
side := "BUY"
|
||||
if order.Type == "sell" {
|
||||
side = "SELL"
|
||||
}
|
||||
|
||||
orders = append(orders, types.OpenOrder{
|
||||
OrderID: order.OrderID.String(),
|
||||
Symbol: t.convertSymbolBack(pair),
|
||||
Side: side,
|
||||
PositionSide: "LONG",
|
||||
Type: "LIMIT",
|
||||
Price: price,
|
||||
Status: "NEW",
|
||||
})
|
||||
}
|
||||
|
||||
return orders, nil
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Helper functions
|
||||
// ============================================================
|
||||
|
||||
// parseFloat safely parses a float from interface{}
|
||||
func parseFloat(v interface{}) float64 {
|
||||
if v == nil {
|
||||
return 0
|
||||
}
|
||||
switch val := v.(type) {
|
||||
case float64:
|
||||
return val
|
||||
case string:
|
||||
f, _ := strconv.ParseFloat(val, 64)
|
||||
return f
|
||||
case json.Number:
|
||||
f, _ := val.Float64()
|
||||
return f
|
||||
case int:
|
||||
return float64(val)
|
||||
case int64:
|
||||
return float64(val)
|
||||
default:
|
||||
return 0
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,374 @@
|
||||
package indodax
|
||||
|
||||
import (
|
||||
"os"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"nofx/trader/types"
|
||||
)
|
||||
|
||||
// Test credentials - set via environment variables
|
||||
func getIndodaxTestCredentials(t *testing.T) (string, string) {
|
||||
apiKey := os.Getenv("INDODAX_TEST_API_KEY")
|
||||
secretKey := os.Getenv("INDODAX_TEST_SECRET_KEY")
|
||||
|
||||
if apiKey == "" || secretKey == "" {
|
||||
t.Skip("Indodax test credentials not set (INDODAX_TEST_API_KEY, INDODAX_TEST_SECRET_KEY)")
|
||||
}
|
||||
|
||||
return apiKey, secretKey
|
||||
}
|
||||
|
||||
func createIndodaxTestTrader(t *testing.T) *IndodaxTrader {
|
||||
apiKey, secretKey := getIndodaxTestCredentials(t)
|
||||
trader := NewIndodaxTrader(apiKey, secretKey)
|
||||
return trader
|
||||
}
|
||||
|
||||
// TestIndodaxTrader_InterfaceCompliance tests that IndodaxTrader implements types.Trader
|
||||
func TestIndodaxTrader_InterfaceCompliance(t *testing.T) {
|
||||
var _ types.Trader = (*IndodaxTrader)(nil)
|
||||
}
|
||||
|
||||
// TestNewIndodaxTrader tests creating Indodax trader instance
|
||||
func TestNewIndodaxTrader(t *testing.T) {
|
||||
trader := NewIndodaxTrader("test_api_key", "test_secret_key")
|
||||
|
||||
if trader == nil {
|
||||
t.Fatal("Expected non-nil trader")
|
||||
}
|
||||
if trader.apiKey != "test_api_key" {
|
||||
t.Errorf("Expected apiKey 'test_api_key', got '%s'", trader.apiKey)
|
||||
}
|
||||
if trader.secretKey != "test_secret_key" {
|
||||
t.Errorf("Expected secretKey 'test_secret_key', got '%s'", trader.secretKey)
|
||||
}
|
||||
if trader.httpClient == nil {
|
||||
t.Error("Expected non-nil httpClient")
|
||||
}
|
||||
if trader.cacheDuration != 15*time.Second {
|
||||
t.Errorf("Expected cacheDuration 15s, got %v", trader.cacheDuration)
|
||||
}
|
||||
}
|
||||
|
||||
// TestIndodaxTrader_SymbolConversion tests symbol format conversion
|
||||
func TestIndodaxTrader_SymbolConversion(t *testing.T) {
|
||||
trader := NewIndodaxTrader("test", "test")
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
input string
|
||||
expected string
|
||||
}{
|
||||
{"BTCIDR to btc_idr", "BTCIDR", "btc_idr"},
|
||||
{"ETHIDR to eth_idr", "ETHIDR", "eth_idr"},
|
||||
{"SOLIDR to sol_idr", "SOLIDR", "sol_idr"},
|
||||
{"Already converted", "btc_idr", "btc_idr"},
|
||||
{"BTC pair", "ETHBTC", "eth_btc"},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := trader.convertSymbol(tt.input)
|
||||
if result != tt.expected {
|
||||
t.Errorf("convertSymbol(%s) = %s, want %s", tt.input, result, tt.expected)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestIndodaxTrader_SymbolConversionBack tests symbol reversion
|
||||
func TestIndodaxTrader_SymbolConversionBack(t *testing.T) {
|
||||
trader := NewIndodaxTrader("test", "test")
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
input string
|
||||
expected string
|
||||
}{
|
||||
{"btc_idr to BTCIDR", "btc_idr", "BTCIDR"},
|
||||
{"eth_idr to ETHIDR", "eth_idr", "ETHIDR"},
|
||||
{"Already standard", "BTCIDR", "BTCIDR"},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := trader.convertSymbolBack(tt.input)
|
||||
if result != tt.expected {
|
||||
t.Errorf("convertSymbolBack(%s) = %s, want %s", tt.input, result, tt.expected)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestIndodaxTrader_GetCoinFromSymbol tests coin extraction
|
||||
func TestIndodaxTrader_GetCoinFromSymbol(t *testing.T) {
|
||||
trader := NewIndodaxTrader("test", "test")
|
||||
|
||||
tests := []struct {
|
||||
input string
|
||||
expected string
|
||||
}{
|
||||
{"BTCIDR", "btc"},
|
||||
{"ETHIDR", "eth"},
|
||||
{"btc_idr", "btc"},
|
||||
{"eth_idr", "eth"},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.input, func(t *testing.T) {
|
||||
result := trader.getCoinFromSymbol(tt.input)
|
||||
if result != tt.expected {
|
||||
t.Errorf("getCoinFromSymbol(%s) = %s, want %s", tt.input, result, tt.expected)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestIndodaxTrader_Sign tests HMAC-SHA512 signature generation
|
||||
func TestIndodaxTrader_Sign(t *testing.T) {
|
||||
trader := NewIndodaxTrader("api_key", "secret_key")
|
||||
|
||||
body := "method=getInfo&nonce=1000"
|
||||
signature := trader.sign(body)
|
||||
|
||||
if signature == "" {
|
||||
t.Error("Expected non-empty signature")
|
||||
}
|
||||
if len(signature) != 128 { // SHA-512 hex = 128 chars
|
||||
t.Errorf("Expected signature length 128, got %d", len(signature))
|
||||
}
|
||||
|
||||
// Same input should produce same signature
|
||||
signature2 := trader.sign(body)
|
||||
if signature != signature2 {
|
||||
t.Error("Signature should be deterministic")
|
||||
}
|
||||
|
||||
// Different input should produce different signature
|
||||
signature3 := trader.sign("method=getInfo&nonce=1001")
|
||||
if signature == signature3 {
|
||||
t.Error("Different input should produce different signature")
|
||||
}
|
||||
}
|
||||
|
||||
// TestIndodaxTrader_Nonce tests nonce incrementation
|
||||
func TestIndodaxTrader_Nonce(t *testing.T) {
|
||||
trader := NewIndodaxTrader("test", "test")
|
||||
|
||||
nonce1 := trader.getNonce()
|
||||
nonce2 := trader.getNonce()
|
||||
nonce3 := trader.getNonce()
|
||||
|
||||
if nonce2 <= nonce1 {
|
||||
t.Errorf("Nonce should be increasing: %d <= %d", nonce2, nonce1)
|
||||
}
|
||||
if nonce3 <= nonce2 {
|
||||
t.Errorf("Nonce should be increasing: %d <= %d", nonce3, nonce2)
|
||||
}
|
||||
}
|
||||
|
||||
// TestIndodaxTrader_SpotOnlyRestrictions tests that futures-only methods return errors
|
||||
func TestIndodaxTrader_SpotOnlyRestrictions(t *testing.T) {
|
||||
trader := NewIndodaxTrader("test", "test")
|
||||
|
||||
// OpenShort should fail
|
||||
_, err := trader.OpenShort("BTCIDR", 0.001, 1)
|
||||
if err == nil {
|
||||
t.Error("OpenShort should return error on spot exchange")
|
||||
}
|
||||
|
||||
// CloseShort should fail
|
||||
_, err = trader.CloseShort("BTCIDR", 0.001)
|
||||
if err == nil {
|
||||
t.Error("CloseShort should return error on spot exchange")
|
||||
}
|
||||
|
||||
// SetStopLoss should fail
|
||||
err = trader.SetStopLoss("BTCIDR", "LONG", 0.001, 500000000)
|
||||
if err == nil {
|
||||
t.Error("SetStopLoss should return error on spot exchange")
|
||||
}
|
||||
|
||||
// SetTakeProfit should fail
|
||||
err = trader.SetTakeProfit("BTCIDR", "LONG", 0.001, 600000000)
|
||||
if err == nil {
|
||||
t.Error("SetTakeProfit should return error on spot exchange")
|
||||
}
|
||||
|
||||
// SetLeverage should NOT fail (no-op)
|
||||
err = trader.SetLeverage("BTCIDR", 10)
|
||||
if err != nil {
|
||||
t.Errorf("SetLeverage should not fail (no-op): %v", err)
|
||||
}
|
||||
|
||||
// SetMarginMode should NOT fail (no-op)
|
||||
err = trader.SetMarginMode("BTCIDR", true)
|
||||
if err != nil {
|
||||
t.Errorf("SetMarginMode should not fail (no-op): %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestIndodaxTrader_ParseFloat tests parseFloat helper
|
||||
func TestIndodaxTrader_ParseFloat(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
input interface{}
|
||||
expected float64
|
||||
}{
|
||||
{"float64", 123.45, 123.45},
|
||||
{"string", "123.45", 123.45},
|
||||
{"int", 123, 123.0},
|
||||
{"int64", int64(123), 123.0},
|
||||
{"nil", nil, 0.0},
|
||||
{"zero string", "0", 0.0},
|
||||
{"empty string", "", 0.0},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := parseFloat(tt.input)
|
||||
if result != tt.expected {
|
||||
t.Errorf("parseFloat(%v) = %f, want %f", tt.input, result, tt.expected)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestIndodaxTrader_ClearCache tests cache clearing
|
||||
func TestIndodaxTrader_ClearCache(t *testing.T) {
|
||||
trader := NewIndodaxTrader("test", "test")
|
||||
|
||||
// Set some cached data
|
||||
trader.cachedBalance = map[string]interface{}{"test": "data"}
|
||||
trader.cachedPositions = []map[string]interface{}{{"test": "data"}}
|
||||
|
||||
// Clear cache
|
||||
trader.clearCache()
|
||||
|
||||
if trader.cachedBalance != nil {
|
||||
t.Error("Cache should be cleared")
|
||||
}
|
||||
if trader.cachedPositions != nil {
|
||||
t.Error("Position cache should be cleared")
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// Integration tests (require INDODAX_TEST_API_KEY env vars)
|
||||
// ============================================================
|
||||
|
||||
// TestIndodaxConnection tests basic API connectivity
|
||||
func TestIndodaxConnection(t *testing.T) {
|
||||
trader := createIndodaxTestTrader(t)
|
||||
|
||||
balance, err := trader.GetBalance()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to get balance: %v", err)
|
||||
}
|
||||
|
||||
t.Logf("✅ Connection OK")
|
||||
t.Logf(" totalWalletBalance: %v", balance["totalWalletBalance"])
|
||||
t.Logf(" availableBalance: %v", balance["availableBalance"])
|
||||
t.Logf(" totalEquity: %v", balance["totalEquity"])
|
||||
t.Logf(" currency: %v", balance["currency"])
|
||||
t.Logf(" user_id: %v", balance["user_id"])
|
||||
}
|
||||
|
||||
// TestIndodaxGetPositions tests position retrieval
|
||||
func TestIndodaxGetPositions(t *testing.T) {
|
||||
trader := createIndodaxTestTrader(t)
|
||||
|
||||
positions, err := trader.GetPositions()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to get positions: %v", err)
|
||||
}
|
||||
|
||||
t.Logf("📊 Found %d positions (crypto balances):", len(positions))
|
||||
for i, pos := range positions {
|
||||
t.Logf(" [%d] %s: qty=%.8f markPrice=%.0f value=%.0f IDR",
|
||||
i+1,
|
||||
pos["symbol"],
|
||||
pos["positionAmt"],
|
||||
pos["markPrice"],
|
||||
pos["notionalValue"],
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// TestIndodaxGetMarketPrice tests market price retrieval
|
||||
func TestIndodaxGetMarketPrice(t *testing.T) {
|
||||
trader := createIndodaxTestTrader(t)
|
||||
|
||||
pairs := []string{"BTCIDR", "ETHIDR"}
|
||||
|
||||
for _, pair := range pairs {
|
||||
price, err := trader.GetMarketPrice(pair)
|
||||
if err != nil {
|
||||
t.Errorf("Failed to get price for %s: %v", pair, err)
|
||||
continue
|
||||
}
|
||||
t.Logf(" %s: %.0f IDR", pair, price)
|
||||
}
|
||||
}
|
||||
|
||||
// TestIndodaxGetOpenOrders tests open orders retrieval
|
||||
func TestIndodaxGetOpenOrders(t *testing.T) {
|
||||
trader := createIndodaxTestTrader(t)
|
||||
|
||||
orders, err := trader.GetOpenOrders("BTCIDR")
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to get open orders: %v", err)
|
||||
}
|
||||
|
||||
t.Logf("📋 Found %d open orders:", len(orders))
|
||||
for i, order := range orders {
|
||||
t.Logf(" [%d] %s %s: price=%.0f orderID=%s",
|
||||
i+1, order.Symbol, order.Side, order.Price, order.OrderID)
|
||||
}
|
||||
}
|
||||
|
||||
// TestIndodaxGetClosedPnL tests trade history retrieval
|
||||
func TestIndodaxGetClosedPnL(t *testing.T) {
|
||||
trader := createIndodaxTestTrader(t)
|
||||
|
||||
startTime := time.Now().Add(-7 * 24 * time.Hour)
|
||||
records, err := trader.GetClosedPnL(startTime, 10)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to get closed PnL: %v", err)
|
||||
}
|
||||
|
||||
t.Logf("📋 Found %d trade records:", len(records))
|
||||
for i, record := range records {
|
||||
t.Logf(" [%d] %s %s: price=%.0f fee=%.4f time=%s",
|
||||
i+1, record.Symbol, record.Side, record.ExitPrice, record.Fee,
|
||||
record.ExitTime.Format("2006-01-02 15:04:05"))
|
||||
}
|
||||
}
|
||||
|
||||
// TestIndodaxLoadPairs tests loading trading pairs
|
||||
func TestIndodaxLoadPairs(t *testing.T) {
|
||||
trader := createIndodaxTestTrader(t)
|
||||
|
||||
err := trader.loadPairs()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to load pairs: %v", err)
|
||||
}
|
||||
|
||||
trader.pairCacheMutex.RLock()
|
||||
defer trader.pairCacheMutex.RUnlock()
|
||||
|
||||
t.Logf("📊 Loaded %d pairs", len(trader.pairCache))
|
||||
|
||||
// Check some known pairs
|
||||
knownPairs := []string{"btc_idr", "eth_idr"}
|
||||
for _, pairID := range knownPairs {
|
||||
if pair, ok := trader.pairCache[pairID]; ok {
|
||||
t.Logf(" %s: min_base=%v, min_traded=%v, precision=%d",
|
||||
pair.Description, pair.TradeMinBaseCurrency, pair.TradeMinTradedCurrency, pair.PriceRound)
|
||||
} else {
|
||||
t.Errorf("Expected pair %s not found", pairID)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user