開発者向け統合ガイド

#!/usr/bin/env python3
"""
VCP Backtest Audit Logger
バックテストの全取引を監査可能な形式で記録
"""
from vcp import VCPLogger, Tier, EventType
from datetime import datetime
import uuid

# ロガー初期化（Silver Tier、テスト環境向け）
logger = VCPLogger(
    tier=Tier.SILVER,
    private_key_path="./test_key.pem",
    output_dir="./vcp_audit_logs/"
)

# バックテストの取引イベントをロギング
def log_backtest_trade(symbol, side, quantity, price, timestamp):
    """
    バックテスト取引をVCP形式でログ
    
    Args:
        symbol: 通貨ペア (例: "EURUSD")
        side: BUY / SELL
        quantity: 数量（String型で精度維持）
        price: 価格（String型で精度維持）
        timestamp: 取引時刻
    """
    event_id = str(uuid.uuid7())  # UUID v7で時系列ソート可能
    
    logger.log_event(
        event_id=event_id,
        event_type=EventType.ORDER_ACCEPTED,
        timestamp=timestamp,
        payload={
            "symbol": symbol,
            "side": side,
            "quantity": str(quantity),  # 必ずString型
            "price": str(price),        # 必ずString型
            "backtest": True,
            "strategy": "mean_reversion_v2"
        }
    )

# 使用例
if __name__ == "__main__":
    # バックテストループ
    trades = [
        ("EURUSD", "BUY", "100000", "1.08450", datetime.now()),
        ("GBPUSD", "SELL", "50000", "1.26320", datetime.now()),
    ]
    
    for symbol, side, qty, price, ts in trades:
        log_backtest_trade(symbol, side, qty, price, ts)
    
    # VCPチェーンを検証
    if logger.verify_chain():
        print("✓ バックテストログの整合性確認完了")
        logger.export_json("backtest_audit_2024.json")
    else:
        print("✗ チェーン整合性エラー検出")

/**
 * VCP Platinum Tier Logger for HFT
 * マイクロ秒レベルの低レイテンシ実装
 */
#include <vcp/platinum.hpp>
#include <vcp/sbe_encoder.hpp>
#include <vcp/ptp_clock.hpp>

class HFTVCPLogger {
private:
    vcp::PlatinumLogger logger_;
    vcp::PTPClock ptp_clock_;
    vcp::SBEEncoder encoder_;
    vcp::RingBuffer<vcp::TradeEvent, 65536> event_buffer_;

public:
    HFTVCPLogger() 
        : logger_(vcp::ClockSource::PTP_HARDWARE, vcp::Encoding::SBE),
          ptp_clock_("/dev/ptp0"),
          encoder_(),
          event_buffer_() {
        // ロックフリー・リングバッファで非同期ロギング
        logger_.set_async_mode(true);
    }

    // 注文受付イベントをナノ秒精度でログ
    inline void log_order_accepted(
        uint64_t order_id,
        const char* symbol,
        Side side,
        const char* quantity,
        const char* price
    ) {
        // PTCハードウェアクロックから直接タイムスタンプ取得
        uint64_t timestamp_ns = ptp_clock_.now_ns();
        
        // SBEでゼロコピー・エンコーディング
        vcp::TradeEvent event;
        event.event_id = vcp::uuid_v7_generate(timestamp_ns);
        event.event_type = vcp::EventType::ORDER_ACCEPTED;
        event.timestamp_ns = timestamp_ns;
        event.order_id = order_id;
        std::strncpy(event.symbol, symbol, sizeof(event.symbol));
        event.side = side;
        std::strncpy(event.quantity, quantity, sizeof(event.quantity));
        std::strncpy(event.price, price, sizeof(event.price));
        
        // リングバッファにプッシュ（ロックフリー、取引スレッドをブロックしない）
        event_buffer_.push(event);
    }

    // バックグラウンドスレッドで定期的にフラッシュ
    void async_flush_worker() {
        while (running_) {
            vcp::TradeEvent event;
            if (event_buffer_.pop(event)) {
                logger_.write_event(event);
            }
        }
    }
};

// 使用例
int main() {
    HFTVCPLogger vcp_logger;
    
    // 取引エンジンのコールバック
    trading_engine.on_order_accepted([&](const Order& order) {
        // 1マイクロ秒未満のオーバーヘッド
        vcp_logger.log_order_accepted(
            order.id,
            order.symbol.c_str(),
            order.side,
            order.quantity_str.c_str(),
            order.price_str.c_str()
        );
    });
    
    return 0;
}

//+------------------------------------------------------------------+
//|                                            VCP_ClientLogger.mq5 |
//|                                  VeritasChain Standards Org     |
//|                                       https://veritaschain.org  |
//+------------------------------------------------------------------+
#property copyright "VeritasChain Standards Organization"
#property link      "https://veritaschain.org"
#property version   "1.00"

#include <VCP_Bridge.mqh>

// グローバル変数
CVCPBridge vcp;
string private_key = "your_private_key_here";  // 本番では暗号化ストレージから取得

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit() {
    // VCP Bridge初期化（Silver Tier、クライアントサイド署名）
    if (!vcp.Init(TIER_SILVER, private_key)) {
        Print("VCP初期化エラー");
        return INIT_FAILED;
    }
    
    Print("VCP Logger初期化完了 (Silver Tier)");
    Print("クライアントサイド署名モード: ブローカー非依存");
    
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Trade transaction event handler                                  |
//+------------------------------------------------------------------+
void OnTradeTransaction(
    const MqlTradeTransaction& trans,
    const MqlTradeRequest& request,
    const MqlTradeResult& result
) {
    // 注文が追加された時
    if (trans.type == TRADE_TRANSACTION_ORDER_ADD) {
        LogOrderAccepted(trans, request);
    }
    
    // 注文が執行された時
    if (trans.type == TRADE_TRANSACTION_DEAL_ADD) {
        LogOrderExecuted(trans, result);
    }
}

//+------------------------------------------------------------------+
//| 注文受付をVCPログに記録                                          |
//+------------------------------------------------------------------+
void LogOrderAccepted(
    const MqlTradeTransaction& trans,
    const MqlTradeRequest& request
) {
    // VCPイベント構築
    VCPEvent event;
    event.event_id = vcp.GenerateUUIDv7();  // UUID v7生成
    event.event_type = "ORDER_ACCEPTED";
    event.timestamp = TimeGMT();
    
    // ペイロード（JSON形式）
    string payload = StringFormat(
        "{\"symbol\":\"%s\",\"side\":\"%s\",\"quantity\":\"%s\",\"price\":\"%s\",\"order_id\":%I64d}",
        trans.symbol,
        (trans.order_type == ORDER_TYPE_BUY || trans.order_type == ORDER_TYPE_BUY_LIMIT) ? "BUY" : "SELL",
        DoubleToString(trans.volume, 2),  // String型に変換（精度維持）
        DoubleToString(trans.price, _Digits),  // String型に変換
        trans.order
    );
    event.payload = payload;
    
    // クライアントサイドで署名してVCCに送信
    if (vcp.SendEventAsync(event)) {
        Print("✓ VCPログ送信成功: ", event.event_id);
    } else {
        Print("✗ VCPログ送信失敗（リトライキューに追加）");
    }
}

//+------------------------------------------------------------------+
//| 注文執行をVCPログに記録                                          |
//+------------------------------------------------------------------+
void LogOrderExecuted(
    const MqlTradeTransaction& trans,
    const MqlTradeResult& result
) {
    VCPEvent event;
    event.event_id = vcp.GenerateUUIDv7();
    event.event_type = "ORDER_EXECUTED";
    event.timestamp = TimeGMT();
    
    string payload = StringFormat(
        "{\"deal_id\":%I64d,\"order_id\":%I64d,\"symbol\":\"%s\",\"volume\":\"%s\",\"price\":\"%s\"}",
        trans.deal,
        trans.order,
        trans.symbol,
        DoubleToString(trans.volume, 2),
        DoubleToString(trans.price, _Digits)
    );
    event.payload = payload;
    
    vcp.SendEventAsync(event);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
    // 未送信のイベントをフラッシュ
    vcp.FlushPendingEvents();
    Print("VCP Logger停止");
}