पिछले लेख में, हमने क्रॉस-एक्सचेंज
निम्नलिखित हैसार्वजनिक संहिता का सरलीकरणइस मूल रणनीति का कोड सिद्धांत बहुत सरल है और एक बार बहुत लाभदायक था। यह वर्तमान में अनुपलब्ध है और केवल संदर्भ के लिए है।
तथाकथित
रणनीति विभिन्न एक्सचेंजों से ऑर्डर बुक डेटा लगभग समवर्ती रूप से प्राप्त करती है, जैसे कि बोली मूल्य, पूछ मूल्य, लंबित ऑर्डर मात्रा, आदि। फिर विभिन्न एक्सचेंजों के मध्य मूल्य (यानी बोली और मांग मूल्य का औसत) की तुलना बाजार गतिशीलता को अनुमानित करने के लिए की जाती है।
रणनीति मुख्य रूप से तीन बाहरी एक्सचेंजों (okex, binance, huobipro) के मूल्य परिवर्तनों पर केंद्रित हैः
यहाँ, प्रत्येक रुझान X का निर्धारण
रणनीति केवल प्रवृत्ति की पुष्टि के बाद ही खरीदती है या बेचती है, और प्रत्येक आदेश लगाने से पहले पिछले आदेश को रद्द करती है (यानी, आकस्मिक लंबित आदेशों से बचने के लिए जो जोखिम संचय का कारण बनते हैं) । उसी समय, स्क्रिप्ट लीवरेज, बैच ऑपरेशन और जोखिम नियंत्रण निगरानी जैसे मॉड्यूल भी सेट करती है, जिसका अर्थ है कि लाइव ट्रेडिंग में एक साथ कई खातों और कई मुद्रा जोड़े का उपयोग किया जाता है, जिससे रणनीति की
इसके अतिरिक्त, यह रणनीति एक उच्च आवृत्ति रणनीति है। आपको प्रत्येक आदेश के लाभ या हानि पर ध्यान देने की आवश्यकता नहीं है, न ही आपको हानि को रोकने की आवश्यकता है। आप तब तक जारी रख सकते हैं जब तक लाभ कमाने की संभावना है।
// Hyperparameter settings
const SYMBOL = "BTC_USDT"; // Trading pair
const PRICE_INCREMENT = 0.1; // Price increment
const LEVEL = 10; // Sensitivity of trend judgment
const RATIO = 10; // Order price adjustment ratio
const INTERVAL = 200; // Time interval (milliseconds)
const S_AMOUNT = 0.02; // Default transaction volume
const MIN_AMOUNT = 0.005; // Minimum transaction volume
// Initial state
let buyOrders = [];
let sellOrders = [];
let previousPrices = [0, 0, 0]; // Store the previous price
let loop = 0;
// Get order book data
function fetchOrderBooks() {
let orderBooks = [];
let tasks = [];
// Start asynchronous order book acquisition tasks for all exchanges
for (let i = 0; i < exchanges.length; i++) {
// Assume that each exchange object can call the Go method
let task = exchanges[i].Go("GetDepth");
tasks.push({ index: i, task: task });
}
// Wait for all tasks to complete and collect results
for (let i = 0; i < tasks.length; i++) {
let { index, task } = tasks[i];
try {
// Waiting for an asynchronous task to return a result
let depth = task.wait(1000);
// Check if the returned data is valid
if (!depth || !depth.Bids || !depth.Asks) {
throw new Error("The returned order book data is invalid");
}
// Add valid order book data to the result array
orderBooks[index] = depth;
} catch (error) {
// Recording error logs
Log(`Failed to obtain the order book of exchange ${index}: ${error.message}`);
// Added default order book data to avoid crashes
orderBooks[index] = {
Bids: [[0, 0]],
Asks: [[0, 0]]
};
}
}
return orderBooks;
}
// Judge the trends
function calculateTrend(orderBooks) {
let trends = [];
for (let i = 0; i < orderBooks.length; i++) {
const midPrice = (orderBooks[i].Bids[0][0] + orderBooks[i].Asks[0][0]) / 2;
if (midPrice > previousPrices[i] + LEVEL * PRICE_INCREMENT) {
trends.push(1); // Upward trend
} else if (midPrice < previousPrices[i] - LEVEL * PRICE_INCREMENT) {
trends.push(-1); // Downward trend
} else {
trends.push(0); // No significant trend
}
previousPrices[i] = midPrice; // Update price record
}
return trends.reduce((a, b) => a + b, 0); // Return to overall trend
}
// Cancel all pending orders
function cancelOrders(orders) {
for (let orderId of orders) {
try {
exchanges[0].CancelOrder(orderId); // Use the main exchange by default
Log(`Cancel order: ${orderId}`);
} catch (error) {
Log(`Failed to cancel order: ${error.message}`);
}
}
}
// Create a buy order
function createBuyOrder(price, amount) {
try {
const orderId = exchanges[0].Buy(price, amount);
buyOrders.push(orderId);
Log(`Create a buy order: price ${price}, quantity ${amount}`);
} catch (error) {
Log(`Failed to create buy order: ${error.message}`);
}
}
// Create a sell order
function createSellOrder(price, amount) {
try {
const orderId = exchanges[0].Sell(price, amount);
sellOrders.push(orderId);
Log(`Create a sell order: price ${price}, quantity ${amount}`);
} catch (error) {
Log(`Failed to create sell order: ${error.message}`);
}
}
function main() {
while (true) {
try {
// Get order book data
const orderBooks = fetchOrderBooks();
// Calculate trends
const trend = calculateTrend(orderBooks);
Log(`Current trend: ${trend}`);
// Cancel pending order
cancelOrders(buyOrders);
cancelOrders(sellOrders);
buyOrders = [];
sellOrders = [];
// Order based on trends
if (trend > 0 && loop > 0) {
const price = _N(orderBooks[0].Bids[0][0] + RATIO * PRICE_INCREMENT, 2);
const amount = _N(Math.max(S_AMOUNT, MIN_AMOUNT), 4);
createBuyOrder(price, amount);
} else if (trend < 0 && loop > 0) {
const price = _N(orderBooks[0].Asks[0][0] - RATIO * PRICE_INCREMENT, 2);
const amount = _N(Math.max(S_AMOUNT, MIN_AMOUNT), 4);
createSellOrder(price, amount);
}
// Loop count and interval
loop++;
Sleep(INTERVAL);
} catch (error) {
Log(`Main logic error: ${error.message}`);
}
}
}
बाजार कुशल होते जा रहे हैं
जब अधिक से अधिक मात्रात्मक या उच्च आवृत्ति वाली रणनीतियाँ शामिल होती हैं और एक ही लीड-लैग संबंध पाती हैं, तो बड़ी मात्रा में धनराशि मूल्य अंतर को जल्दी से समाप्त कर देगी। बाजार अधिक से अधिक
विनिमय प्रतिबंध या शुल्क परिवर्तन
जैसे-जैसे विभिन्न एक्सचेंजों के शुल्क संरचना में परिवर्तन होता है, एक बार शुल्क लागत आर्बिट्रेज लाभ से अधिक हो जाने के बाद, उच्च आवृत्ति वाली ट्रेडिंग रणनीतियों की लाभप्रदता बहुत कम हो जाएगी। या यदि एक्सचेंज मिलान गति को तेज करता है, आवृत्ति और मात्रा को सीमित करता है, और देरी को कम करता है, तो यह उस रणनीति को भी अमान्य कर देगा जो मूल रूप से असंगत देरी पर निर्भर थी।
तरलता में गिरावट और फिसलन
जब बाजार की मात्रा अपर्याप्त होती है, तो उच्च आवृत्ति वाली रणनीतियों में अक्सर अधिक गंभीर फिसलन होती है; या बड़े ऑर्डर कीमतों को तेजी से बढ़ाएंगे, जिससे मूल रूप से अपेक्षित
बाजार की अस्थिरता में परिवर्तन
कुछ रणनीतियाँ
उच्च आवृत्ति ट्रेडिंग रणनीति का मुख्य बिंदु कई एक्सचेंजों से कीमतों को कैप्चर करने और