Introduzione
La comunità che si occupa dello sviluppo della blockchain ha bisogno da tempo di approcci efficaci per la sicurezza e l'integrità degli smart contract.
## Introduzione e abstract
Questo nuovo sistema di verifica formale cambierà il modo in cui gli sviluppatori possono capire se i loro contratti intelligenti Solidity funzionano bene. È più flessibile rispetto ad altri metodi automatici tradizionali di dimostrazione dei teoremi perché è più programmabile dall'uomo, ma offre anche più flessibilità nell'espressione e nella dimostrazione delle proprietà di correttezza rispetto al passato.
Questo rende più facile per gli sviluppatori iniziare a creare prove che dimostrino che le specifiche derivano dalla rappresentazione astratta.
Introduzione al Framework
Il framework mette insieme prove verificabili dal computer sulla correttezza degli smart contract Yul in un sottolinguaggio del Lean proving assistant e può compilare specifiche per eseguirle su EVM in linea con i test per controllare la correttezza del modello.
Questo metodo sfrutta le ricche librerie matematiche e l'automazione delle dimostrazioni dell'ecosistema Lean, quindi richiede più intervento manuale rispetto ad altri metodi di automazione conosciuti, ma qualsiasi argomento di correttezza scrivibile su carta può essere dimostrato al computer.
Il framework usa librerie di formalizzazione matematica efficaci e opzioni di automazione specifiche per il settore. Comunque, come mostrano molti teoremi matematici di base, ci saranno sempre affermazioni che non si possono dimostrare in nessun sistema abbastanza potente da provarle.
Questa possibilità dovrebbe aprire la strada alla verifica delle proprietà di correttezza dei contratti intelligenti complessi. Il framework è particolarmente utile per mostrare i suoi punti di forza verificando le proprietà complesse degli algoritmi di approssimazione numerica usati nelle applicazioni finanziarie decentralizzate e nei verificatori a conoscenza zero on-chain.
Architettura tecnica e caratteristiche
Per rendere tutto più affidabile, il framework è stato finanziato con sovvenzioni per testare la semantica rispetto alle suite di test di conformità Ethereum e per estendere il modello ai più recenti piani di aggiornamento di Ethereum. Questo modello migliorato sarà pubblicato come bene pubblico.
Il framework ha un generatore di condizioni di verifica che può estrarre i programmi Yul nell'assistente di prova Lean. Non solo divide i programmi in blocchi facili da gestire e da capire, ma crea anche descrizioni semplici della semantica di questi blocchi.
Il framework supporta anche la scrittura di dimostrazioni grazie a una libreria di teoremi e strumenti automatizzati. Le dimostrazioni possono poi essere controllate con l'aiuto di LeanCompiler, il cui kernel di verifica delle dimostrazioni è un po' più piccolo, ma che al momento sembra non avere bug nel senso che non accetta dimostrazioni di proposizioni false.
Questo approccio ha il vantaggio di permettere di scrivere qualsiasi proprietà che possa essere scritta e dimostrata formalmente su carta e di verificarla con LeanCompiler, che ha un kernel di verifica delle prove relativamente piccolo e che attualmente si ritiene privo di bug nel senso che accetta prove di proposizioni false. Questa flessibilità è maggiore rispetto alla maggior parte dei metodi automatizzati, che sono limitati dal ragionamento integrato dei metodi.
Componibilità e astrazione
Le proprietà di composizionalità e astrazione significano che le parti di codice che hanno già dimostrato di funzionare bene vengono usate anche in situazioni nuove. Questo permette di sostituire grandi parti di codice complicato con semplici dichiarazioni delle loro azioni.
Può anche aiutare a sostituire in modo sicuro le implementazioni di codice con altre alternative ma con lo stesso significato, tipo ottimizzare gli algoritmi e mantenere le garanzie di correttezza.
Il framework offre un'automazione controllata ed estendibile grazie a procedure personalizzate che producono prove verificate dal sistema sottostante. Questo riduce di molto il lavoro manuale e le garanzie di verifica rimangono intatte.
Componenti di sistema e flusso di lavoro
Il framework ha tre parti principali che lavorano insieme per dare un sacco di potere di verifica:
- •Modello del dialetto Yul EVM che spiega la semantica del codice Yul nell'ambiente dell'assistente di prova. È questo che dà al ragionamento sul comportamento dei programmi la sua semantica di base
- •Raccolta di tattiche e teoremi personalizzati pensati apposta per rendere più facile scrivere prove sui programmi Yul. Questi strumenti gestiscono modelli e operazioni comuni che si vedono spesso nella verifica degli smart contract
- •Il generatore di condizioni di verifica crea modelli di prova con una struttura di alto livello e produce automaticamente prove che semplificano i programmi Yul in forme canoniche. Queste condizioni di verifica non sono più specificate in termini di linguaggio Yul, ma in modo più accessibile
La verifica è un processo strutturato. Gli utenti iniziano con un programma Yul e lo compilano con opzioni speciali del compilatore per produrre un codice che soddisfi i presupposti strutturali del framework. Questo codice viene quindi elaborato dal generatore di condizioni di verifica per generare l'infrastruttura di prova richiesta.
Inizia oggi stesso a verificare i tuoi contratti intelligenti
Dai una svolta al tuo sviluppo Solidity con la verifica formale. Inizia subito.
Requisiti per la compilazione dei contratti
Il framework parte dal presupposto che ci sia una certa struttura dei codici Yul.
Implementazione pratica: funzione di moltiplicazione
Per implementare una funzione di moltiplicazione, devi rispettare i requisiti strutturali compilando il codice seguente con flag specifici del compilatore. Questo esempio mostra come il framework è in grado di gestire funzioni scritte dall'utente e strutture di flusso di controllo arbitrarie.
Il processo di moltiplicazione ha due input e fa una moltiplicazione aggiungendo un valore a un accumulatore il numero di volte necessario.
Le interruzioni condizionali vengono usate all'interno dei cicli invece delle condizioni di ciclo standard per mostrare come il framework possa funzionare con uno scenario di flusso di controllo complesso.
Processo di generazione delle condizioni di verifica
Quando si usa il generatore di condizioni di verifica su un programma, si ottiene una struttura di file organizzata con i file che ha creato. In generale, la struttura è così:
- •File generati in base a ciascun file Yul e a un contratto
- •Altre sottocartelle comuni di blocchi di codice astratti
Il framework scompone automaticamente i programmi in unità e crea una logica di integrazione per assicurarsi che le unità composte siano il programma originale. Ogni blocco di codice elementare crea tre tipi di file che possono essere facilmente interpretati, componenti riutilizzabili e migliori prestazioni e scalabilità.
Il codice del programma Yul e il ragionamento specifico del framework includono condizioni di verifica e prove che l'esecuzione del blocco di codice porta a una condizione di verifica rappresentata nei file di famiglia generati. Questi file collegano le specifiche/soddisfazioni e l'esecuzione del codice, e bisogna stare attenti ai file di famiglia dell'utente perché sono quelli generati dal framework che contengono la logica di verifica che l'utente deve completare.
Per colmare le lacune logiche, il sistema deve fornire specifiche di comportamento condizionali. Per esprimere la semantica del controllo di ciclo, il sistema offre utilità che eseguono operazioni di routine come l'uscita dal ciclo e l'accesso alle variabili negli stati del programma.
Le specifiche non devono necessariamente essere errate, ma potrebbero non riflettere facilmente il comportamento previsto nel caso in cui non specifichino adeguatamente alcuni punti importanti. I problemi relativi alle specifiche sono solitamente la parte più difficile della verifica formale, a volte anche più della stesura delle prove stesse.
Sfide di verifica del ciclo
I loop sono davvero difficili da controllare con un sistema di verifica, e questo è in parte dovuto al ragionamento induttivo che spesso serve per un sistema del genere. Il framework affronta questo problema dando specifiche sistematiche dei componenti dei loop.
L'utente deve specificare:
- •Condizioni di risoluzione
- •Comportamento post-iterazione
- •Comportamento del corpo del ciclo
- •Invarianti di ciclo in generale
Il framework supporta la descrizione della semantica dei loop di semplici aggiornamenti delle variabili per elaborare la logica condizionale. Anche se questo tipo di tecnicismo potrebbe non sembrare molto chiaro all'inizio, garantisce che tutte le possibilità di esecuzione siano coperte.
Prova di costruzione e automazione
Una volta stabilite le specifiche, l'utente deve dimostrare che le condizioni di verifica possono confermare le specifiche indicate. Il framework offre un'automazione massiccia per elaborare modelli tipici di prove.
Le tattiche personalizzate servono per gestire:
- •Salva le modifiche nelle variabili
- •Ragionamento sul flusso di controllo
- •Altri problemi comuni di verifica
Questi metodi automatizzati aiutano un sacco a ridurre il lavoro manuale necessario per fare le correzioni, mantenendo comunque un livello di verifica super preciso.
Il processo di verifica di solito inizia con lo svelare le astrazioni corrispondenti, dato che queste prove sono direttamente collegate alle proprietà definite dall'utente. Applica il framework per automatizzare un sacco di condizioni di verifica con tattiche di pulizia generiche usate per gestire dettagli tecnici come operazioni di archiviazione delle variabili e transizioni di stato.
Funzionalità avanzate e sviluppi futuri
Il framework è uno strumento complesso che trasforma qualsiasi programma Yul in una serie di istruzioni su ciò che il programma dovrebbe fare e dimostra che il codice soddisfa le aspettative. I programmi vengono inizialmente tradotti in programmi con prove di coerenza in una rappresentazione astratta, fornendo punti di partenza semplificati per ulteriori prove di specificazione.
I modelli nel ragionamento del programma Yul, come le operazioni su un archivio di variabili, sono gestiti da procedure di automazione personalizzate.
Ulteriore sviluppo
Gli sviluppi futuri includono un sacco di miglioramenti importanti:
- •Il modello hash affidabile avrà una semantica di funzionamento crittografico corretta
- •La modellizzazione delle chiamate incrociate ti aiuterà a capire meglio i complessi schemi di interazione
- •L'accuratezza semantica verrà controllata tramite la modellazione del gas, tenendo conto del costo di esecuzione.
- •Seguire le ultime modifiche ai piani di aggiornamento di Ethereum per renderlo compatibile con come funziona ora la rete
- •Migliorare l'usabilità aiuterà gli utenti a usare il programma ogni giorno in modo più efficiente e intuitivo
Si può fare di più per estrarre i client Ethereum execution dalle specifiche e creare compilatori Yul to EVM bytecode verificati formalmente.
Integrazione con le librerie matematiche
Il framework si basa su un sacco di librerie matematiche e informatiche nel suo sistema di prova. Queste librerie offrono concetti formali che spesso si trovano quando si ragiona sui programmi, semplificando un sacco il lavoro necessario per fare prove complesse.
Le tattiche personalizzate si basano su un solido ambiente di metaprogrammazione senza compromettere la verifica. La natura componibile dell'automazione, ancorata ai modelli di utilizzo osservati, è ciò che garantisce il continuo miglioramento dell'usabilità nel tempo.
L'architettura per codificare Yul direttamente nell'ambiente di prova rende l'interfaccia trasparente e naturale per gli sviluppatori che conoscono bene il linguaggio e offre funzionalità mai viste prima nella verifica automatizzata per garantire che il codice sia corretto.
