Developers Integration Guide

# VCC API usage example
curl -X POST https://api.veritaschain.cloud/v1/events \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "event_type": "ORDER_ACCEPTED",
    "symbol": "BTCUSD",
    "side": "BUY",
    "quantity": "0.5",
    "price": "45000.00"
  }'

# VCC API usage example
curl -X POST https://api.veritaschain.cloud/v1/events \
  -H "Authorization: Bearer YOUR_API_KEY" \
                    

                        

                            HFT Optimization
                        
                        

                            In microsecond-competitive HFT environments, logging is designed not to block trading threads.
                            Platinum Tier exclusive ultra-low latency implementation.
                        
                    
        
        

            

                Code Examples
            

            
            

                

                    Python: Backtest Audit Implementation
                
                

                    
#!/usr/bin/env python3
"""
VCP Backtest Audit Logger
Record all backtest trades in auditable format
"""
from vcp import VCPLogger, Tier, EventType
from datetime import datetime
import uuid

# Initialize logger (Silver Tier, test environment)
logger = VCPLogger(
    tier=Tier.SILVER,
    private_key_path="./test_key.pem",
    output_dir="./vcp_audit_logs/"
)

# Log backtest trade events
def log_backtest_trade(symbol, side, quantity, price, timestamp):
    """
    Log backtest trade in VCP format
    
    Args:
        symbol: Currency pair (e.g., "EURUSD")
        side: BUY / SELL
        quantity: Quantity (String type to maintain precision)
        price: Price (String type to maintain precision)
        timestamp: Trading timestamp
    """
    event_id = str(uuid.uuid7())  # UUID v7 for chronological sorting
    
    logger.log_event(
        event_id=event_id,
        event_type=EventType.ORDER_ACCEPTED,
        timestamp=timestamp,
        payload={
            "symbol": symbol,
            "side": side,
            "quantity": str(quantity),  # Must be String type
            "price": str(price),        # Must be String type
            "backtest": True,
            "strategy": "mean_reversion_v2"
        }
    )

# Usage example
if __name__ == "__main__":
    # Backtest loop
    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)
    
    # Verify VCP chain
    if logger.verify_chain():
        print("✓ Backtest log integrity confirmed")
        logger.export_json("backtest_audit_2024.json")
    else:
        print("✗ Chain integrity error detected")

                
            

            
            

                

                    C++: Ultra-Low Latency HFT Implementation
                
                

                    
/**
 * VCP Platinum Tier Logger for HFT
 * Microsecond-level low latency implementation
 */
#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_() {
        // Lock-free ring buffer for async logging
        logger_.set_async_mode(true);
    }

    // Log order accepted event with nanosecond precision
    inline void log_order_accepted(
        uint64_t order_id,
        const char* symbol,
        Side side,
        const char* quantity,
        const char* price
    ) {
        // Get timestamp directly from PTP hardware clock
        uint64_t timestamp_ns = ptp_clock_.now_ns();
        
        // Zero-copy encoding with 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));
        
        // Push to ring buffer (lock-free, doesn't block trading thread)
        event_buffer_.push(event);
    }

    // Periodic flush in background thread
    void async_flush_worker() {
        while (running_) {
            vcp::TradeEvent event;
            if (event_buffer_.pop(event)) {
                logger_.write_event(event);
            }
        }
    }
};

// Usage example
int main() {
    HFTVCPLogger vcp_logger;
    
    // Trading engine callback
    trading_engine.on_order_accepted([&](const Order& order) {
        // Less than 1 microsecond overhead
        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;
}

                
            

            
            

                

                    MQL5: Client-Side Signing EA for MT5
                
                

                    
//+------------------------------------------------------------------+
//|                                            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>

// Global variables
CVCPBridge vcp;
string private_key = "your_private_key_here";  // Retrieve from encrypted storage in production

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit() {
    // Initialize VCP Bridge (Silver Tier, client-side signing)
    if (!vcp.Init(TIER_SILVER, private_key)) {
        Print("VCP initialization error");
        return INIT_FAILED;
    }
    
    Print("VCP Logger initialized (Silver Tier)");
    Print("Client-side signing mode: Broker-independent");
    
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Trade transaction event handler                                  |
//+------------------------------------------------------------------+
void OnTradeTransaction(
    const MqlTradeTransaction& trans,
    const MqlTradeRequest& request,
    const MqlTradeResult& result
) {
    // When order is added
    if (trans.type == TRADE_TRANSACTION_ORDER_ADD) {
        LogOrderAccepted(trans, request);
    }
    
    // When order is executed
    if (trans.type == TRADE_TRANSACTION_DEAL_ADD) {
        LogOrderExecuted(trans, result);
    }
}

//+------------------------------------------------------------------+
//| Log order accepted to VCP                                        |
//+------------------------------------------------------------------+
void LogOrderAccepted(
    const MqlTradeTransaction& trans,
    const MqlTradeRequest& request
) {
    // Build VCP event
    VCPEvent event;
    event.event_id = vcp.GenerateUUIDv7();  // Generate UUID v7
    event.event_type = "ORDER_ACCEPTED";
    event.timestamp = TimeGMT();
    
    // Payload (JSON format)
    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),  // Convert to String (maintain precision)
        DoubleToString(trans.price, _Digits),  // Convert to String
        trans.order
    );
    event.payload = payload;
    
    // Sign client-side and send to VCC
    if (vcp.SendEventAsync(event)) {
        Print("✓ VCP log sent successfully: ", event.event_id);
    } else {
        Print("✗ VCP log send failed (added to retry queue)");
    }
}

//+------------------------------------------------------------------+
//| Log order execution to 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) {
    // Flush pending events
    vcp.FlushPendingEvents();
    Print("VCP Logger stopped");
}

                
            
        

        
        

            

                GitHub Repositories
            
            

                

                    

                        VCP Specification
                    
                    

                        Official specification, schema definitions, conformance tests
                    
                    
                        View vcp-spec
                    
                

                

                    

                        Python SDK
                    
                    

                        vcp-core-py: Python library and documentation
                    
                    
                        View vcp-core-py
                    
                

                

                    

                        C++ SDK
                    
                    

                        vcp-core-cpp: C++ library for HFT
                    
                    
                        View vcp-core-cpp
                    
                

                

                    

                        MQL Bridge
                    
                    

                        vcp-mql-bridge: MT4/MT5 integration library
                    
                    
                        View vcp-mql-bridge
                    
                
            

            

                

                    Community Contributions
                
                

                    VCP is an open standard. We welcome pull requests, bug reports, and feature proposals.
                
                
                    View GitHub Organization 
                
            
        

        
        

            

                Need Technical Support?
            
            

                Contact us for integration questions, PoC support, or enterprise deployment consultation
            
            

                
                    Email Us
                
                
                    Discord Community