Trong bài viết trước, chúng tôi đã giới thiệu sự điều chỉnh giao dịch chéo. Trong bài viết này, chúng tôi sẽ xem xét kỹ lưỡng cách áp dụng hiệu ứng Lead-Lag cho giao dịch tần số cao, đòi hỏi phải nắm bắt sự khác biệt giá nhỏ trong một thời gian rất ngắn và kiếm lợi nhuận nhanh chóng. Hiệu ứng Lead-Lag cung cấp cho các nhà giao dịch thông tin dự đoán để giúp họ đánh giá xu hướng ngắn hạn của giá và đạt được sự điều chỉnh giữa các sàn giao dịch khác nhau.
Sau đây làđơn giản hóa bộ luật công cộngvà chuyển đổi sang FMZ API. Nguyên tắc mã của chiến lược ban đầu này rất đơn giản và đã từng rất có lợi. Nó hiện không có sẵn và chỉ dành cho tham khảo.
Chiến lược thu thập dữ liệu sổ lệnh từ các sàn giao dịch khác nhau gần như đồng bộ, chẳng hạn như giá thầu, giá hỏi, khối lượng lệnh đang chờ, v.v. Sau đó giá trung bình (tức là giá trung bình của giá thầu và giá hỏi) của các sàn giao dịch khác nhau được so sánh để suy luận về động lực thị trường.
Chiến lược chủ yếu tập trung vào sự thay đổi giá của ba sàn giao dịch bên ngoài (okex, binance, huobipro):
Ở đây, mỗi xu hướng X được xác định bởi sự khác biệt giữa
Chiến lược chỉ mua hoặc bán sau khi xu hướng được xác nhận, và hủy lệnh trước đó trước khi đặt mỗi lệnh (tức là tránh các lệnh chờ ngẫu nhiên dẫn đến sự tích lũy rủi ro). Đồng thời, kịch bản cũng thiết lập các mô-đun như đòn bẩy, hoạt động hàng loạt và giám sát kiểm soát rủi ro, có nghĩa là nhiều tài khoản và nhiều cặp tiền tệ được sử dụng đồng thời trong giao dịch trực tiếp, do đó mở rộng tần suất giao dịch và hiệu quả sử dụng vốn của chiến lược.
Ngoài ra, chiến lược này là một chiến lược tần suất cao. Bạn không cần phải chú ý đến lợi nhuận hoặc lỗ của mỗi lệnh, cũng không cần phải dừng lỗ. Bạn có thể tiếp tục miễn là có khả năng kiếm lợi nhuận.
// 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}`);
}
}
}
Thị trường trở nên hiệu quả
Khi nhiều chiến lược định lượng hoặc tần số cao hơn được tham gia và tìm thấy mối quan hệ Lead-Lag tương tự, một số tiền lớn sẽ loại bỏ sự khác biệt giá nhanh chóng.
Hạn chế đổi tiền hoặc thay đổi phí
Khi cấu trúc phí của các sàn giao dịch khác nhau thay đổi, một khi chi phí phí vượt quá lợi nhuận phân phối, lợi nhuận của các chiến lược giao dịch tần số cao sẽ giảm đáng kể. Hoặc nếu sàn giao dịch tăng tốc độ phù hợp, hạn chế tần số và số lượng và giảm sự chậm trễ, nó cũng sẽ vô hiệu hóa chiến lược ban đầu dựa trên sự chậm trễ không nhất quán.
Sự suy giảm và trượt của thanh khoản
Khi khối lượng thị trường không đủ, các chiến lược tần số cao thường gặp phải sự trượt nghiêm trọng hơn; hoặc các đơn đặt hàng lớn sẽ đẩy giá lên nhanh chóng, khiến mức mua thấp và bán cao ban đầu dự kiến bị ảnh hưởng bởi các đơn đặt hàng của riêng họ, dẫn đến giảm lợi nhuận.
Biến đổi biến động thị trường
Một số chiến lược hoạt động rất tốt trong
Điểm then chốt của chiến lược giao dịch tần số cao nằm trong việc nắm bắt giá từ nhiều sàn giao dịch và phán đoán của tổng hợp xu hướng. Nó đã thực hiện một phương pháp giao dịch nhập và xuất nhanh với tần số cực cao và nhanh dựa trên nguyên tắc Lead-Lag: quan sát mức giá của sàn giao dịch nào di chuyển đầu tiên, và sau đó thúc đẩy các sàn giao dịch khác theo sau, do đó nắm bắt sự khác biệt giá tức thời hoặc xu hướng ngắn hạn. Tuy nhiên, như tác giả đã nói, những thay đổi trong môi trường thị trường, đồng nhất chiến lược, phí xử lý và giới hạn tần số đã làm cho chiến lược này dựa trên động thái đầu tiên và sau đó di chuyển chênh lệch giá dần dần trở nên kém hữu ích hơn, và thậm chí mất lợi nhuận. Đối với những người muốn khám phá lại loại chiến lược Lead-Lag này, cần phải tối ưu hóa mô-đun giao dịch kết hợp với cấu trúc thị trường mới nhất (tiền thanh khoản, thuật toán xử lý, phù hợp với quy tắc quản lý rủi ro), đồng thời chú ý đến khả năng cạnh tranh trong một môi trường thị trường liên tục thay đổi.