하이프레크 거래 전략 분석 - 페니 점프

고주파 거래는 빠른 거래 실행과 시장 미세 구조에 대한 민감한 통찰력에 의존하는 도전적이고 경쟁적인 분야입니다. 그중에서도 주목받는 전략 중 하나는 시장의 "코끼리"를 소규모지만 빈번한 수익을 얻기 위해 활용하는 데 초점을 맞춘 페니 점프입니다. 이 기사에서는 페니 점프 전략의 작동 원리를 자세히 설명하고 시작자가 그것이 어떻게 작동하는지 이해할 수 있도록 전략 코드의 세부 사항을 깊이 탐구합니다.

페니 점프 전략에 대한 이해

주식 시장에서, "코끼리"는 일반적으로 많은 양의 주식을 구매하거나 판매하기를 원하는 기관 투자자를 의미하지만 시장 가격에 거래하기를 원하지 않습니다. 대신, 그들은 시장에 많은 제한 목록, 즉 서열을 붙이는 것을 선택하여 그들의 의도를 표시합니다. 이러한 행동은 시장에서 광범위한 관심을 불러 일으켰습니다. 대량 거래가 시장에 중대한 영향을 줄 수 있기 때문입니다.

예를 들어, 한 주식의 시장 깊이가 원래 이렇게 생겼다고 가정해 봅시다: 200$1.01 x $1.03 200; 그리고 코끼리가 들어와 3000주식 $1.01의 결제금을 걸어 놓습니다. 이 때 시장 깊이는 3,200가 됩니다. $1.01 x $1.03 200; 이것은 코끼리를 도입하는 것과 같습니다. 그리고 그 코끼리는 시장의 다른 참가자들의 관심사가 됩니다.

• 경쟁 시장 하이프레크 트레이더의 경우, 그들의 이익은 주로 다른 트레이더들의 의도를 추측하기 위해 시장의 미세 구조를 분석하는 것에서 나온다. once an elephant appears, highfrequency traders will quickly establish positions to capture tiny price fluctuations. 그들의 목표는 짧은 시간에 자주 거래하여 미세하지만 축적된 이익을 축적하는 것이다.

• 코끼리의 곤경 코끼리들은 시장에서 대규모로 거래하기를 원할 수 있지만, 그들의 행동은 그들의 거래 의도를 드러내기도 하며, 고주파 거래자의 표적이 된다. 고주파 거래자는 사전에 입장을 세우고, 그 다음 가격 변동에서 이익을 얻으려고 시도한다. 코끼리들의 시장에서의 존재는 경쟁 시장의 반응을 불러일으키고, 따라서 그들의 거래 전략에 영향을 줄 수 있다.

• 시장 속임수 현실적으로, 대형 기관 투자자들은 일반적으로 시장에 큰 양의 구매 또는 판매 주문을 공개적으로 게재하지 않습니다. 왜냐하면 그러한 행동은 시장의 다른 참가자들이 대응을 하거나 심지어 시장 조작을 할 수 있기 때문입니다. 따라서, 그들은 고주파 거래자를 유치하고 빠르게 판매하거나 구매하여 가격 변동의 이익을 얻기 위해 위상을 만드는 전략을 취할 수 있습니다.

페니 점프 전략의 핵심 아이디어

페니 점프 전략의 핵심 아이디어는 시장에 코끼리가 나타나서 특정 가격 (예: $1.01) 을 지지하면, 고사파선 거래자가 빠르게 그들의 가격을 1센트로, 예를 들어 $1.02로 올릴 것이라는 것이다. 이것은 고사파선 거래자가 코끼리가 나타나고 있다는 것을 알고 있기 때문에, 이 가격에 강력한 구매자 지원이 있다는 것을 의미하기 때문에, 그들은 그 뒤를 따라서 가격 상승을 기대하기 위해 노력한다. 가격이 실제로 $1.03 x $1.05로 상승했을 때, 고사파선 거래자는 빠르게 판매하여 $0.01의 이익을 얻을 수 있다.

뿐만 아니라, 높은 주파수 거래자는 가격 상승이 없더라도 구매 후 수익을 얻을 수 있습니다. 그들은 코끼리가 밑값을 지지한다는 것을 알고 있기 때문에, 그들은 코끼리에 주식을 빠르게 팔 수 있으며, 소소한 차이 수익을 얻을 수 있습니다.

페니 점프 정책 코드를 풀고

이 전략의 소스 코드는:https://www.fmz.com/strategy/358

위의 정책 코드는 페니 점프 전략을 구현하는 데 사용되는 예입니다. 다음은 초보자가 어떻게 작동하는지 이해할 수 있도록 코드의 자세한 설명입니다.

var Counter = {
    i: 0,
    w: 0,
    f: 0
};

// Variables
var InitAccount = null;

function CancelAll() {
    while (true) {
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        for (var i = 0; i < orders.length; i++) {
            exchange.CancelOrder(orders[i].Id);
        }
        Sleep(Interval);
    }
}

function updateStatus(msg) {
    LogStatus("调戏次数:", Counter.i, "成功:", Counter.w, "失败:", Counter.f, "\n"+msg+"#0000ff\n"+new Date());
}

function main() {
    if (DisableLog) {
        EnableLog(false);
    }
    CancelAll();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    var i = 0;
    var locks = 0;
    while (true) {
        Sleep(Interval);
        var depth = _C(exchange.GetDepth);
        if (depth.Asks.length === 0 || depth.Bids.length === 0) {
            continue;
        }
        updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ",  卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks);
        var askPrice = 0;
        for (i = 0; i < depth.Asks.length; i++) {
            if (depth.Asks[i].Amount >= Lot) {
                askPrice = depth.Asks[i].Price;
                break;
            }
        }
        if (askPrice === 0) {
            continue;
        }
        var elephant = null;
        // skip Bids[0]
        for (i = 1; i < depth.Bids.length; i++) {
            if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
                break;
            }
            if (depth.Bids[i].Amount >= ElephantAmount) {
                elephant = depth.Bids[i];
                break;
            }
        }

        if (!elephant) {
            locks = 0;
            continue;
        }
        locks++;
        if (locks < LockCount) {
            continue;
        }
        locks = 0;

        updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant));
        exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
        var ts = new Date().getTime();
        while (true) {
            Sleep(CheckInterval);
            var orders = _C(exchange.GetOrders);
            if (orders.length == 0) {
                break;
            }
            if ((new Date().getTime() - ts) > WaitInterval) {
                for (var i = 0; i < orders.length; i++) {
                    exchange.CancelOrder(orders[i].Id);
                }
            }
        }
        var account = _C(exchange.GetAccount);
        var opAmount = _N(account.Stocks - InitAccount.Stocks);
        if (opAmount < 0.001) {
            Counter.f++;
            Counter.i++;
            continue;
        }
        updateStatus("买单得手: " + opAmount +", 开始出手...");
        exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
        var success = true;
        while (true) {
            var depth = _C(exchange.GetDepth);
            if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price-(STTick*PennyTick))) {
                success = false;
                updateStatus("没有得手, 开始止损, 当前买一: " + depth.Bids[0].Price);
                CancelAll();
                account = _C(exchange.GetAccount);
                var opAmount = _N(account.Stocks - InitAccount.Stocks);
                if (opAmount < 0.001) {
                    break;
                }
                exchange.Sell(depth.Bids[0].Price, opAmount);
            }
            var orders = _C(exchange.GetOrders);
            if (orders.length === 0) {
                break;
            }
            Sleep(CheckInterval);
        }
        if (success) {
            Counter.w++;
        } else {
            Counter.f++;
        }
        Counter.i++;
        var account = _C(exchange.GetAccount);
        LogProfit(account.Balance - InitAccount.Balance, account);
    }
}

제가 여러분에게 제공한 전략 코드를 단계별로 분석해 보도록 하겠습니다.

var Counter = {
    i: 0,
    w: 0,
    f: 0
};

이 코드는 Counter라는 객체를 초기화하여 트랜잭션 통계 정보를 추적하는 정책을 수행한다. 구체적으로 세 가지 속성을 포함합니다.

• i: 총 거래 수를 나타냅니다.
• w: 성공한 거래 수를 나타냅니다.
• f: 실패한 거래 수를 나타냅니다.

이 속성은 정책 실행 과정에서 기록되고 업데이트됩니다.

var InitAccount = null;

이 코드 라인은 InitAccount라는 변수를 초기화하여 정책 실행에 들어갈 때 계정 정보를 저장합니다.

function CancelAll() {
    while (true) {
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        for (var i = 0; i < orders.length; i++) {
            exchange.CancelOrder(orders[i].Id);
        }
        Sleep(Interval);
    }
}

이것은CancelAll()이 기능은 시장에서 완료되지 않은 모든 주문을 취소하는 기능을 제공합니다.

• while (true): 이것은 무한한 순환이며, 완료되지 않은 주문이 없을 때까지 계속 실행될 것입니다.
• var orders = _C(exchange.GetOrders)：这一行代码使用exchange.GetOrders函数获取当前账户所有挂出的订单，并将它们存储在orders变量中。
• if (orders.length == 0): 이 코드 라인은 완료되지 않은 주문이 있는지 확인합니다. 만약 orders 대수의 길이가 0이면 완료되지 않은 주문이 없다는 것을 의미합니다.
• for (var i = 0; i < orders.length; i++): 이것은 모든 미완성 주문을 가로질러 진행되는 for 루프입니다.
• exchange.CancelOrder(orders[i].Id): 이 코드 라인은 exchange.CancelOrder ()) 함수를 사용하여 주문의 ID를 통해 각 주문을 취소합니다.
• Sleep(Interval): 이 코드 라인은 주문을 취소하는 작업이 너무 자주 되지 않도록 하기 위해 잠시 동안 (밀리초 단위) 대기하는 대기 주기를 도입한다.

이 함수의 목적은 메인 정책 실행에 방해를 방지하기 위해 메인 정책 실행 이전에는 미완성 주문이 존재하지 않는다는 것을 확인하는 것입니다.

function updateStatus(msg) {
    LogStatus("调戏次数:", Counter.i, "成功:", Counter.w, "失败:", Counter.f, "\n" + msg + "#0000ff\n" + new Date());
}

이것은updateStatus(msg)트레이드 상태 정보를 업데이트하고 기록하는 기능이다. 일반적으로 현재 시장 상태에 대한 정보를 포함하는 msg 매개 변수를 받아들이고 있다.

사용LogStatus()함수는 정책 실행 시 상태 칸에 표시되는 정보를 기록합니다. 그것은 거래 횟수, 성공 횟수, 실패 횟수와 관련된 텍스트를 보여줍니다. 더하기msg현재 시장 상태에 대한 정보를 포함하는 매개 변수. 현재 시간표가 추가되었습니다.new Date()) 시간 정보를 표시합니다. 이 기능의 목적은 전략 실행 중 모니터링 및 분석을 위해 거래 상태 정보를 기록하고 업데이트하는 것입니다.

function main() {
    if (DisableLog) {
        EnableLog(false);
    }
    CancelAll();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    var i = 0;
    var locks = 0;
    while (true) {
        Sleep(Interval);
        var depth = _C(exchange.GetDepth);
        if (depth.Asks.length === 0 || depth.Bids.length === 0) {
            continue;
        }
        updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ",  卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks);
        var askPrice = 0;
        for (i = 0; i < depth.Asks.length; i++) {
            if (depth.Asks[i].Amount >= Lot) {
                askPrice = depth.Asks[i].Price;
                break;
            }
        }
        if (askPrice === 0) {
            continue;
        }
        var elephant = null;
        // skip Bids[0]
        for (i = 1; i < depth.Bids.length; i++) {
            if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
                break;
            }
            if (depth.Bids[i].Amount >= ElephantAmount) {
                elephant = depth.Bids[i];
                break;
            }
        }

        if (!elephant) {
            locks = 0;
            continue;
        }
        locks++;
        if (locks < LockCount) {
            continue;
        }
        locks = 0;

        updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant));
        exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
        var ts = new Date().getTime();
        while (true) {
            Sleep(CheckInterval);
            var orders = _C(exchange.GetOrders);
            if (orders.length == 0) {
                break;
            }
            if ((new Date().getTime() - ts) > WaitInterval) {
                for (var i = 0; i < orders.length; i++) {
                    exchange.CancelOrder(orders[i].Id);
                }
            }
        }
        var account = _C(exchange.GetAccount);
        var opAmount = _N(account.Stocks - InitAccount.Stocks);
        if (opAmount < 0.001) {
            Counter.f++;
            Counter.i++;
            continue;
        }
        updateStatus("买单得手: " + opAmount +", 开始出手...");
        exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
        var success = true;
        while (true) {
            var depth = _C(exchange.GetDepth);
            if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price-(STTick*PennyTick))) {
                success = false;
                updateStatus("没有得手, 开始止损, 当前买一: " + depth.Bids[0].Price);
                CancelAll();
                account = _C(exchange.GetAccount);
                var opAmount = _N(account.Stocks - InitAccount.Stocks);
                if (opAmount < 0.001) {
                    break;
                }
                exchange.Sell(depth.Bids[0].Price, opAmount);
            }
            var orders = _C(exchange.GetOrders);
            if (orders.length === 0) {
                break;
            }
            Sleep(CheckInterval);
        }
        if (success) {
            Counter.w++;
        } else {
            Counter.f++;
        }
        Counter.i++;
        var account = _C(exchange.GetAccount);
        LogProfit(account.Balance - InitAccount.Balance, account);
    }
}

이것은 전략의 주요 실행 기능입니다.main()이 전략의 핵심 논리를 담고 있습니다.

• if (DisableLog): 이 코드 라인은 DisableLog 변수가 사실인지 확인하고, 만약 그렇다면 로그 기록을 비활성화합니다. 이것은 정책이 불필요한 로그 기록을 하지 않도록 하기 위해서입니다.

• CancelAll(): 이전 설명된 CancelAll (() 함수를 호출하여 완료되지 않은 주문이 없음을 확인합니다.

• InitAccount = _C(exchange.GetAccount): 이 코드 라인은 현재 계정의 정보를 가져와 initAccount 변수에 저장합니다. 이것은 정책 실행이 시작되는 계정 상태를 기록하는 데 사용됩니다.

• var i = 0;그리고var locks = 0;: 두 개의 변수 i와 locks를 초기화하고, 이는 후속 전략 논리에서 사용될 것이다.

• while (true): 이것은 무한한 순환이며 주로 전략의 지속적인 실행을 위해 사용됩니다.

다음으로, 우리는 줄별로 설명할 것입니다.while (true)이 순환의 주요 전략적 논리.

while (true) {
    Sleep(Interval);
    var depth = _C(exchange.GetDepth);
    if (depth.Asks.length === 0 || depth.Bids.length === 0) {
        continue;
    }
    updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ",  卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks);

• Sleep(Interval): 이 코드 라인은 정책의 실행 빈도를 제어하기 위해 정책을 잠시 잠겨두는 것입니다. Interval 파라그램은 잠겨있는 시간의 간격을 정의합니다.

• var depth = _C(exchange.GetDepth): 현재 시장 깊이 정보를 얻으십시오. 판매 주문과 구매 주문의 가격과 양을 포함합니다. 이 정보는 깊이 변수에 저장됩니다.

• if (depth.Asks.length === 0 || depth.Bids.length === 0): 이 코드줄은 시장을 깊이 있는 정보를 확인하고, 매매와 매매가 모두 존재하는지 확인합니다. 이 중 하나가 존재하지 않으면 시장이 충분한 거래 정보를 가지고 있지 않을 수 있음을 나타냅니다.

• updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ", 卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks): 이 코드 라인은 업데이트 상태 기능을 호출하고, 정책을 업데이트하는 상태 정보를 제공합니다. 현재 시장 상태를 기록합니다. 구매 가격, 판매 가격 및 이전에 잠겨있는 횟수 (lock) 를 포함합니다.

    var askPrice = 0;
    for (i = 0; i < depth.Asks.length; i++) {
        if (depth.Asks[i].Amount >= Lot) {
            askPrice = depth.Asks[i].Price;
            break;
        }
    }
    if (askPrice === 0) {
        continue;
    }
    var elephant = null;

• var askPrice = 0;: 이니셔얼한 askPrice 변수를, 그것은 조건이 충족된 판매 통의 가격을 저장하는 데 사용될 것이다.

• for (i = 0; i < depth.Asks.length; i++): 이것은 시장에서 판매되는 상품의 가격과 양 정보를 탐색하는 for 루킹입니다.

• if (depth.Asks[i].Amount >= Lot): 루프에서 각 판매 주문의 수가 지정된 Lot (수) 보다 크거나 같는지 확인합니다. 만약 그렇다면, 해당 판매 주문의 가격을 AskPrice에 저장하고 루프를 종료합니다.

• if (askPrice === 0): 조건이 충족되는 판매 주문을 찾지 못하면 (askPrice는 여전히 0) 정책은 계속 기다리고 다음 작업을 건너갑니다.

• var elephant = null;: 이니셔티브 코끼리 변수를, 그것은 코끼리 으로 확인 된 지불 정보를 저장하는 데 사용될 것입니다.

    for (i = 1; i < depth.Bids.length; i++) {
        if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
            break;
        }
        if (depth.Bids[i].Amount >= ElephantAmount) {
            elephant = depth.Bids[i];
            break;
        }
    }

    if (!elephant) {
        locks = 0;
        continue;
    }
    locks++;
    if (locks < LockCount) {
        continue;
    }
    locks = 0;

시장에서 구매하는 가격과 수량 정보를 계속 탐색하여 첫 번째 구매 (Bids[0]) 를 건너가십시오.

• if ((askPrice - depth.Bids[i].Price) > ElephantSpace): 현재 구매 가격과 요청 가격 사이의 차이는 ElephantSpace보다 크는지 확인합니다. 만약 그렇다면, 사슴 사슴에서 충분히 멀리 떨어져 있음을 표시하고 전략은 더 이상 검색하지 않습니다.

• if (depth.Bids[i].Amount >= ElephantAmount): 현재 지불금의 수가 ElephantAmount보다 크거나 같는지 확인하고, 만약 그렇다면, 이 지불금 정보를 elephant 변수에 저장한다.

• if (!elephant): 코끼리 이 발견되지 않으면, 잠금 횟수 잠금을 0으로 다시 설정하고 계속 기다립니다.

locks++: 코끼리의 코끼리가 발견되면 잠금 횟수가 증가합니다. 이것은 코끼리의 코끼리의 코끼리가 존재한다는 것을 여러 번 확인한 후에 정책을 실행하는 것을 보장합니다.

• if (locks < LockCount): 요구 사항에 대한 잠금 수를 확인합니다. 요구 사항이 충족되지 않으면 계속 기다립니다.

    updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant));
    exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
    var ts = new Date().getTime();
    while (true) {
        Sleep(CheckInterval);
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        if ((new Date().getTime() - ts) > WaitInterval) {
            for (var i = 0; i < orders.length; i++) {
                exchange.CancelOrder(orders[i].Id);
            }
        }
    }

• updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant)):updateStatus 함수를 호출하여, 발견된 코끼리 의 위치와 관련 정보와 같은 정책의 현재 상태를 기록합니다. 이것은 정책의 상태 탭에 표시됩니다.

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): exchange.Buy 함수를 사용하여 발견된 사마귀 사마귀를 구매합니다. 구매 가격은 elephant.Price + PennyTick, 구매량은 Lot이며 구매 동작은 "Bids[" + i + ] 사마귀"로 설명됩니다.

• var ts = new Date().getTime(): 현재 시간의 시간표를 얻어서 시간 간격을 계산할 수 있습니다.

• while (true): 새 무궁무진한 순환으로 들어갑니다. 코끼리의 사리 사리 주문을 기다리고 있는 순환 순환 순환 순환 순환 순환입니다.

• Sleep(CheckInterval): 정책 휴식시간을 지정하여 주문 상태를 확인하는 빈도를 제어합니다.

• var orders = _C(exchange.GetOrders)현재 계정에 있는 모든 주문 정보를 얻을 수 있습니다.

• if (orders.length == 0): 완료되지 않은 주문이 있는지 확인하고, 그렇지 않은 경우, 루프를 건너십시오.

• (new Date().getTime() - ts) > WaitInterval: 현재 시간과 사마귀 사마귀를 구매할 때의 시간 간격을 계산합니다. WaitInterval을 초과하면 대기 시간이 지나간다는 것을 의미합니다.

• for (var i = 0; i < orders.length; i++): 모든 미완성 주문을 검색합니다.

• exchange.CancelOrder(orders[i].Id)：使用exchange.CancelOrder函数取消每个未完成的订单。

    var account = _C(exchange.GetAccount);
    var opAmount = _N(account.Stocks - InitAccount.Stocks);
    if (opAmount < 0.001) {
        Counter.f++;
        Counter.i++;
        continue;
    }
    updateStatus("买单得手: " + opAmount + ", 开始出手...");
    exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
    var success = true;
    while (true) {
        var depth = _C(exchange.GetDepth);
        if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))) {
            success = false;
            updateStatus("没有得手, 开始止损, 当前买一: " + depth.Bids[0].Price);
            CancelAll();
            account = _C(exchange.GetAccount);
            var opAmount = _N(account.Stocks - InitAccount.Stocks);
            if (opAmount < 0.001) {
                break;
            }
            exchange.Sell(depth.Bids[0].Price, opAmount);
        }
        var orders = _C(exchange.GetOrders);
        if (orders.length === 0) {
            break;
        }
        Sleep(CheckInterval);
    }
    if (success) {
        Counter.w++;
    } else {
        Counter.f++;
    }
    Counter.i++;
    var account = _C(exchange.GetAccount);
    LogProfit(account.Balance - InitAccount.Balance, account);
}

• var account = _C(exchange.GetAccount)현재 계정 정보를 얻을 수 있습니다.

• var opAmount = _N(account.Stocks - InitAccount.Stocks): 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀 사마귀

• updateStatus("买单得手: " + opAmount + ", 开始出手..."): 코끼리의 을 성공적으로 구매한 정보를 기록하고, 구매량도 포함합니다.

• exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): exchange.Sell 함수를 사용하여 성공적으로 구입한 코끼리 코끼리를 판매하여 수익을 얻습니다. 판매 가격은 코끼리.Price + (PennyTick * ProfitTick) 입니다.

새로운 무한 순환으로 진입하여 판매 주문을 기다리는 실행에 사용됩니다.

• var depth = _C(exchange.GetDepth)시장을 더 깊이 들여다볼 수 있습니다.

• if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))): 시장 깊이 정보를 확인하고 시장 가격이 중지 손실 가격으로 떨어지면 중지 손실 작업을 수행합니다.

• CancelAll():CancelAll() 함수를 호출하여 모든 미완성 주문을 취소하여 보유 위험을 피합니다.

• if (opAmount < 0.001): 구매 수를 다시 확인하고, 0.001보다 작으면 구매가 실패하고 루프에서 벗어나는 것을 나타냅니다.

• exchange.Sell(depth.Bids[0].Price, opAmount): 현재 시장에서 가장 낮은 가격에 남은 자산을 판매하는 중지 손실 작전을 수행합니다.

마지막으로, 거래 성공 여부에 따라 성공 및 실패 수를 업데이트하고 거래 수익을 기록합니다.

이 전략의 핵심 아이디어는 시장에서 코끼리를 찾는 것 (많은 돈을 지불하는 것) 과 작은 수익을 얻기 위해 구매하고 판매하는 것이다. 이 전략은 구매량 (Lot), 실수 재시험 간격 (Interval), 코끼리의 규모 (ElephantAmount), 코끼리의 거리를 (ElephantSpace) 등과 같은 여러 중요한 매개 변수들을 포함하여 전략의 행동을 조정한다.

전체적으로 이 전략은 시장의 깊이 정보를 활용하여 많은 지불금을 식별하고 짧은 시간에 거래하기 위한 고주파 거래 전략이다. 그것은 시장을 지속적으로 모니터링하고 작은 수익을 빠르게 얻기 위해 거래를 수행하는 것을 필요로 한다. 그러나, 그것은 또한 시장의 변동에 신속하게 반응하는 것을 필요로 하며, 동시에 큰 손실을 피하기 위해 위험 관리와 손해 방지 메커니즘을 고려해야 하기 때문에 위험성이 높은 전략이다.

이 전략은 특정 시장 및 거래 플랫폼에 기반하여, 다른 시장 및 거래소에 적절한 조정 및 최적화가 필요할 수 있음을 유의하십시오. 실제 응용에서, 투자자는 전략의 성능을 신중하게 테스트하고 평가하여 투자 목표와 위험 부담에 부합하는지 확인해야합니다.

당신이 계속 실행하는 동안, 그것은 계속해서 반복적으로 다음과 같은 작업을 수행합니다:

우선 전략은 시장에 대한 깊은 정보를 조사하여 현재 판매와 구매 상황을 파악합니다.

2, 다음으로 전략은 조건에 맞는 판매 주문을 찾으려고 노력합니다. 특정 조건은 판매 주문의 수가 Lot (수) 보다 많거나 같다는 것입니다. 만약 조건에 맞는 판매 주문이 발견되면 판매 주문의 가격을 askPrice로 기록합니다.

3, 그 다음 전략은 사마귀의 사마귀를 계속 찾습니다. 그것은 시장의 사마귀를 통해 이동하고 첫 번째 사마귀를 건너뛰습니다. 일반적으로 가장 높은 가격의 사마귀입니다. 만약 적합한 사마귀가 발견되면 사마귀의 사마귀의 정보를 기록하고 잠금 수를 증가시킵니다.

4, 만약 연속적으로 충분한 코끼리 수를 찾으면 (LockCount 매개 변수에 의해 제어된다) 정책은 다음 동작을 더 수행합니다:

• 업데이트 상태 기능을 호출하여 코끼리 의 위치와 관련 정보를 기록합니다.
• exchange.Buy 함수를 사용하여 코끼리의 코끼리를 사다. 가격 + 페니 틱, 구매량: 롯.
• 새로운 무궁무진한 순환을 시작하여 구매 주문의 실행을 기다리고 있습니다.
• 주문 상태를 확인하고, 주문이 완료되면 루프를 건너십시오.
• 대기 시간이 설정된 대기 간격 (Wait Interval) 을 초과하면 모든 미완성 주문을 취소합니다.
• 성공한 구매 후 계정 자산의 변화를 계산합니다. 만약 변화량이 0.001보다 작다면 구매가 실패하고 실패의 수를 늘리고 다음 순환으로 계속됩니다.
• 코끼리 껍질을 성공적으로 구입한 정보를 기록하고, 구매량을 기록합니다.

5. 다음으로, 정책은 새로운 무한주로로 계속 들어가 팔기 동작의 실행을 기다리고 있다. 이 루프에서, 그것은 다음과 같은 동작을 수행한다:

• 시장의 깊이 정보를 얻고 시장 가격이 정지 가격에 도달했는지 확인합니다.
• 만약 시장 가격이 스톱-러스 가격에 도달하거나 그보다 낮다면, 스톱-러스 작전을 실행하여 남은 자산을 매각한다.
• CancelAll 함수를 호출하여 모든 미완성 주문을 취소하여 보유 위험을 줄이십시오.
• 성공한 구매 후 계정 자산의 변화를 다시 확인하고, 0.001보다 작은 변화라면 구매가 실패하고 루프에서 벗어나는 것을 나타냅니다.
• 마지막으로, 거래 성공 여부를 기록하고 거래 결과에 따라 성공 및 실패 수를 업데이트합니다.

전체 전략은 위와 같은 동작을 반복적으로 수행하여 가능한 한 많은 코끼리를 포획하고 작은 수익을 얻는다. 이것은 시장 변화에 신속하게 반응해야 하는 고주파 거래 전략이며 자본을 보호하기 위해 위험 관리 및 손해를 막는 메커니즘을 고려해야 한다. 투자자는 특히 높은 변동성 있는 시장에서 이 전략을 신중하게 고려해야 한다.

마지막 말

페니 점프 전략은 고주파 거래의 대표적인 예이며, 시장 참여자들 간의 미묘한 게임과 경쟁을 보여준다. 암호화폐 시장에서, 이 전략은 특히 시장의 큰 변동과 기관 투자자와 고주파 거래자가 빠른 수익을 추구하기 때문에 두드러진다. 그러나, 이것은 또한 시장이 도전으로 가득 차 있으며, 경쟁 우위를 유지하기 위해 끊임없이 적응하고 조정하는 전략을 필요로 한다. 이 치열한 경쟁 세계에서, 시장의 미세한 구조를 잘 파악하고 신속하게 반응하는 거래자만이 성공할 수 있다.