
bithoven v0.1.0
Bithoven è un linguaggio per smart contract progettato per comporre strumenti potenti e sicuri su Bitcoin. Parser LR(1) con analisi statica per garantire la sicurezza a tempo di compilazione. Articolo di verifica formale: https://arxiv.org/abs/2601.01436
Bithoven 🎼
Sicurezza formale per smart contract Bitcoin espressivi
Bithoven è un linguaggio imperativo di alto livello per gli smart contract Bitcoin. Compila in Bitcoin Script nativo per output legacy (P2SH), segwit (P2WSH) e taproot (P2TR). Si scrivono contratti leggibili con if/else, input witness nominati e tipizzati, e primitive integrate per timelock e firme, invece di destreggiarsi manualmente con uno stack.
Ciò che distingue Bithoven è l'analisi dietro la sintassi. Prima di emettere un singolo opcode, il compilatore rifiuta qualsiasi contratto che potrebbe raggiungere uno stato indefinito, violare una regola di codifica del consenso, consumare un elemento witness in modo diverso da esattamente una volta e nell'ordine dello stack, lasciare un percorso senza un return esplicito, o consentire a un percorso di avere successo senza una firma valida. Rifiuta inoltre qualsiasi contratto di cui può dimostrare che nessun witness potrebbe mai riscattare.
⚡ Caratteristiche principali
- Sintassi imperativa:
if/else,verifyereturninvece del destreggiarsi mentale con lo stack. - Input witness tipizzati: ogni percorso di spesa dichiara i propri elementi witness per nome e tipo (
number,bool,string,signature). - Necessità della firma su ogni percorso: un analizzatore sensibile al percorso dimostra che nessun percorso di spesa può avere successo senza una firma valida, qualunque forma assuma il controllo.
- Tipi rigorosi e letterali verificati dal consenso: nessuna aritmetica su stringhe o sui risultati di
checksig; numeri, stringhe di byte, locktime e chiavi pubbliche sono verificati per intervallo e codifica in fase di compilazione. - Consumo lineare del witness: ogni elemento dichiarato viene consumato esattamente una volta, nell'ordine dello stack, su ogni percorso.
- Compilazione mirata: un'unica sorgente compila per
legacy,segwitotaproot; il multisig diventaOP_CHECKMULTISIGoOP_CHECKSIGADDa seconda di ciò che richiede il target. - Specificato formalmente, testato contro Bitcoin Core: la solidità dei tipi e un teorema di raffinamento legano la sorgente allo script emesso, e il compilatore è testato in modo differenziale contro
libbitcoinconsensus. - Basso overhead: sulle policy Miniscript standard, gli script emessi rientrano in una mediana di un byte rispetto a
rust-miniscript.
🆕 Novità in v0.1.0
v0.1.0 è una revisione importante dell'analizzatore e del back end, che accompagna il paper.
- Necessità della firma sensibile al percorso. Nella 0.0.x, una dichiarazione doveva solo contenere un elemento
signature, e solo la forma letterale!checksig(..)veniva segnalata. La v0.1.0 decide, per ogni percorso, se può avere successo mentre ognichecksigfallisce. Riscritture che la 0.0.x compilava in script spendibili da chiunque, comechecksig(..) == false,checksig(..) || flago unif checksig(..)invertito, ora vengono rifiutate.!!checksig(..), che la 0.0.x rifiutava erroneamente, ora viene compilato. - Rilevamento dei contratti morti. Un contratto in cui ogni percorso è dimostrabilmente insoddisfacibile viene rifiutato con
DeadPathinvece di compilare in un output non spendibile. - Correttezza formale imposta. Ogni
ifnecessita di unelse, esiste esattamente una dichiarazione di stack per ogni percorso di spesa, e i percorsi che si dividono a un ramo devono concordare sugli elementi witness consumati prima di esso. - Liveness per percorso. Il consumo del witness è tracciato per percorso di spesa, quindi due rami possono riutilizzare un nome come
sig; la 0.0.x lo rifiutava conVariableConsumed. - Tipi e letterali più rigorosi. Gli operandi di
verify,returneifdevono esserebool; le stringhe di byte sono limitate al limite di push di 520 byte; i letterali delle chiavi devono usare la codifica del target. - Correzioni al back end. L'uguaglianza su aritmetica compila in
OP_NUMEQUAL, così una somma in overflow non può più confrontarsi uguale byte per byte, e i letterali di stringhe di byte lunghe che potevano mandare in crash il compilatore 0.0.x ora vengono compilati. - Valutazione riproducibile. La validazione differenziale contro Bitcoin Core, l'analisi delle mutazioni, il benchmark della tassonomia BSHunter e un corpus di falsi positivi sono inclusi nel repository (vedi
tests/README.md).
Stai eseguendo l'aggiornamento da 0.0.x? I contratti che si basavano sulle regole più permissive potrebbero non compilare più. Assegna a ogni
ifunelse(NoReturn), scrivi esattamente una dichiarazione per ogni percorso di spesa (DeclarationPathMismatch) e usa chiavi x-only da 32 byte sottotaprooto chiavi compresse da 33 byte sottolegacy/segwit(MalformedPubkey).
🚀 Avvio rapido
- Bithoven Web IDE, vedi: https://bithoven-lang.github.io/bithoven/ide/
- Documentazione di Bithoven, vedi: https://bithoven-lang.github.io/bithoven/docs/
Installazione
# For CLI user
cargo install bithoven
# For rust user
cargo add bithoven
# For js user
npm install bithoven
Scrivere il tuo primo contratto
I contratti Bithoven sono definiti con l'estensione .bithoven. Di seguito è riportata un'implementazione di un Hashed Time-Locked Contract (HTLC) standard, che dimostra come Bithoven semplifichi i percorsi di spesa condizionale.
htlc.bithoven
pragma bithoven version 0.0.1;
pragma bithoven target segwit;
/*
* Stack input declarations: one per spending path, in the order the
* paths' returns appear below. Each lists its items in the order the path
* consumes them, so the first item (here the branch condition) is the top
* of the witness stack.
*/
(condition: bool, sig_alice: signature)
(condition: bool, preimage: string, sig_bob: signature)
{
// If 'condition' is true, we enter the Refund Path (Alice)
if condition {
// Enforce relative timelock of 1000 blocks
older 1000;
// If timelock is satisfied, Alice can spend with her signature
return checksig(sig_alice, "0245a6b3f8eeab8e88501a9a25391318dce9bf35e24c377ee82799543606bf5212");
} else {
// Redeem Path (Bob)
// Bob must reveal the secret preimage that hashes to the expected value
verify sha256(sha256(preimage)) == "53de742e2e323e3290234052a702458589c30d2c813bf9f866bef1b651c4e45f";
// If hash matches, Bob can spend with his signature
return checksig(sig_bob, "0345a6b3f8eeab8e88501a9a25391318dce9bf35e24c377ee82799543606bf5212");
}
}
🛠 Compilazione
Una volta compilato, Bithoven traduce la logica imperativa di alto livello nei corrispondenti opcode di Bitcoin Script, gestendo automaticamente il flusso di controllo e la gestione dello stack.
Comando:
bithoven compile htlc.bithoven --format asm
Senza --format, la CLI scrive l'ASM, l'esadecimale e i byte in htlc.bithoven.json; --format hex e --format json stampano invece su stdout.
Script Bitcoin generato (ASM, formattato per leggibilità):
OP_IF
<0xe803> OP_CHECKSEQUENCEVERIFY OP_DROP
<pubkey_alice> OP_CHECKSIG
OP_ELSE
OP_HASH256 OP_TOALTSTACK <hash_digest> OP_FROMALTSTACK OP_SWAP OP_EQUALVERIFY
<pubkey_bob> OP_CHECKSIG
OP_ENDIF
🛡️ Cosa rifiuta il compilatore
Ogni controllo viene eseguito in fase di compilazione, e ogni rifiuto è accompagnato da una diagnostica che punta alla riga incriminata. Questo contratto sembra protetto da una firma, ma il suo unico percorso ha successo esattamente quando il controllo della firma fallisce:
pragma bithoven version 0.0.1;
pragma bithoven target segwit;
(sig_alice: signature)
{
return checksig(sig_alice, "0245a6b3f8eeab8e88501a9a25391318dce9bf35e24c377ee82799543606bf5212") == false;
}