Im vorherigen Artikel haben wir die börsenübergreifende „Arbitrage“-Arbitrage vorgestellt. Dieses Mal werden wir uns eingehend mit der Anwendung des Lead-Lag-Effekts auf den Hochfrequenzhandel befassen, bei dem es darum geht, in sehr kurzer Zeit winzige Preisunterschiede auszunutzen und schnell Gewinne zu erzielen. Der Lead-Lag-Effekt liefert Händlern prädiktive Informationen, die ihnen helfen, den kurzfristigen Preistrend zu bestimmen und so Arbitrage zwischen verschiedenen Börsen zu erzielen.

Im Folgenden sindVereinfachung des öffentlichen Codes, und auf FMZ API-basiert konvertiert. Das Codeprinzip dieser ursprünglichen Strategie ist sehr einfach und war einst sehr profitabel. Es ist derzeit nicht verfügbar und dient nur zu Referenzzwecken.

Prinzip der Lead-Lag-Hochfrequenzstrategie

Der sogenannte „Lead-Lag“ kann so verstanden werden, dass die Preise (oder bestimmte Indikatoren) einiger Börsen bei den allgemeinen Marktveränderungen eher „vorausschauend“ sind, während andere Börsen oder andere Indikatoren relativ „nachhinken“ (Lag). . Bei dieser Strategie stellen „Preis_1, Preis_2, Preis_3“ die Marktbedingungen verschiedener Börsen dar. Es handelt sich um Mainstream-Börsen, die sensibler auf Marktnachrichten oder ihre Handelstiefe und Teilnehmertypen reagieren. Sobald ein großer Kauf- oder Verkaufsauftrag vorliegt, Die Preise dieser Börsen werden zunächst schwanken. Die Preisschwankungen an tatsächlichen Handelsbörsen werden aufgrund von Faktoren wie Matching-Mechanismen und Handelsgruppen leicht zurückbleiben. An diesem Punkt entsteht die Situation, dass „einige führen und andere zurückbleiben“.

Orderbuch-Crawling an mehreren Börsen

Die Strategie erhält nahezu synchron Orderbuchdaten von verschiedenen Börsen, wie etwa den besten Gebotspreis, den besten Briefkurs, das ausstehende Ordervolumen usw. Anschließend werden die Mittelpreise (also der Durchschnitt der Geld- und Briefkurse) verschiedener Börsen verglichen, um Rückschlüsse auf die Marktdynamik zu ziehen.

Beurteilung von Trendsignalen

Die Strategie konzentriert sich hauptsächlich auf die Preisänderungen von drei externen Börsen (Okex, Binance, Huobipro):

Dabei wird jeder TrendX durch die Differenz zwischen „aktuellem Preis“ und „früherem Preis“ bestimmt, die einen bestimmten Schwellenwert (Level * Preisinkrement) überschreitet. Wenn nach der Addition der „Aufwärts-/Abwärts“-Signale der drei Börsen der Gesamttrend > 0 ist, bedeutet dies, dass der Markt im Allgemeinen steigt und die Strategie zum Kaufen lautet; wenn der Trend < 0 ist, bedeutet dies, dass der Markt im Allgemeinen fallen, und die Strategie besteht darin, zu verkaufen.

Einwegauftrag und Risikokontrolle

Bei dieser Strategie wird erst gekauft oder verkauft, nachdem sich der Trend bestätigt hat, und vor der Platzierung jeder einzelnen Bestellung wird die vorherige Bestellung storniert (das heißt, um versehentliche ausstehende Bestellungen zu vermeiden, die zu einer Risikoakkumulation führen). Gleichzeitig richtet das Skript auch Module wie Leverage, Batch-Betrieb und Risikokontrollüberwachung ein, was bedeutet, dass mehrere Konten und mehrere Währungspaare im tatsächlichen Handel verwendet werden, wodurch die “Handelsfrequenz” und “Effizienz von Kapitalverwertung“.

Darüber hinaus handelt es sich bei dieser Strategie um eine Hochfrequenzstrategie. Sie müssen weder auf den Gewinn oder Verlust jeder einzelnen Order achten, noch müssen Sie einen Stop-Loss festlegen. Sie können so lange fortfahren, wie eine hohe Wahrscheinlichkeit besteht, einen profitieren.

FMZ Strategieumsetzung

Parametereinstellungen

// 超参设置
const SYMBOL = "BTC_USDT"; // 交易对
const PRICE_INCREMENT = 0.1; // 价格增量
const LEVEL = 10; // 趋势判断的灵敏度
const RATIO = 10; // 下单价格调整比例
const INTERVAL = 200; // 时间间隔（毫秒）
const S_AMOUNT = 0.02; // 默认交易量
const MIN_AMOUNT = 0.005; // 最小交易量

// 初始状态
let buyOrders = [];
let sellOrders = [];
let previousPrices = [0, 0, 0]; // 存储之前的价格
let loop = 0;

Kernlogik: Daten erfassen und Trends beurteilen

// 获取订单簿数据
function fetchOrderBooks() {
    let orderBooks = [];
    let tasks = [];

    // 启动所有交易所的异步获取订单簿任务
    for (let i = 0; i < exchanges.length; i++) {
        // 假设每个交易所对象都可以调用Go方法
        let task = exchanges[i].Go("GetDepth");
        tasks.push({ index: i, task: task });
    }

    // 等待所有任务完成并收集结果
    for (let i = 0; i < tasks.length; i++) {
        let { index, task } = tasks[i];
        try {
            // 等待异步任务返回结果
            let depth = task.wait(1000);

            // 检查返回的数据是否有效
            if (!depth || !depth.Bids || !depth.Asks) {
                throw new Error("返回的订单簿数据无效");
            }

            // 将有效的订单簿数据添加到结果数组
            orderBooks[index] = depth;
        } catch (error) {
            // 记录错误日志
            Log(`获取交易所${index}订单簿失败: ${error.message}`);

            // 添加默认的订单簿数据以避免崩溃
            orderBooks[index] = {
                Bids: [[0, 0]],
                Asks: [[0, 0]]
            };
        }
    }

    return orderBooks;
}


// 判断趋势
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); // 上升趋势
        } else if (midPrice < previousPrices[i] - LEVEL * PRICE_INCREMENT) {
            trends.push(-1); // 下降趋势
        } else {
            trends.push(0); // 无显著趋势
        }
        previousPrices[i] = midPrice; // 更新价格记录
    }
    return trends.reduce((a, b) => a + b, 0); // 返回总体趋势
}

Aufgeben und Stornieren von Bestellungen

// 取消所有挂单
function cancelOrders(orders) {
    for (let orderId of orders) {
        try {
            exchanges[0].CancelOrder(orderId); // 默认使用主交易所
            Log(`取消订单: ${orderId}`);
        } catch (error) {
            Log(`取消订单失败: ${error.message}`);
        }
    }
}

// 创建买单
function createBuyOrder(price, amount) {
    try {
        const orderId = exchanges[0].Buy(price, amount);
        buyOrders.push(orderId);
        Log(`创建买单: 价格 ${price}, 数量 ${amount}`);
    } catch (error) {
        Log(`创建买单失败: ${error.message}`);
    }
}

// 创建卖单
function createSellOrder(price, amount) {
    try {
        const orderId = exchanges[0].Sell(price, amount);
        sellOrders.push(orderId);
        Log(`创建卖单: 价格 ${price}, 数量 ${amount}`);
    } catch (error) {
        Log(`创建卖单失败: ${error.message}`);
    }
}

Hauptstrategielogik

function main() {
    while (true) {
        try {
            // 获取订单簿数据
            const orderBooks = fetchOrderBooks();

            // 计算趋势
            const trend = calculateTrend(orderBooks);
            Log(`当前趋势: ${trend}`);

            // 取消挂单
            cancelOrders(buyOrders);
            cancelOrders(sellOrders);
            buyOrders = [];
            sellOrders = [];

            // 根据趋势下单
            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++;
            Sleep(INTERVAL);

        } catch (error) {
            Log(`主逻辑错误: ${error.message}`);
        }
    }
}

Analyse der Gründe für das Scheitern einer Strategie

Märkte werden effizient

Wenn immer mehr quantitative oder Hochfrequenzstrategien zum Einsatz kommen und dieselbe Lead-Lag-Beziehung entdecken, wird eine große Menge an Fonds den Preisunterschied schnell aufheben. Da die Märkte immer stärker „synchronisiert“ werden, wird es für Strategien immer schwieriger, aus kleinen Preisunterschieden „risikofreie“ oder kurzfristige Arbitrage zu erzielen.

Umtauschbeschränkungen oder Gebührenänderungen

Da sich die Gebührenstruktur der verschiedenen Börsen ändert, wird die Rentabilität von Hochfrequenzhandelsstrategien erheblich reduziert, sobald die Gebührenkosten die Arbitragegewinne übersteigen. Alternativ gilt: Wenn die Börse den Matching-Prozess beschleunigt, die Häufigkeit und Menge begrenzt und die Latenz reduziert, werden Strategien, die auf inkonsistenter Latenz beruhen, wirkungslos.

Liquiditätsverfall und Slippage

Wenn das Marktvolumen nicht ausreicht, stoßen Hochfrequenzstrategien häufig auf stärkere Kursschwankungen; oder große Aufträge treiben die Preise schnell in die Höhe, wodurch die ursprünglich erwartete „billig kaufen und teuer verkaufen“-Strategie durch die eigenen Aufträge beeinflusst wird, was zu einem Rückgang der Renditen führt. .

Veränderte Marktvolatilität

Einige Strategien funktionieren sehr gut bei „hoher Volatilität“ oder „bestimmten Zyklen“. Wenn der Markt stagniert oder die Volatilität abnimmt und die Hebelwirkung reduziert wird, verliert die Strategie ihr geeignetes Umfeld und kann sogar häufige Verluste verursachen.

Zusammenfassen

Der Kernpunkt dieser Hochfrequenzhandelsstrategie liegt in der Erfassung von Preisen von mehreren Börsen und der Beurteilung der „Trendsynthese“. Es wurde einmal eine ultrahochfrequente, schnelle Ein- und Ausstiegshandelsmethode implementiert, die auf dem Lead-Lag-Prinzip basierte: Beobachten Sie, an welcher Börse sich der Preis zuerst bewegt, und treiben Sie dann die Preise anderer Börsen dazu, zu folgen, wodurch sofortige Preisunterschiede oder kurzfristige Trends erfasst werden. . Allerdings führen laut dem Autor Veränderungen im Marktumfeld, der Strategiehomogenität, den Gebühren und Frequenzbeschränkungen dazu, dass diese auf dem „First Move, Last Move“-Spread beruhende Strategie allmählich weniger nützlich ist und sogar ihre Rentabilität verliert. Wer diese Art von Lead-Lag-Strategie ausprobieren möchte, muss das Handelsmodul in Kombination mit der neuesten Marktstruktur (Liquidität, Gebührenregeln, Algorithmus-Matching-Geschwindigkeit) optimieren und auf das Risikokontrollmanagement achten, um In einem sich verändernden Marktumfeld bestehen. Kontinuierliche Wettbewerbsfähigkeit aufrechterhalten.