In diesem Artikel werden wir einen tiefen Blick darauf werfen, wie der Lead-Lag-Effekt auf den Hochfrequenzhandel angewendet werden kann, der erfordert, dass kleine Preisunterschiede in sehr kurzer Zeit erfasst und schnell Gewinne erzielt werden.
Die folgendeeine Vereinfachung des öffentlichen KodexDas Codeprinzip dieser ursprünglichen Strategie ist sehr einfach und war einst sehr profitabel.
Der sogenannte
Die Strategie erhält Daten des Auftragsbuchs von verschiedenen Börsen nahezu synchron, z. B. den Gebotspreis, den Gebotspreis, das ausstehende Auftragsvolumen usw. Anschließend wird der mittlere Preis (d. h. der Durchschnitt des Gebots- und Gebotspreises) verschiedener Börsen verglichen, um die Marktdynamik abzuleiten.
Die Strategie konzentriert sich hauptsächlich auf die Preisänderungen von drei externen Börsen (okex, binance, huobipro):
Hier wird jeder Trend X durch die Differenz zwischen dem
Die Strategie kauft oder verkauft nur, nachdem der Trend bestätigt wurde, und storniert die vorherige Bestellung vor der Platzierung jeder Bestellung (d. h. vermeidet versehentliche ausstehende Aufträge, die zu Risikoakkumulationen führen). Gleichzeitig setzt das Skript auch Module wie Hebelwirkung, Chargenbetrieb und Risikokontrollüberwachung ein, was bedeutet, dass mehrere Konten und mehrere Währungspaare gleichzeitig im Live-Handel verwendet werden, wodurch die Strategie
Darüber hinaus ist diese Strategie eine Hochfrequenzstrategie. Sie müssen nicht auf den Gewinn oder Verlust jeder Bestellung achten, noch müssen Sie den Verlust stoppen. Sie können so lange fortfahren, wie es eine Gewinnwahrscheinlichkeit gibt.
// 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}`);
}
}
}
Die Märkte werden effizienter
Wenn immer mehr quantitative oder hochfrequente Strategien beteiligt sind und die gleiche Lead-Lag-Beziehung finden, wird eine große Menge an Geldern den Preisunterschied schnell beseitigen.
Wechselkursbeschränkungen oder Gebührenänderungen
Wenn sich die Gebührenstruktur verschiedener Börsen ändert, wird die Rentabilität von Hochfrequenz-Handelsstrategien erheblich reduziert, sobald die Gebührenkosten die Arbitrage-Gewinne übersteigen. Oder wenn die Börse die Matching-Geschwindigkeit beschleunigt, die Häufigkeit und Menge begrenzt und die Verzögerung reduziert, wird sie auch die Strategie, die ursprünglich auf inkonsistente Verzögerungen angewiesen war, ungültig machen.
Liquiditätsverlust und -abschiebungen
Wenn das Marktvolumen unzureichend ist, begegnen Hochfrequenzstrategien häufig einem schwereren Rutsch; oder große Aufträge drücken die Preise schnell nach oben, wodurch die ursprünglich erwartete
Veränderungen der Marktvolatilität
Einige Strategien funktionieren sehr gut unter
Der Schlüsselpunkt der Hochfrequenz-Handelsstrategie liegt in der Erfassung von Preisen von mehreren Börsen und dem Urteil der