리소스 로딩... 로딩...
  1. 소화
  2. 원본
  3. 고주파 거래 전략 분석 - 페니 점프

고주파 거래 전략 분석 - 페니 점프

저자:FMZ~리디아, 창작: 2023-11-07 10:44:20, 업데이트: 2024-01-01 12:19:43

img

높은 주파수 거래는 빠른 거래 실행과 시장의 미세 구조에 대한 민감한 통찰력에 의존하는 도전적이고 경쟁적인 분야입니다. 주목할만한 전략 중 하나는 페니 점프입니다. 이 기사는 페니 점프 전략이 어떻게 작동하는지 초보자도 이해할 수 있도록 페니 점프 전략이 어떻게 작동하는지 자세히 설명합니다.

페니 점프 전략 을 이해 함

주식 시장에서, 코끼리는 일반적으로 많은 수의 주식을 사거나 팔고 싶지만 시장 가격에 거래하기를 원하지 않는 기관 투자자를 의미합니다. 대신 그들은 그들의 의도를 표시하기 위해 시장에서 많은 수의 제한 주문, 즉 미뤄진 주문을 매달기를 선택합니다. 큰 거래가 시장에 상당한 영향을 줄 수 있기 때문에이 행동은 시장에서 광범위한 관심을 끌었습니다.

예를 들어, 주식 시장의 원래 깊이는 다음과 같다고 가정해 봅시다: 200 ∙ $1.01 x $1.03 ∙ 200. 그러면 코끼리가 들어와 각각 1.01 달러로 3000개의 주식을 구매할 수 있는 주문을 합니다. 이 시점에서 시장의 깊이는 3,200 ∙ $1.01 x $1.03 ∙ 200로 변합니다. 이 동작은 코끼리를 소개하는 것과 같습니다. 코끼리는 시장의 다른 참가자들의 관심사가 됩니다.

  • 경쟁 시장 고주파 트레이더의 경우, 그들의 이익은 주로 다른 트레이더의 의도에 대해 추측하기 위해 시장 미세 구조의 분석에서 발생합니다. 큰 플레이어가 나타나면, 고주파 트레이더는 사소한 가격 변동을 포착하기 위해 신속하게 포지션을 설정합니다. 그들의 목표는 짧은 시간에 자주 거래하고 작지만 누적 수익을 축적하는 것입니다.

  • 코끼리의 딜레마 코끼리는 시장에서 대규모로 활동하기를 원할 수도 있지만, 그들의 행동은 또한 그들의 거래 의도를 드러내며, 고주파 거래자의 표적이 된다. 고주파 거래자는 시간보다 먼저 포지션을 설정하고 가격 변동으로부터 이익을 얻으려고 한다. 시장에서 코끼리의 존재는 경쟁 시장에서 반응을 유발할 수 있으며, 따라서 그들의 거래 전략에 영향을 미친다.

  • 시장 에서의 사기 실제로, 대규모 기관 투자자들은 일반적으로 시장에 많은 수의 구매 또는 판매 주문을 공개적으로 배치하지 않으며, 그러한 행동은 시장의 다른 참가자가 대응 조치를 취하거나 심지어 시장을 조작하도록 유도 할 수 있습니다. 따라서 그들은 착각을 일으키기 위해 전략을 채택하고, 현장에 높은 주파수 거래자를 유치하고, 가격 변동으로부터 이익을 얻기 위해 신속하게 판매하거나 구매 할 수 있습니다.

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

페니 점프 전략의 핵심 아이디어는 시장에 빅 플레이어가 나타나 특정 가격 (예를 들어 $1.01 등) 을 지원하면, 고주파 트레이더들은 빠르게 시장을 한 센트로, 예를 들어, $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("Number of debugging sessions:", Counter.i, "succeeded:", Counter.w, "failed:", 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("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ",  Sell one:" + depth.Asks[0].Price + ", Lock times: " + 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("Debug the elephant... The elephant is in gear " + 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("Successful payment: " + opAmount +", Start taking action...");
        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("Didn't get it, start to stop loss, currently buying one: " + 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): 이 코드 라인은 교환.GetOrders 기능을 사용하여 현금 계좌에서 모든 미뤄진 주문을 검색하고 주문 변수에 저장합니다.
  • if (orders.length == 0): 이 코드 줄은 완료되지 않은 주문을 검사합니다. 명령어 배열의 길이가 0이라면 완료되지 않은 주문이 없으며 루프가 중단됩니다.
  • for (var i = 0; i < orders.length; i++): 이것은 모든 미완성 명령어를 반복하는 for 루프입니다.
  • exchange.CancelOrder(orders[i].Id): 이 코드 줄은 exchange.CancelOrder (() 함수를 사용하여 각 주문을 해당 ID로 취소합니다.
  • Sleep(Interval): 이 코드 라인은 취소 주문의 동작이 너무 자주 되지 않도록 하기 위해 일정 시간 동안 (밀리 초에) 일시 정지하는 대기 기간을 도입합니다.

이 코드 라인은 취소 주문의 동작이 너무 자주 되지 않도록 하기 위해 일정 시간 동안 (밀리 초에) 중지하는 대기 기간을 도입합니다.

function updateStatus(msg) {
    LogStatus("Number of debugging sessions:", Counter.i, "succeeded:", Counter.w, "failed:", 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("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ",  Sell one:" + depth.Asks[0].Price + ", Lock times: " + 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("Debug the elephant... The elephant is in gear " + 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("Successful payment: " + opAmount +", Start taking action...");
        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("Didn't get it, start to stop loss, currently buying one: " + 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와 잠금 초기화.

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

다음으로, 우리는while (true)라인별로 루프.

while (true) {
    Sleep(Interval);
    var depth = _C(exchange.GetDepth);
    if (depth.Asks.length === 0 || depth.Bids.length === 0) {
        continue;
    }
    updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ",  Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks);

  • Sleep(Interval): 이 코드 라인은 전략의 실행 주파수를 제어하기 위해 전략이 일정 기간 동안 잠자리에 있게 허용합니다. 인터벌 매개 변수는 잠자리 간격을 정의합니다.

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

  • if (depth.Asks.length === 0 || depth.Bids.length === 0): 이 코드 라인은 시장 깊이 정보를 확인하고 판매 주문과 구매 주문이 존재하는지 확인합니다. 그 중 하나가 존재하지 않으면 시장이 충분한 거래 정보를 가지고 있지 않을 수 있음을 나타냅니다. 따라서 전략은 계속 기다립니다.

  • updateStatus("Searching within the elephant... Buy one: " + depth.Bids[0].Price + ", Sell one:" + depth.Asks[0].Price + ", Lock times: " + locks): 이 코드 줄은 updateStatus 함수를 호출하여 전략의 상태 정보를 업데이트합니다. 가장 높은 입찰 가격, 가장 낮은 요청 가격 및 이전에 잠금 된 시간 ( 잠금) 을 포함하여 현재 시장 상태를 기록합니다.

    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++): 이것은 시장 판매 주문의 가격 및 양 정보를 통과하는 데 사용되는 포 루프입니다.

  • if (depth.Asks[i].Amount >= 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;

시장 구매 주문의 가격 및 양 정보를 계속 탐색하고 첫 번째 구매 주문 (입찰[0]) 을 건너뛰는 것.

  • if ((askPrice - depth.Bids[i].Price) > ElephantSpace): 현재 입찰 가격과 askPrice 사이의 격차가 ElephantSpace보다 크는지 확인합니다. 그렇다면, 그것은 elephant에서 충분히 멀리 떨어져 있음을 나타냅니다. 전략은 더 이상 검색을 계속하지 않을 것입니다.

  • if (depth.Bids[i].Amount >= ElephantAmount): 현재 구매 주문의 양이 ElephantAmount보다 크거나 같는지 확인합니다. 만약 그렇다면 구매 주문 정보를 elephant 변수에 저장합니다.

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

  • locks++: 코끼리이 발견되면 잠금 수를 증가시킵니다. 이것은 시간이 지남에 따라 코끼리의 존재를 여러 번 확인 한 후에만 전략이 실행되도록합니다.

  • if (locks < LockCount): 잠금 시간 수가 요구 사항을 충족하는지 확인합니다. 그렇지 않으면 계속 기다립니다.

    updateStatus("Debug the elephant... The elephant is in gear " + 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("Debug the elephant... The elephant is in gear " + i + ", " + JSON.stringify(elephant)): updateStatus 함수를 호출하여 발견된 코끼리의 기어 위치와 관련 정보를 포함하여 전략의 현재 상태를 기록합니다. 이것은 전략의 상태 표시줄에 표시됩니다.

  • exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): 교환.구매 기능을 사용하여 발견 된 코끼리를 구매하십시오. 구매 가격은 코끼리입니다. 가격 + 페니 틱, 구매 양은 롯이며 구매 작업을 입찰[ + 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("Successful payment: " + opAmount + ", Start taking action...");
    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("Didn't get it, start to stop loss, currently buying one: " + 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): 코끼리을 구매한 후 계정 자산의 변화를 계산합니다. 변화가 0.001보다 작으면 구매가 실패했다는 것을 나타냅니다. 실패의 수를 증가시키고 다음 루프로 계속하십시오.

  • updateStatus("Successful payment: " + opAmount + ", Start taking action..."): 구매된 양을 포함하여 코끼리의 성공적인 구매 정보를 기록합니다.

  • exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): 교환.판매 기능을 사용하여 수익을 위해 성공적으로 구매 된 코끼리를 판매하십시오. 판매 가격은 코끼리입니다. 가격 + (펜니 틱 * 수익 틱).

새로운 무한 순환을 입력합니다. 판매 주문 실행을 기다리기 위해 사용됩니다.

  • 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): 스톱 로스 거래를 실행하고, 현재 시장의 가장 낮은 가격으로 남은 자산을 판매합니다.

마지막으로, 거래가 성공했는지 아닌지에 따라 성공한 거래와 실패한 거래의 수를 업데이트하고 거래 수익을 기록합니다.

이 전략의 핵심 아이디어는 시장에서 코끼리 (대량 구매 주문) 를 찾고, 사서 소액의 수익을 얻기 위해 판매하는 것입니다. 전략 조정을 위해 롯, 오류 재시사 간격 (Interval), 코끼리Amount, 코끼리공간 등 여러 가지 중요한 매개 변수를 포함합니다.

일반적으로 이 전략은 시장 깊이 정보를 활용하여 큰 구매 주문을 식별하고 짧은 기간에 구매 및 판매 거래를 수행하는 것을 목표로 하는 고주파 거래 전략이다. 시장의 지속적인 모니터링과 작은 수익을 빠르게 얻기 위해 구매 및 판매 운영의 실행이 필요합니다. 그러나 중요한 손실을 피하기 위해 위험 관리 및 중지 손실 메커니즘을 고려하면서 시장 변동에 신속한 대응이 필요하기 때문에 또한 높은 위험 전략입니다.

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

전략 실행을 계속할 때, 다음과 같은 작업을 반복적으로 수행합니다.

  1. 첫째, 전략은 판매 주문과 구매 주문의 현재 상황을 이해하기 위해 시장의 깊이 있는 정보를 확인합니다.

  2. 다음으로, 전략은 기준을 충족하는 판매 주문을 찾으려고 노력합니다. 특히 롯보다 크거나 동등한 양의 판매 주문을 찾습니다. 자격 판매 주문이 발견되면 판매 주문의 가격이 askPrice로 기록됩니다.

  3. 다음으로 전략은 코끼리 (대량의 구매 주문) 를 계속 검색합니다. 시장의 구매 주문을 가로질러 첫 번째 (일반적으로 가장 높은 가격의 구매 주문) 을 건너뛰습니다. 기준을 충족하는 코끼리을 찾으면 코끼리에 대한 정보를 기록하고 잠금을 증가시킵니다.

  4. 코끼리의 숫자가 충분히 연속적으로 발견되면 (LockCount 매개 변수에 의해 제어), 전략은 다음 작업을 수행합니다:

  • updateStatus 함수를 호출하여 코끼리의 기구와 관련 정보를 기록합니다.
  • 교환.구매 기능을 사용하여 코끼리을 구매합니다. 코끼리의 구매 가격 + 페니 틱과 롯의 양.
  • 구매 주문 실행을 기다리는 새로운 무한 순환을 시작합니다.
  • 명령 상태 확인, 완료되면 루프를 끊어
  • 대기 시간이 설정된 간격 (WaitInterval) 을 초과하면, 완료되지 않은 모든 주문을 취소합니다.
  • 성공적인 구매 후 계정 자산의 변화를 계산합니다. 변경이 0.001 미만이라면 구매가 실패했다는 것을 나타냅니다. 실패 수를 증가시키고 다음 루프를 계속하십시오.
  • 구매된 수량을 포함하여 성공적 인 코끼리 구매에 대한 정보를 기록하십시오.
  1. 다음으로, 전략은 새로운 무한 루프에 계속 들어가 판매 작업의 실행을 기다리고 있습니다. 이 루프에서, 그것은 다음 행동을 수행합니다:
  • 시장 깊이 정보를 얻고 시장 가격이 이미 스톱 로스 수준에 도달했는지 확인합니다.
  • 만약 시장가격이 스톱 로스 수준에 도달하거나 그 이하로 떨어졌다면, 스톱 로스 거래가 실행됩니다. 즉, 나머지 자산은 판매됩니다.
  • CancelAll 함수를 호출하여 완료되지 않은 모든 주문을 취소하여 포지션 위험을 줄이십시오.
  • 성공한 구매 후 계정 자산의 변경을 다시 확인합니다. 변경이 0.001 미만인 경우 구매가 실패하고 루프를 종료하는 것을 나타냅니다.
  • 마지막으로 거래가 성공했는지 아닌지를 기록하고 거래 결과에 따라 성공과 실패의 수를 업데이트합니다.

전체 전략은 가능한 한 많은 '코끼리'를 잡고 작은 이익을 얻기 위해 위의 작업을 지속적으로 수행합니다. 이것은 시장 변화에 신속하게 대응해야하는 고주파 거래 전략이며 자본을 보호하기 위해 위험 관리 및 스톱-손실 메커니즘을 고려해야합니다. 투자자는 특히 변동성이 높은 시장에서이 전략을 사용하는 것을 신중하게 고려해야합니다.

요약

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

더 많은

2019 FMZ - 모든 권리 보호