#engineering

Correttezza per costruzione: il motore di trading deterministico di un prediction market

In un prediction market ogni ordine sposta denaro e il traffico si concentra sullo stesso book negli ultimi minuti di un evento. Abbiamo costruito in Rust un motore il cui nucleo, nei benchmark, applica circa 250.000 ordini al secondo su un solo thread, e il cui stato dipende solo da un log ordinato di comandi: repliche, retry e riavvii diventano innocui, e ogni movimento di denaro lascia una scrittura in partita doppia.

Sistemi finanziari · Rust · Node.js · gRPC · MemoryDB · PostgreSQL

TL;DR: per un prediction market abbiamo costruito in Rust un motore di trading il cui stato dipende solo da un log ordinato e durevole di comandi. Gli ordini sono applicati in memoria da un solo thread, quindi niente lock né pause del garbage collector sul picco di fine evento, e l’ordine dei comandi lo decide un log gestito su Amazon MemoryDB invece di un protocollo di consenso. Nei nostri benchmark il nucleo applica circa 250.000 ordini al secondo su un solo thread. Ne derivano garanzie verificabili: ogni comando è applicato al massimo una volta, dall’app al motore; ogni replica arriva allo stesso stato; ogni movimento di denaro è una scrittura in partita doppia, riconciliata ogni ora con il database; le nuove regole si attivano con un comando nel log. I test confrontano il sistema con riferimenti volutamente semplici.

Un prediction market è una borsa in cui si scambiano previsioni. Per ogni evento (“chi vince la partita?”) si comprano e si vendono contratti sugli esiti possibili: un contratto SÌ paga 1 se l’esito si verifica, un contratto NO paga 1 se non si verifica, e il prezzo del SÌ, fra 0,01 e 0,99, è la probabilità che il mercato assegna a quell’esito. La piattaforma non scommette contro i propri utenti: fa incontrare chi crede in un esito con chi crede nel contrario e guadagna una commissione su ogni scambio.

Per questo cliente abbiamo costruito l’intero sistema: backend, app per iOS, Android e web, back office, infrastruttura e motore di trading. Il motore è il componente in cui un errore costa di più. Un ordine applicato due volte, un arrotondamento sbagliato o due server che non concordano sullo stato non sono difetti estetici, ma denaro creato o distrutto, in un prodotto regolamentato in cui i fondi degli utenti vanno riconciliati. E il carico non è uniforme: si concentra negli ultimi minuti di ogni evento e sugli stessi esiti, cioè proprio quando gli utenti sono più attivi e la piattaforma incassa di più.

La strada più comune per un sistema del genere è gestire i casi difficili uno per uno: un lock qui, una tabella di idempotenza là, un job che riconcilia di notte. Abbiamo scelto l’approccio opposto: un motore in Rust il cui stato dipende soltanto da una sequenza ordinata e durevole di comandi. Se gli stessi comandi producono sempre lo stesso stato, repliche, riavvii, retry e messaggi duplicati smettono di essere casi da gestire e diventano innocui per costruzione. E le stesse scelte che lo rendono corretto lo rendono anche veloce: nei nostri benchmark il nucleo applica circa 250.000 ordini al secondo.

Il collo di bottiglia è un book conteso, e non si risolve aggiungendo server

Davanti a un picco di traffico il riflesso naturale è scalare in orizzontale. Qui non funziona: gli ordini di uno stesso book vanno applicati uno dopo l’altro, in un ordine che tutti devono condividere, e il saldo di un utente è condiviso fra tutti i book su cui opera. Un database relazionale con un lock per ordine trasformerebbe la raffica finale in una coda di transazioni in conflitto, proprio quando conta di più.

Abbiamo quindi separato le responsabilità. Il backend in Node.js gestisce ciò che è “applicazione”: autenticazione, catalogo, verifiche regolamentari, notifiche alle app. Il motore tiene in memoria book, saldi, contratti, commissioni e limiti di spesa, e applica i comandi uno alla volta, su un solo thread. Sembra un passo indietro, ma è la scelta di sistemi come LMAX e TigerBeetle: senza lock né coordinamento fra thread, un ordine completo, dalla validazione al regolamento di entrambe le parti, richiede pochi microsecondi.

Anche il linguaggio è uscito da una misura, non da una preferenza. Abbiamo confrontato il tempo necessario per elaborare un blocco di 1.000 ordini con lo stesso motore semplificato e uno stato di grandi dimensioni:

Linguaggio Mediana p99,9 Caso peggiore
Rust 0,85 ms 1,42 ms 1,6 ms
Node.js 4 ms 21 ms 658 ms

Il dato decisivo è l’ultima colonna. I 658 ms di Node.js sono una pausa del garbage collector, e in una borsa una pausa del genere tende a cadere proprio sul picco, perché è lì che si alloca di più. In Rust, senza garbage collector, il caso peggiore resta vicino a quello tipico: l’ordine piazzato all’ultimo secondo viene trattato come quello piazzato con calma.

Un solo book per esito: più liquidità per gli utenti, conti verificabili per la piattaforma

La modellazione più immediata tratta SÌ e NO come due titoli distinti, ciascuno con il proprio book. Ma così chi compra SÌ a 0,40 e chi compra NO a 0,60, che insieme formano esattamente una coppia da 1, non si incontrerebbero mai: servirebbe una controparte in mezzo, cioè il ruolo che la piattaforma ha scelto di non avere, e il risultato sarebbero book più vuoti e prezzi peggiori.

Abbiamo dato a ogni esito un solo book, in cui ogni prezzo è un prezzo del SÌ. Comprare NO a 0,60 equivale a offrire 0,40 sul lato opposto, e vendere un SÌ posseduto ha sul book lo stesso effetto di comprare un NO. Tutti gli ordini finiscono su due soli lati, e ogni abbinamento crea una nuova coppia di contratti, la passa da un utente all’altro o la chiude restituendo il denaro.

Il beneficio va oltre la liquidità. Da questo modello discende un invariante semplice: per ogni esito i contratti SÌ in circolazione sono quanti i NO, e ogni coppia è coperta da un’unità di denaro depositata. Il denaro entrato meno quello uscito è sempre uguale ai saldi, più il denaro bloccato dagli ordini aperti, più le commissioni, più il valore delle coppie in circolazione. La contabilità diventa una legge di conservazione, e una legge di conservazione si controlla. Anche le commissioni sono progettate per rispettarla: una configurazione in cui un abbinamento pagherebbe più di quanto incassa viene rifiutata.

Il determinismo è una disciplina, e la rendiamo verificabile

Un solo thread garantisce un ordine, non lo stesso risultato su macchine diverse. Le divergenze fra repliche raramente nascono da un errore nell’abbinamento: nascono da dettagli che sembrano innocui, come l’ora di sistema, l’ordine in cui si scorre una mappa o un arrotondamento. Per questo il nucleo è una libreria pura, e ogni sua regola chiude una di queste strade.

Il tempo arriva con il comando, assegnato dal log, mai dall’orologio della macchina: due repliche non possono decidere diversamente se un ordine è arrivato prima o dopo la chiusura. Il denaro è un intero in tutto il sistema, e un importo non valido viene rifiutato, mai arrotondato. Ogni operazione verifica tutto prima di scrivere, quindi un comando rifiutato lascia lo stato esattamente com’era. Sopra queste regole c’è una rete di sicurezza: se un controllo interno fallisce mentre il motore applica un comando, il motore si ferma invece di proseguire, perché un saldo sbagliato verrebbe replicato ovunque e presentato come corretto. Le regole sono progettate perché non accada, e i test lo verificano dopo ogni comando.

Due strumenti trasformano la disciplina in qualcosa che si può verificare. Un audit ricalcola da zero ogni invariante, dalla conservazione del denaro alla parità fra SÌ e NO: i test lo eseguono dopo ogni comando, e a runtime ogni replica lo esegue su ogni snapshot che salva, così un’anomalia emerge in pochi minuti e non a fine mese. Un’impronta (digest) dell’intero stato permette di confrontare due repliche nella stessa posizione del log con un solo numero, e uno snapshot che una volta ricaricato dà un’impronta diversa viene scartato. L’impronta è costruita in modo che un campo aggiunto allo stato senza includerlo non compili: il controllo resta valido anche dopo la prossima modifica, chiunque la faccia.

Un log gestito al posto di un protocollo di consenso

Se lo stato è funzione dei comandi, basta rendere durevoli i comandi. Resta da decidere chi stabilisce il loro ordine. La risposta da manuale è un protocollo di consenso come Raft, in cui un leader eletto dai nodi riceve i comandi e li replica. Lo abbiamo valutato nella forma di Aeron Cluster: commit sotto il millisecondo, ma un costo operativo, fra nodi con identità stabile e rilasci orchestrati, che il cliente avrebbe pagato per sempre.

Abbiamo scelto di affidare l’ordine al log invece che a un leader. Ogni comando viene scritto su uno stream Redis ospitato su Amazon MemoryDB, che conferma una scrittura solo dopo averla registrata nel proprio log transazionale, distribuito su più zone di disponibilità: un failover non perde un comando confermato. Ogni replica del motore accetta comandi, li accoda al log, legge l’intero log e calcola l’intero stato. Non c’è un leader da eleggere, e durante un rilascio la versione vecchia e quella nuova possono girare insieme, purché applichino le stesse regole: più avanti vediamo come lo garantiamo.

Ordine con chiave di idempotenza Autenticazione e verifiche Comando con id derivato dalla chiave Scrittura insieme ai comandi in attesa Posizione nel log Esito e posizione Risposta e aggiornamenti in tempo reale Scritture contabili, tramite una coda Ogni replica legge e applica la stessa voce App Backend Replica del motore Log dei comandi PostgreSQL

Togliere il leader lascia aperti tre problemi, e ognuno ha una risposta semplice.

Il primo è il throughput: scrivere sul log un comando alla volta satura presto la replica. Ogni replica raggruppa invece i comandi arrivati mentre la scrittura precedente è in corso e li scrive insieme, lo stesso principio del group commit dei database. A basso traffico un comando parte subito, sotto carico i gruppi crescono con il traffico, e nei nostri benchmark il throughput quasi raddoppia. Le repliche servono alla disponibilità e alle letture, e il log è dietro un’interfaccia che permette di sostituirlo senza riscrivere il nucleo, il giorno in cui servirà più capacità.

Il secondo è il tempo: se il motore non legge l’orologio, qualcosa deve dirgli che un evento va chiuso. Quando una scadenza arriva, ogni replica accoda un comando di “tick”: il primo applicato esegue la chiusura, gli altri non trovano nulla da fare. Un ordine arrivato anche un millisecondo dopo la chiusura trova l’evento già chiuso, quindi nessuno può operare oltre l’orario di chiusura, e non esiste un cron nel backend che possa sbagliare orario o contraddire il motore.

Il terzo sono le letture. Una replica può essere qualche millisecondo indietro, e un utente non deve veder sparire l’ordine appena piazzato. Ogni scrittura restituisce la propria posizione nel log, l’app la rimanda con la lettura successiva e la replica aspetta, se serve, di averla applicata: su qualunque replica, l’utente non vede mai uno stato più vecchio di uno già visto.

Centinaia di migliaia di ordini al secondo: la correttezza non costa velocità

Garanzie così forti di solito si pagano in prestazioni. Qui succede il contrario: senza lock, senza garbage collector e senza un protocollo di consenso da attraversare, il lavoro sensibile si riduce a pochi microsecondi di calcolo in memoria. Nei nostri benchmark, in cui ogni ordine paga tutto ciò che paga un ordine reale, dalla validazione al regolamento di entrambe le parti:

Scenario Ordini al secondo
Tutti gli ordini sullo stesso esito circa 250.000
1.000 esiti aperti e un milione di utenti oltre 150.000
Motore completo, con la scrittura durevole di ogni comando circa 80.000

Il dato che conta di più è il primo: lo scenario che preoccupa ogni exchange, tutti sullo stesso esito negli ultimi minuti, è quello in cui il nucleo va più veloce. E perché le prestazioni non peggiorino nel tempo, memoria e istruzioni per ordine sono soglie in CI: una pull request che rende il motore sensibilmente più lento non passa.

I retry sono sempre sicuri, dall’app fino al motore

Un utente che preme “compra” su una rete instabile non sa se l’ordine è partito. Se ritenta, deve ottenere l’ordine una volta sola, e per un prelievo un doppione costa ancora di più. La soluzione più diffusa è una tabella di idempotenza nel backend, ma qui l’effetto avviene nel motore, e una tabella esterna lascia sempre una finestra fra l’esecuzione e la registrazione dell’esito. Abbiamo portato la garanzia dove avviene l’effetto: l’id del comando nasce dall’intenzione dell’utente, e la deduplica la fa il motore.

L’app genera una chiave per ogni intenzione e la riusa finché l’esito non è certo. Il backend ne ricava l’id del comando, legato anche all’utente, così una chiave non può mai indicare l’ordine di qualcun altro. Il motore ricorda per un intervallo di tempo ogni id applicato con la risposta data, rifiuti compresi, e a un comando ripetuto restituisce la risposta originale senza effetti. Il backend può quindi ritentare con lo stesso id, anche su un’altra replica, e se il tempo a disposizione finisce risponde in modo onesto: “esito sconosciuto, riprova”. Che la scrittura sia fallita, la risposta si sia persa o la replica sia caduta subito dopo la scrittura, il comando viene applicato al massimo una volta.

Resta un vincolo che di solito nessuno scrive: ogni ripetizione automatica, dall’app ai job che muovono denaro, deve concludersi prima che il motore smetta di ricordare quell’id. Il backend lo verifica all’avvio e, se la configurazione lo viola, si rifiuta di partire. È il tipo di errore che altrimenti si scopre in produzione, il giorno in cui qualcuno allunga un timeout.

Ogni movimento di denaro ha un’identità, e un duplicato non costa nulla

Una piattaforma regolamentata non ha bisogno solo di saldi corretti, ma di poter dimostrare come ci si è arrivati. Per questo ogni movimento, di denaro o di contratti, esce dal motore come un trasferimento fra due conti, in partita doppia: i soli trasferimenti bastano a ricostruire ogni saldo, e i test lo verificano dopo ogni comando.

Portare questi movimenti nel database è il punto in cui un sistema replicato di solito si complica: chi esporta, come si evitano i doppioni, cosa succede se chi esporta cade a metà. Il determinismo permette di rispondere senza coordinamento, perché ogni evento ha un’identità deterministica: la posizione nel log più un numero progressivo, uguale su ogni replica e a ogni riesecuzione. PostgreSQL la usa come chiave univoca e scarta i duplicati, quindi basta una normale coda SQS, che può consegnare un messaggio più volte. Una sola replica alla volta esporta, ma solo per efficienza: se per un momento due repliche esportano insieme, il database riceve soltanto duplicati, e non serve nessun protocollo di coordinamento.

Su queste basi la riconciliazione diventa routine: ogni ora un job confronta i totali del motore con la somma delle scritture contabili in PostgreSQL alla stessa posizione del log, e qualunque differenza viene segnalata. Prima di essere compattato, il log viene archiviato, così ogni periodo archiviato può essere rieseguito da capo per un controllo.

Cambiare le regole di una borsa mentre è aperta

Un motore deterministico pone un problema che i sistemi tradizionali non hanno. In un rilascio progressivo la replica nuova e quella vecchia girano insieme sullo stesso log: se la nuova applicasse una commissione diversa o un nuovo controllo, le due divergerebbero. E all’avvio la versione nuova rilegge comandi che la vecchia aveva già applicato e confermato agli utenti: ricalcolarli con regole nuove significherebbe riscrivere il passato.

Abbiamo separato il rilascio dall’attivazione. La versione delle regole fa parte dello stato e cambia solo con un comando nel log, inviato da un operatore dal back office: ogni replica cambia regole esattamente in quella voce, e una riesecuzione applica ogni voce con le regole del suo momento. Finché la nuova versione non è attiva, il nuovo binario calcola e scrive esattamente ciò che scriveva il precedente, quindi il rilascio non cambia nulla e si può annullare. Una replica che incontra una versione che non conosce si ferma prima di applicarla, invece di divergere, e riparte con il binario nuovo. Ogni release include uno stato e un tratto di log scritti dal binario precedente, e la CI verifica a ogni pull request che il nuovo li rilegga e li riscriva identici: la possibilità di tornare indietro è verificata, non presunta.

È così che il motore cresce insieme al prodotto. Il costo di ogni posizione comprensivo delle commissioni pagate, che cambia ciò che il motore calcola per ogni utente e ciò che l’app mostra nel profilo, è stato rilasciato così: spento, pronto per essere attivato con un comando nel log, senza azzerare lo stato né riscrivere la storia.

Test che confrontano il sistema con un riferimento semplice

Testare un sistema distribuito che muove denaro di solito significa scrivere molti scenari e sperare di aver pensato a quelli giusti. Il determinismo permette qualcosa di più forte: confrontare il sistema con un riferimento abbastanza semplice da verificarlo a mano. I property-based test generano sessioni casuali e riproducibili di centinaia di comandi, e verificano che gli invarianti reggano dopo ogni comando, che due motori con gli stessi input concordino su risposte, eventi e impronta, e che l’abbinamento dia gli stessi risultati di un’implementazione volutamente ingenua.

Lo stesso principio vale per le repliche. Cluster da 2 a 10 repliche, sotto traffico concorrente casuale con invii duplicati, arresti improvvisi, rilasci e riavvii, devono produrre esattamente gli stessi risultati di un solo motore che legge il log in ordine. Nei test di failover del log, con un cambio di nodo programmato la pausa più lunga fra due risposte è stata di circa 50 ms, e con il nodo primario bloccato all’improvviso le scritture riprendono circa tre secondi dopo la promozione del nodo di riserva, senza perdere alcun comando confermato. Nel backend, le race condition e le risposte perse dopo un ordine eseguito sono riprodotte in modo deterministico contro un vero binario del motore, così un difetto di concorrenza fa fallire il test a ogni esecuzione, non una volta su cento.

Il valore per la piattaforma

Per un prediction market il motore di trading è il prodotto: decide chi ha comprato cosa, a quale prezzo e chi viene pagato alla fine. Quello che abbiamo costruito dà al cliente garanzie verificabili invece di promesse. Il denaro si conserva, e un audit lo controlla. Ogni operazione è applicata al massimo una volta, dall’app fino al log. Ogni replica arriva allo stesso stato, confrontabile con un solo numero. Ogni movimento ha una scrittura contabile, e ogni ora i totali del motore vengono riconciliati con il database. E tutto questo non costa velocità: nei benchmark il nucleo applica centinaia di migliaia di ordini al secondo, anche con tutto il traffico sullo stesso esito. Le stesse scelte rendono il sistema semplice da gestire e da far evolvere: il lavoro sensibile sta in un solo thread, la durabilità è affidata a un servizio gestito e le regole nuove entrano in vigore senza fermare il mercato.

Il metodo vale oltre questo progetto. Repliche che divergono, risposte perse, messaggi duplicati e riavvii a metà non si risolvono gestendoli uno per uno, ma rendendo il sistema deterministico e ogni sua uscita identificabile. A quel punto ripetere un’operazione è innocuo, e la correttezza smette di essere una speranza per diventare qualcosa che i test verificano a ogni modifica.