1. Introduction — pourquoi RPC en HFT ?1. Introduction — Why RPC in HFT?

2. gRPC Tonic : l'épine dorsale temps-réel2. gRPC Tonic: The Real-Time Backbone

Avantages de gRPC vs REST pour le HFTWhy gRPC over REST for HFT

Streaming bidirectionnel — exempleBidirectional streaming example

// hfthot-lab-core/src/grpc/market_service.rs
use tonic::{Request, Response, Status};
use tokio_stream::wrappers::ReceiverStream;

#[tonic::async_trait]
impl MarketService for HfthotService {
    type StreamTicksStream = ReceiverStream<Result<Tick, Status>>;

    async fn stream_ticks(
        &self,
        request: Request<SubscribeRequest>,
    ) -> Result<Response<Self::StreamTicksStream>, Status> {
        let symbol = request.into_inner().symbol;
        let (tx, rx) = tokio::sync::mpsc::channel(128);

        // Subscribe to Polarway price feed (zero-copy Arrow batches)
        let mut feed = self.polarway.subscribe_feed(&symbol).await?;

        tokio::spawn(async move {
            while let Some(tick) = feed.next().await {
                let msg = Tick {
                    symbol: tick.symbol.clone(),
                    price: tick.close,
                    qty: tick.volume,
                    ts_ms: tick.timestamp_ms,
                    latency_us: tick.pipeline_latency_us,
                };
                if tx.send(Ok(msg)).await.is_err() { break; }
            }
        });

        Ok(Response::new(ReceiverStream::new(rx)))
    }
}

3. Architecture globale de Polarway3. Polarway Overall Architecture

La pile technologiqueTechnology Stack

4. Lakehouse Delta Lake : données ACID à toutes les couches4. Delta Lake Lakehouse: ACID Data at Every Layer

# python/lakehouse/client.py (Polarway LakehouseClient)
from python.lakehouse.client import LakehouseClient

client = LakehouseClient("/app/data/lakehouse")

# ACID write: saves user API keys atomically
success = client.save_api_keys(
    user_id="user-123",
    provider_keys={
        "finnhub": {"api_key": "c8qXXX", "queries_limit": 3600},
    },
    data_sharing_consent=True
)

# The Delta transaction log records this as a new version
# → /lakehouse/api_keys/_delta_log/00000000000000000003.json
# If the write fails mid-way, Delta rolls back => no partial writes

5. Time-Travel : audit réglementaire et débogage5. Time-Travel: Regulatory Audit & Debugging

from datetime import datetime
from python.lakehouse.client import LakehouseClient

client = LakehouseClient("/app/data/lakehouse")

# --- Débogage : état avant un bug en production ---
# Était-ce la version 12 qui avait le mauvais quota ?
users_v12 = client.read_version("users", version=12)
api_keys_v12 = client.read_version("api_keys", version=12)

# --- Audit MiFID II : état à une date précise ---
audit_date = datetime(2026, 1, 15, 14, 0, 0)  # heure de la transaction contestée
state = client.read_at_timestamp("api_keys", audit_date)

# --- Lister toutes les versions disponibles ---
versions = client.list_versions("market/BTC-USDT")
# [{"version": 0, "timestamp": "...", "operation": "WRITE", "rows_added": 1440},
#  {"version": 1, "timestamp": "...", "operation": "WRITE", "rows_added": 1440}]

6. Conformité RGPD out-of-the-box6. Out-of-the-Box GDPR Compliance

# RGPD Article 17 — Droit à l'oubli / Right to erasure

# Étape 1 : soft-delete (tombstone, data still recoverable for 30 days)
client.delete_user_soft(user_id="user-123")

# Étape 2 : suppression physique irréversible (VACUUM)
# Efface tous les fichiers Parquet référencés dans les anciennes versions Delta
client.delete_user_permanent(user_id="user-123")
# → Removes from: users/, sessions/, api_keys/, audit_log/
# → Runs VACUUM (retention_hours=0 for immediate deletion)
# → Old Delta version files physically removed from disk

# Étape 3 : export RGPD (Article 20 — Portabilité)
export = client.export_user_data(user_id="user-123", format="json")
# Returns structured JSON: user + sessions + api_keys + audit_log

7. Performances mesurées7. Measured Performance

8. Intégration dans HFThot : le cycle complet8. Integration with HFThot: The Full Cycle

# Exemple d'intégration complet / Full integration example
import grpc
import hfthot_pb2_grpc as stub
import hfthot_pb2 as pb
from python.lakehouse.client import LakehouseClient

# --- Setup ---
channel = grpc.secure_channel("api.hfthot-lab.eu:50053", grpc.ssl_channel_credentials())
meta = [("x-hfthot-api-key", "hft_pro_your_key")]
signals = stub.SignalServiceStub(channel)
portfolio = stub.PortfolioServiceStub(channel)
lake = LakehouseClient("/app/data/lakehouse")

# --- Streaming regime updates ---
for event in signals.StreamRegime(pb.SubscribeRequest(symbol="BTC-USDT"), metadata=meta):
    if event.confidence > 0.8:
        # Re-optimize portfolio on regime change
        weights = portfolio.Optimize(pb.OptimizeRequest(
            method="risk_parity",
            symbols=["BTC-USDT", "ETH-USDT", "SOL-USDT"],
        ), metadata=meta)

        # Persist allocation decision (ACID write to Delta Lake)
        lake.write_allocation(
            strategy=event.strategy,
            weights=dict(zip(weights.symbols, weights.values)),
            regime=event.to,
            confidence=event.confidence
        )
        print(f"Regime: {event.to} → weights: {weights}")

9. Conclusion9. Conclusion