Qml0Vk0gcHXDsiBhcHJpcmUgdW4gbnVvdm8gbW9kZWxsbyBkaSBCaXRjb2luIEwyPw==

2023-10-19, 09:15

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>[TL;DR]:<br>BitVM cerca di implementare il calcolo complesso e il controllo condizionale su <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> reti senza la necessità di modifiche al livello del protocollo Bitcoin.</p>
<p>BitVM può essere considerato come la costruzione di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> L2, che è più adatto per scenari limitati di calcolo della catena pesante e può essere utilizzato per migliorare la affidabilità dei pagamenti delle reti lightning.</p>
<h2 id="h2-Introduzione758946"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Recentemente, il project leader di ZeroSync ha rilasciato un white paper intitolato “BitVM: Calcola qualsiasi cosa su Bitcoin”, cercando di implementare calcoli complessi e controllo condizionale sulle reti Bitcoin senza la necessità di modifiche al livello del protocollo Bitcoin.</p>
<p>Si può dire che BitVM è un altro tentativo di espandere la narrazione di Bitcoin dopo Lightning Network e BRC20, che è rapidamente diventato un argomento caldo di discussione nell’industria crittografica, e alcuni lo chiamano addirittura il concetto L2 di Bitcoin.</p>
<h2 id="h2-Introduzione20a20BitVM507240"><a name="Introduzione a BitVM" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione a BitVM</h2><p>Secondo il white paper, BitVm è un nuovo paradigma di calcolo lanciato di recente che esprime il contratto Bitcoin completo di Turing. Integra generalmente elementi di base come Optimal RollUp, Proof di frode, Taproot Leaf e Bitcoin . La sua implementazione è simile a OP Rollup su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> dove il contratto non effettua calcoli su Bitcoin, ma viene sottoposto a convalida off-chain senza modificare il ruolo del consenso di rete.<br><img src="https://gimg2.gateimg.com/image/article/169770682411561697706589_.pic.jpg" alt=""><br>BitVM White Paper</p>
<p>Il motivo per cui BitVM è accattivante è che si impegna a fornire più possibilità tecnologiche per la scalabilità di Bitcoin senza la necessità di aggiornamenti.</p>
<p>In particolare, il concetto di BitVM può essere inteso come una macchina virtuale Bitcoin, che consente l’espressione di contratti Bitcoin completi di Turing senza modificare le regole di consenso della rete Bitcoin. Può eseguire qualsiasi funzione calcolabile per il calcolo offline senza lasciare tracce sulla catena.</p>
<p>A differenza della <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Virtual Machine (EVM), BitVM non esegue processi computazionali sulla catena, ma la convalida, che è fondamentalmente simile al principio di Optimal Rollup. Anche se la rete Bitcoin stessa non può effettivamente eseguire compiti computazionali e memorizza solo dati, la sua elevata sicurezza può diventare un terzo di fiducia per qualsiasi livello di calcolo completo di Turing.</p>
<p>In parole povere, il protocollo può essere visto come la costruzione di Bitcoin L2, ma c’è ancora molta strada da fare prima di implementare operazioni di contratto intelligente complesse ed efficienti come Ethereum L2.</p>
<h2 id="h2-Vantaggi20e20svantaggi20di20BitVM115593"><a name="Vantaggi e svantaggi di BitVM" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vantaggi e svantaggi di BitVM</h2><p>A questo punto, dobbiamo prima integrare le informazioni di base. Attualmente, ci sono due idee principali nell’industria rispetto all’implementazione di Layer2 con Tecoin:</p>
<p>1) Espandi il modello OP Rollup di Lightning Network, che non è limitato al pagamento e può eseguire qualsiasi operazione contrattuale. BitVM segue questo approccio.</p>
<p>2) Centralizza le firme soglia distribuite come tBTC sulla catena. BEVM è questo approccio.</p>
<p>Rispetto a BEVM, BitVM è ancora nella fase iniziale di convalida concettuale, rendendolo relativamente difficile da capire e da usare. Non è ancora stata proposta una soluzione completa per alcuni dettagli, come il ponte di fiducia della side chain. Inoltre, è leggermente insufficiente nel supportare la cooperazione tra più parti, la facilità di utilizzo e l’universalità.</p>
<p>In generale, ci sono tre critiche della comunità riguardo alle limitazioni di BitVM.</p>
<p>L’oggetto di interazione è limitato a entrambe le parti che si comprendono in anticipo e fanno molto lavoro di preparazione offline e non può supportare la cooperazione multi-party come DeFi.</p>
<p>La modalità con cui entrambe le parti avviano sfide alla rete principale BTC offline sarà più complessa e difficile da gestire rispetto alla rete lightning.</p>
<p>Non è possibile sviluppare una piattaforma universale on-chain Layer2 matura come BEVM in un breve periodo di tempo, figuriamoci Ethereum Layer2.</p>
<p>Ad esempio, lo sviluppatore di Blockchair Nikita Zhavoronkov ha twittato, paragonando BitVM a “eseguire gli scacchi in Minecraft” e affermando che il protocollo BitVM non è sufficiente per essere chiamato Bitcoin EVM.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169770687211571697706601_.pic.jpg" alt=""><br>Tweet che criticano BitVM</p>
<p>Successivamente, lo sviluppatore anonimo Super Testnet ha risposto indirettamente a queste accuse, ritenendo che BitVM stesso fosse focalizzato sulla scalabilità di Bitcoin e sul miglioramento di una delle carenze delle reti lightning: l’affidabilità dei pagamenti, piuttosto che sull’implementazione di smart contract e molte Altcoin.</p>
<p>Molti membri della comunità ritengono anche che BitVM abbia proposto un possibile percorso di scalabilità che non è ancora completo.</p>
<p>Bob Bodily, CEO di BioniqMarket, ha dichiarato che i potenziali casi d’uso che BitVM può facilmente implementare includono parti decentralizzate di varie applicazioni che attualmente si basano su servizi centralizzati, tra cui macchine oracolo DLC, aggregatori di controllo della congestione/coinjoin e quorum di side-chain.</p>
<h2 id="h2-Prospettive20future20per20BitVM375099"><a name="Prospettive future per BitVM" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future per BitVM</h2><p>In sintesi, BitVM è un nuovo concetto intelligente e creativo che attualmente non può realizzare applicazioni contrattuali intelligenti più complesse e sofisticate come L2 di ETH, rendendolo più adatto a scenari limitati di calcolo su catena pesante.</p>
<p>Tuttavia, in ogni caso, fornisce un nuovo tentativo di espandere Bitcoin. Questa innovazione esplora un percorso che abbraccia una gamma più ampia di casi d’uso e combinazioni senza violare il protocollo core di Bitcoin, che in sé incarna uno spirito geek aperto e condiviso.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169770689811581697706611_.pic.jpg" alt=""><br>La soluzione originale per la scalabilità di Bitcoin</p>
<p>Vale la pena considerare che il lancio di BitVM ha nuovamente suscitato discussioni nella comunità crittografica tra il mantenimento del minimalismo e l’espansione dell’evoluzione rispetto a Bitcoin. BitVM sembra aver indicato una soluzione che tiene conto di entrambi, sebbene stretta, ma ha comunque una significato positivo. Come giocherà un ruolo nelle reti Bitcoin in futuro potrebbe essere un focus a lungo termine di attenzione per una comunità.</p>
<p>In realtà, dal primo hard fork di BTC fuori da BCH nel 2017, ci sono stati significativi dubbi sulla scalabilità di Bitcoin nella comunità, ma sembra che tutti siano riluttanti a mantenere l’immagine conservativa di Bitcoin come un token antico. Che sia per mantenere il minimalismo per approfondire la missione di memorizzare e scambiare valute digitali, o per aggiungere più programmabilità per arricchire i casi d’uso dell’ecosistema di Bitcoin, sarà un problema irrisolto per molto tempo.</p>
<p>BitVM ha compiuto un piccolo passo in questo senso, anche se rimangono molte sfide di implementazione. Tuttavia, mentre si garantisce la decentralizzazione di Bitcoin, raggiungere qualche micro innovazione per ridefinire la forma futura di Bitcoin è molto degno di attenzione degli investitori. Se BitVM può diventare un Bitcoin L2 richiede ulteriore verifica nel tempo.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Peter L.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>