Z2F0ZUxpdmUgdGF2b2xvIHJvdG9uZG86IHF1YWxpIG9wcG9ydHVuaXTDoCBkaSByaWNjaGV6emEgaW1wZXJkaWJpbGkgc29ubyBjb250ZW51dGUgbmVsbCdlY29zaXN0ZW1hIEJpdGNvaW4gaW4gdmlzdGEgZGVsIG1lcmNhdG8gcmlhbHppc3RhPw==

<p><img src="https://gimg2.gateimg.com/image/article/1698897223yzrecap.jpeg" alt=""><br><strong>Tema della tavola rotonda:</strong> Il mercato toro è in arrivo, quali sono le opportunità di ricchezza imperdibili nell’ecosistema del Bitcoin?</p>
<p><strong>Ospite di questo episodio:</strong> 洪蜀宁（ <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Researcher）、Haotian（Blockchain Researcher）、Ben（Discoco Labs 创始人）、Leo Deng（LK Venture VP）、bitrabbit（ <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> Consiglio BNS dao）</p>
<p><strong>Guarda la ripresa completa della trasmissione in diretta</strong>: <a href="https://www.gate.io/live/video/4f88759b894a6a34321069848b5a99ad" target="_blank">https://www.gate.io/live/video/4f88759b894a6a34321069848b5a99ad</a></p>
<h2 id="h2-Quali20sono20i20significati20dello20sviluppo20dellecosistema20Bitcoin20attualmente383871"><a name="Quali sono i significati dello sviluppo dell’ecosistema Bitcoin attualmente?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono i significati dello sviluppo dell’ecosistema <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> attualmente?</h2><h4 id="h4-u6D2Au8700u5B81803224"><a name="洪蜀宁：" class="reference-link"></a><span class="header-link octicon octicon-link"></span>洪蜀宁：</h4><p>Nel 2009, Satoshi Nakamoto ha fatto una dichiarazione che prevedeva il futuro del Bitcoin. Ha detto: ‘Tra 20 anni, il Bitcoin sarà o ampiamente utilizzato per transazioni di grandi importi o non sarà usato da nessuno e non avrà valore’. Fino ad oggi, il futuro del Bitcoin rimane incerto per tutti i detentori. Come fare in modo che il Bitcoin venga utilizzato da più persone per un gran numero di transazioni? Finora, non abbiamo ancora trovato una soluzione efficace. In realtà, l’uso del Bitcoin non è così diffuso e i blocchi non sono ancora pieni. Secondo me, se il Bitcoin vuole diventare una valuta di successo come il dollaro, deve sviluppare numerose applicazioni basate su se stesso.</p>
<p>Fin dai primi giorni di nascita di Bitcoin, le persone hanno continuato a esplorare come creare più applicazioni per esso. Dopo l’evento di hard fork del 2017, l’intera comunità BTC è diventata più conservatrice, preoccupata che si ripetano problemi causati da un fork. Di conseguenza, l’innovazione tecnologica è diventata più conservativa. Ciò ha portato Bitcoin a essere considerato esclusivamente come oro digitale o uno strumento di conservazione del valore, senza ulteriori esplorazioni delle applicazioni.</p>
<p>Tuttavia, con l’avvento della tecnologia taproot, risolve il problema della programmabilità di Bitcoin, rendendo possibile l’implementazione dei contratti intelligenti sulla blockchain di Bitcoin. Solo quando queste tecnologie applicative diventano mature e le persone di tutto il mondo iniziano a utilizzare applicazioni basate su Bitcoin, ci saranno numerose transazioni applicative nell’ecosistema di Bitcoin, portando entrate considerevoli alla blockchain di Bitcoin e ai minatori.</p>
<h4 id="h4-Haotian803841"><a name="Haotian:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Haotian:</h4><p>Attualmente, alcune persone stanno cercando di trasferire le dinamiche dell’ecosistema di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> all’ecosistema di Bitcoin, sfruttando il potente consenso di rete di Bitcoin per ridefinire una nuova narrazione. Questo approccio viene descritto come reinventare la ruota, cercando di trovare nuovi segreti di ricchezza. Tale approccio ha suscitato l’opposizione di alcune persone, le quali ritengono che questo tipo di adattamento non sia adatto all’ecosistema di Bitcoin. A breve termine, è difficile evitare tale approccio. A lungo termine, questa esplorazione offre nuove idee e direzioni per lo sviluppo futuro dell’ecosistema di Bitcoin.</p>
<p>Con la scomparsa dell’effetto di dimezzamento del prezzo del Bitcoin, come faranno i minatori a sbarcare il lunario? Se l’ecosistema del Bitcoin non ha una quantità significativa di transazioni e utenti, i minatori non saranno in grado di sostenere la vasta rete solo con le commissioni. Pertanto, non si può contare solo su un aumento del prezzo. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> Sostenere lo sviluppo dell’ecosistema. Un piano praticabile è quello di sviluppare seriamente l’ecosistema della rete Bitcoin, in modo che le commissioni diventino il reddito principale dei minatori futuri. Sono ottimista sul futuro della rete Lightning, perché è ampiamente integrata nelle applicazioni pratiche ed è adatta per l’uso in specifici contesti di consumo.</p>
<p>Attualmente, la narrazione che circonda Ethereum è principalmente legata alle sue proprietà finanziarie, come l’emissione di monete e il mining, che sono essenzialmente di natura ludica e mancano di applicazioni pratiche. D’altra parte, la rete Lightning di Bitcoin mira a spendere le monete in mano. L’ecosistema Bitcoin comprende anche progetti eccellenti come Nostr, che si trovano ancora in una fase embrionale. In generale, è necessario mantenere un’opinione obiettiva e paziente sullo sviluppo dell’ecosistema Bitcoin, guardando con fiducia al futuro.</p>
<h4 id="h4-Ben770250"><a name="Ben:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ben:</h4><p>Dalla nascita di Bitcoin fino ad oggi, abbiamo visto una varietà di alt-coin emergere. Ma sono tutti falliti. Dobbiamo considerare Bitcoin come infrastruttura di base. Abbiamo bisogno che Bitcoin diventi un ecosistema applicativo, in quanto Bitcoin stesso è il consenso più forte al mondo. Non abbiamo bisogno che nessuno lo cambi, ma di basarci su di esso per creare un sistema veramente decentralizzato, sia che si tratti di protocolli di token o di ecosistemi applicativi.</p>
<p>Di recente, un progetto molto popolare, Babylon, menziona anche un punto importante nel suo protocollo, cioè il suo nucleo è basato sull’uso di POW per potenziare la sicurezza di POS. Poiché il POW è in grado di resistere meglio agli attacchi a lungo raggio rispetto al POS, sta aumentando la sicurezza della catena COSMOS con il potenziamento di Bitcoin. Dal fatto che questo progetto stia ricevendo così tanto sostegno, si può vedere che le persone concordano con questa logica, cioè il consenso basato sul POW di Bitcoin è riconosciuto come più forte di qualsiasi di queste catene POS.</p>
<p>Il Bitcoin stesso è in costante evoluzione, come ha appena sottolineato un compagno di classe menzionando l’aggiornamento Taproot e PSBT, negli ultimi anni sono emerse nuove idee nei documenti o proposte. Anche il BTC stesso sta evolvendo, ma manca ancora un’esplosione di applicazioni. Penso che a partire da quest’anno e probabilmente per molto tempo nel futuro, ci sarà un’esplosione dell’ecosistema Bitcoin.</p>
<h4 id="h4-Leo20Deng854402"><a name="Leo Deng:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Leo Deng:</h4><p>Bitcoin ha ottenuto il consenso globale come “oro digitale” e un sistema di scambio di denaro elettronico peer-to-peer. Tuttavia, dallo sviluppo attuale di Bitcoin, non ha completamente soddisfatto questi due attributi. In primo luogo, alcuni problemi chiave relativi a Bitcoin, come la privacy del portafoglio, i costi di transazione più bassi e la sicurezza, richiedono miglioramenti e sviluppi continui.</p>
<p>In secondo luogo, il white paper di Bitcoin ha presentato un concetto importante, ovvero un sistema di transazioni di contanti elettronici peer-to-peer, che offre una rete di valore decentralizzata e fornisce una nuova soluzione per i pagamenti elettronici. Tuttavia, nelle applicazioni pratiche, le prestazioni e l’efficienza di questo sistema devono ancora essere migliorate. Ad esempio, i costi generati durante il processo di transazione e vari problemi di attrito richiedono ulteriori ottimizzazioni.</p>
<p>Inoltre, non possiamo limitare Bitcoin solo alle due proprietà sopra menzionate, ma dobbiamo esplorarne un’applicazione più ampia. Attualmente, il vantaggio di Bitcoin non è solo nell’ETF spot e nella narrazione dimezzata, ma anche nella prosperità del suo ecosistema e nello sviluppo su larga scala. Per lo sviluppo dell’ecosistema di Bitcoin, dobbiamo anche considerare le esigenze oggettive dell’intero ambiente nei confronti di esso.</p>
<h4 id="h4-Bitrabbit326762"><a name="Bitrabbit:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitrabbit:</h4><p>Di recente, l’interesse per Ordinals ha suscitato l’immaginazione di molte persone che confrontano la realizzazione, da parte di Bitcoin, di funzionalità di contratti intelligenti turing-completi, come Ethereum. Tuttavia, a causa delle limitazioni del meccanismo di consenso di Bitcoin, è difficile realizzare questa idea in modo perfetto attraverso biforcazioni e simili.</p>
<p>La più grande comunità di consenso attuale nella comunità Bitcoin è l’ecosistema delle applicazioni di pagamento basate principalmente sulla rete Lightning. Molti suggerimenti BIP sono dedicati all’ottimizzazione della rete Lightning per rendere Bitcoin un sistema di moneta elettronica più ideale. In questo contesto, Stacks, con un’idea di progettazione unica, può implementare applicazioni DeFi per Bitcoin in modo decentralizzato al secondo livello, senza modificare il consenso di Bitcoin, il che è di grande importanza.</p>
<p>Attualmente, molte funzionalità di trading non possono essere realizzate su Bitcoin, ma solo su scambi centralizzati. Tuttavia, negli ultimi anni abbiamo assistito a diversi casi di chiusura degli scambi, come il crollo di FTX. Pertanto, la necessità di transazioni on-chain e applicazioni on-chain sta diventando sempre più urgente. Anche la domanda di trading on-chain, prestiti per prodotti derivati e altro continua a crescere.</p>
<h2 id="h2-Quali20protocolli20ecologici20Bitcoin20sono20attualmente20i20pi20promettenti20Perch664342"><a name="Quali protocolli ecologici Bitcoin sono attualmente i più promettenti? Perché?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali protocolli ecologici Bitcoin sono attualmente i più promettenti? Perché?</h2><h4 id="h4-Haotian415259"><a name="Haotian:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Haotian:</h4><p>Taproot Assets è un protocollo per l’emissione di token sulla rete Bitcoin, che realizza l’era multi-asset di Bitcoin e offre agli sviluppatori più spazio per agire. Sfruttando Taproot Assets, possiamo creare varie applicazioni economiche basate su token, espandendo così le funzionalità della rete Bitcoin.</p>
<p>Tuttavia, a causa del modello UTXO su cui si basa la rete Bitcoin, è difficile implementare scenari di utilizzo complessi, quindi diventa particolarmente importante l’integrazione con la rete Lightning. La rete Lightning, come strato di calcolo e applicazione, può espandere le funzionalità della rete Bitcoin, ridurre le commissioni e fornire un meccanismo di regolamento efficiente. Creando scenari di consumo basati su stablecoin sulla rete Lightning, possiamo creare una stablecoin che può circolare senza intoppi sulla rete Lightning ed essere ampiamente accettata e utilizzata. Questa idea porta un enorme impulso all’espansione e allo sviluppo dell’intero ecosistema Bitcoin.</p>
<p>Tuttavia, Taproot Assets non è impeccabile. Come ogni tecnologia emergente, presenta alcune sfide e problemi. Uno di questi è un attacco round-robin alternativo alla Lightning Network. Sebbene questo attacco possa avere un impatto sullo sviluppo futuro di Taproot Assets, non è facile portare a termine un attacco del genere in questo momento. Inoltre, i nodi della Lightning Network sono tutti affidabili e ogni nodo stabilisce più connessioni e aderisce a un determinato codice di condotta per garantire la sicurezza e l’affidabilità degli asset Taproot.</p>
<p>Inoltre, Taproot Assets coinvolge progetti, distribuzione di token e nodi intermedi nell’intera catena, ed è una rete di emissione e circolazione di asset matura e affidabile. Rispetto alla modalità di gioco BRC20 basata su Ordinals, Taproot Assets è più scientifico e meno incline a problemi formali. Tuttavia, è ancora necessario tempo per svilupparsi e maturare in questo campo.</p>
<h4 id="h4-Ben271751"><a name="Ben:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ben:</h4><p>Nella differenza tra le due reti blockchain di Bitcoin ed Ethereum, Bitcoin è più simile a un sistema che sottrae continuamente, mentre Ethereum è un sistema che aggiunge continuamente. Taproot Assets è un protocollo di risorse che si conforma alla filosofia di progettazione di Bitcoin e consente di costruire calcoli e memorizzazioni verificati dal proprio client sulla rete Bitcoin, al fine di realizzare funzionalità più avanzate in modo simile a Layer2. Il cuore di Taproot Assets è la disposizione delle transazioni, che organizzano le nostre risorse fuori dalla catena utilizzando un albero di Merkel nidificato e quindi interagiscono sulla catena utilizzando un formato di transazione Virtual PSDT simile al formato di transazione PBST nativo di BTC. Una volta che il canale di micro-pagamento di Taproot Assets è attivo, potrà essere utilizzato dall’infrastruttura della rete Lightning di ligtling labs. Ciò significa anche che potrà integrare tutte le proposte di ottimizzazione precedenti sulla rete Lightning. Tuttavia, a differenza di questo, RGB è nato in un’epoca precedente e non è allineato con alcuni dei nuovi progressi di BTC, ad esempio, l’unico significato dell’aggiornamento Taproot per RGB è quello di inserire i dati di impegno in TapLeaf.</p>
<h4 id="h4-Hong20Shuning924885"><a name="Hong Shuning:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hong Shuning:</h4><p>Prima di tutto, la sicurezza è la priorità assoluta dell’applicazione Bitcoin, altrimenti è impossibile parlare di altri aspetti dell’applicazione. Per risolvere questo problema, il protocollo RGB utilizza il calcolo off-chain, che gli consente di ottenere una completa decentralizzazione garantendo al contempo un elevato livello di sicurezza. Perché tutti i calcoli degli smart contract vengono eseguiti peer-to-peer e non richiedono l’aiuto di terze parti.</p>
<p>In secondo luogo, il protocollo RGB ha anche caratteristiche di scalabilità e completezza di Turing. Può funzionare sulla rete Lightning, è scalabile e il suo design è stato realizzato per realizzare smart contract Turing completi. La sua macchina virtuale R6VM è equivalente all’EVM e supera l’EVM in alcuni aspetti, consentendo di realizzare tutte le applicazioni attualmente presenti su Ethereum.</p>
<p>Inoltre, il protocollo RGB ha il vantaggio di un’alta privacy. Solo le parti coinvolte nella transazione e coloro che partecipano alla transazione sono a conoscenza dei contenuti del contratto e delle informazioni sulla transazione, mentre gli altri non hanno alcuna conoscenza dell’esistenza di tale transazione. Ciò elimina molti problemi attuali dell’ambiente Web3, come MEV e attacchi hacker.</p>
<p>Tuttavia, il protocollo RGB ha anche alcune evidenti carenze. In primo luogo, lo sviluppo è molto lento. Nonostante il protocollo RGB sia stato sviluppato 5 anni fa, è stato lanciato solo quest’anno in una versione stabile. Ciò è principalmente dovuto al fatto che ci sono pochi sviluppatori coinvolti e che la soglia di sviluppo è troppo alta. Sebbene RGB abbia creato un grande quadro tecnologico, ci vuole ancora tempo per realizzarlo completamente. Attualmente, il numero di sviluppatori è molto basso, il che ha causato un progresso lento nello sviluppo. Ma non preoccuparti, perché la versione stabile è stata già rilasciata e la nostra applicazione può provare a svilupparsi su di essa.</p>
<p>Il secondo problema è che attualmente l’integrazione tra RGB e Lightning Network non è perfetta e ci sono ancora molti problemi di ingegneria da risolvere. Ciò comporta vari bug durante l’utilizzo, anche se questi problemi non compromettono la sicurezza del protocollo stesso, potrebbero influire negativamente sull’esperienza dell’utente.</p>
<p>Il terzo problema è che attualmente RGB è ancora un giocattolo tecnologico relativamente piccolo, senza considerare l’istituzione di un sistema commerciale e un meccanismo di incentivi economici per la commercializzazione su larga scala in futuro. Questo è uno dei motivi per cui il protocollo RGB non ha ancora ricevuto molta attenzione e applicazioni.</p>
<h4 id="h4-Leo20Deng58732"><a name="Leo Deng:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Leo Deng:</h4><p>In precedenza, il signor Hong ha menzionato che il protocollo RGB si concentra sui calcoli fuori dalla catena, che è coerente con il concetto di design della rete Lightning. La tecnologia degli smart contract è un altro punto forte di RGB, in quanto può espandere gli scenari di utilizzo dell’ecosistema Bitcoin. Di recente, abbiamo anche osservato alcune applicazioni del protocollo RGB.</p>
<p>Ci sono notizie secondo cui, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> Il nuovo CEO Paolo Ardoino ha affermato in un’intervista che il protocollo RGB potrebbe essere la migliore scelta per emettere stablecoin su Bitcoin e potrebbe persino essere un successore legittimo. Dal punto di vista di Tether, gli smart contract e gli elementi del client di RGB integrano molte opportunità per l’ecosistema futuro di Bitcoin.</p>
<p>Lo sviluppo di un ecosistema dipende non solo dalla passione e dall’orientamento degli sviluppatori, ma anche dalla collaborazione tra il capitale e le grandi istituzioni. Possiamo vedere che il supporto e l’approvazione di progetti come <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> sono molto importanti per il protocollo RGB. Inoltre, il protocollo RGB stesso sta evolvendo costantemente, con sempre più sviluppatori che partecipano allo sviluppo di applicazioni all’interno di questo ecosistema. Considerando tutti questi fattori, personalmente penso che il potenziale di RGB sia ancora maggiore.</p>
<h4 id="h4-Bitrabbit36296"><a name="Bitrabbit:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitrabbit:</h4><p>Qui vi presenterò Stacks. In primo luogo, parliamo del background: il team principale di <a href="/price/stacks-stx" target="_blank" class="blog_inner_link">Stacks</a> proviene dal Dipartimento di Informatica di Princeton, il fondatore ha lavorato sullo sviluppo di Bitcoin per dieci anni e ha iniziato con il sistema di nomi di dominio BNS su Bitcoin. BNS è il sistema di nomi di dominio blockchain più antico dell’industria crittografica. Successivamente, attraverso il finanziamento regolamentato della SEC, è stato creato un meccanismo di consenso basato sulla trasmissione di prova PoX, ovvero l’attuale Stacks. All’interno della trasmissione di prova di Stacks ci sono due ruoli: i minatori di Stacks e i depositanti di STX. Più Bitcoin inviano i minatori di Stacks, maggiore è la probabilità di ricevere la ricompensa a blocchi STX.</p>
<p>Il prossimo punto chiave è l’aggiornamento nakamoto del primo trimestre dell’anno prossimo, che è attualmente la direzione principale del lavoro di Stack. L’aggiornamento nakamoto include tre aspetti. Il primo aspetto è sBTC, che basandosi su PoX e firma a soglia, realizza l’ancoraggio bidirezionale di Bitcoin a Stack in modo decentralizzato. Il secondo aspetto è l’aggiornamento della sicurezza, che include anche due parti: una parte elimina le biforcazioni arbitrariamente, stabilisce che 150 blocchi di Stack non possono essere biforcati, ereditando maggiormente la sicurezza di Bitcoin. L’altra parte è che gli stakeholder di stx parteciperanno anche alla produzione dei blocchi di Stack, migliorando così l’assunzione di sicurezza. Il terzo aspetto è l’aggiornamento delle prestazioni. Attualmente, Stack produce blocchi agganciati a Bitcoin molto lentamente. Dopo l’aggiornamento nakamoto, il meccanismo di prova del tempo consente di aumentare la velocità di produzione dei blocchi di Stack a 5 secondi senza sacrificare la sicurezza, ma a scapito delle commissioni. Le commissioni di transazione nei blocchi di 5 secondi saranno notevolmente più alte rispetto a quelle nei blocchi ancorati.</p>
<p>Le tre principali aree di aggiornamento di sicurezza, prestazioni e prestazioni di sBTC sono in arrivo.</p>
<p>Questo sistema di interconnessione senza fiducia di Stacks sembra essere un’ottima soluzione tecnica, ma ha anche dei difetti. Il difetto principale è che sacrifica la liquidità per garantire la sicurezza. La capacità di sBTC è limitata dalla capitalizzazione di Stacks, quindi ci vorrà del tempo per svilupparsi fino a una certa scala.</p>
<h2 id="h2-Come20consideri20lo20sviluppo20futuro20dellecosistema20Bitcoin210406"><a name="Come consideri lo sviluppo futuro dell’ecosistema Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come consideri lo sviluppo futuro dell’ecosistema Bitcoin?</h2><h4 id="h4-u6D2Au8700u5B81884186"><a name="洪蜀宁:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>洪蜀宁:</h4><p>A breve termine, penso che ci siano due vantaggi principali nel protocollo RGB. Prima di tutto, supporta BTC nativo, il che significa che non abbiamo bisogno di fare alcuna operazione cross-chain o peg e possiamo ottenere asset nativi di BTC direttamente dalla blockchain di Bitcoin. In secondo luogo, supporta l’USDT di Tether, che è sufficiente per costruire vari casi d’uso sul protocollo RGB.<br>A mio parere, il prestito decentralizzato sarà la prima esplosione del protocollo RGB. Prendendo in prestito e prestando BTC e USDT, possiamo ottenere maggiore flessibilità e libertà nel modo in cui utilizziamo i nostri fondi. Allo stesso tempo, i prestiti decentralizzati diventeranno un mercato molto ampio, superando tutte le piattaforme di prestito centralizzate esistenti.</p>
<p>Inoltre, poiché il protocollo RGB ha una scalabilità infinita, i giochi blockchain possono essere facilmente realizzati su di esso. Le aziende di gioco possono implementare direttamente logiche di gioco complesse sulla blockchain, che rappresenterà una direzione molto creativa. Una volta che i giochi blockchain diventano popolari sulla catena di Bitcoin, anche il traffico del mondo tradizionale inizierà a partecipare. In sintesi, il protocollo RGB ha un enorme potenziale per creare un ecosistema delle app più aperto, trasparente e decentralizzato.</p>
<h4 id="h4-Haotian20208"><a name="Haotian:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Haotian:</h4><p>Secondo me, la maggiore aspettativa per l’ecosistema di Bitcoin è il successivo impatto della rete Lightning. Dopo il lancio di Taproot Assets sulla rete Lightning, alcuni progetti come Tether sono stati ridisegnati nell’ecosistema di Bitcoin per emettere USDT, che poi viene fatto circolare sulla rete Lightning. Questa è una tendenza entusiasmante che segna la vera applicazione delle valute virtuali e degli asset virtuali nei contesti di consumo.</p>
<p>Un altro fenomeno osservato di recente è che l’intera rete Ethereum sta lavorando su alcune cose a livello di astrazione, come l’astrazione degli account, al fine di ridurre la soglia di utilizzo degli smart contract per gli utenti, attirare più utenti e raggiungere l’adozione su larga scala. Tuttavia, al momento sembra che Ethereum si trovi in ​​una situazione in cui, nonostante lo sviluppo, la soglia per gli utenti rimane ancora alta.</p>
<p>In seguito, ci saranno progetti che emetteranno asset sulla rete Lightning e li spingeranno verso il livello delle applicazioni? Ad esempio, emettere un gioco sulla rete Lightning che utilizza un modello a doppia valuta, in cui una delle valute potrebbe essere emessa sulla rete Lightning. Lo scopo di ciò è incoraggiare le persone a spendere queste valute. Possiamo trovare una società o un team di giochi che faccia questo? Questo è qualcosa su cui dobbiamo aspettare e prestare attenzione. Se questo potenziale viene sfruttato appieno, soprattutto in combinazione con Ethereum, penso che ci saranno prospettive di sviluppo ancora migliori.</p>
<h4 id="h4-Ben346085"><a name="Ben:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ben:</h4><p>Innanzitutto, dal punto di vista dei giganti, perché Tether si interessa alla stablecoin sulla rete Lightning? Nell’economia dei token ci sono due livelli, uno è il denaro per i regolamenti e l’altro è il denaro per i pagamenti. Per i giganti, non vogliono solo guadagnare sulle commissioni di Bitcoin, ma anche sui pagamenti delle stablecoin.</p>
<p>L’anno scorso, Teda ha contattato Lighting Labs con l’obiettivo di collaborare per rendere disponibile USDT sull’infrastruttura di Lighting Labs. Tuttavia, questo piano è fallito perché Lighting Labs controlla il client Lightning Network LND, che detiene una quota di mercato superiore al 90%. Poiché Lighting Labs non poteva fornire a Teda la quota desiderata, ha deciso di collaborare con RGB per emettere USDT e guadagnare denaro dai pagamenti.</p>
<p>Quando c’è una stablecoin nell’ecosistema, ha una base di liquidità. Rispetto al passato in cui c’era solo Bitcoin, ora ci sarà molta più immaginazione. Su questa base, gli sviluppatori possono creare molte infrastrutture come Dex e prestiti garantiti. In particolare, per gli sviluppatori di applicazioni Crypto tradizionali, ora possono fare DeFi.</p>
<p>Quindi, su quale scenario essere ottimisti? Credo che l’ecosistema dei pagamenti sarà la prima scena vivace, ma questa ecologia potrebbe essere guidata dai grandi giganti. E se vuoi vedere l’esplosione di altre scene ecologiche, allora la DeFi sarà una buona scelta. Se vogliamo vedere applicazioni più ricche, dobbiamo aspettare lo sviluppo complessivo.</p>
<h4 id="h4-Leo20Deng181194"><a name="Leo Deng:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Leo Deng:</h4><p>Secondo me, la scena dei pagamenti con stablecoin basati sulla rete secondaria di Bitcoin ha un enorme potenziale. La rete secondaria ha notevoli vantaggi in termini di velocità delle transazioni e user experience, e può migliorare notevolmente l’usabilità dei pagamenti crittografici C2C, B2C e persino B2B. Inoltre, la stabilità della rete di Bitcoin negli ultimi dieci anni rende possibile i pagamenti con stablecoin basati sulla rete secondaria di Bitcoin e può risolvere i problemi attuali della scena dei pagamenti con stablecoin.</p>
<p>Inoltre, l’interoperabilità cross-chain è un’altra importante direzione per l’ecosistema di Bitcoin. L’introduzione dei contratti intelligenti può notevolmente migliorare l’interoperabilità di Bitcoin con altre reti di blockchain pubbliche non EVM. Questa esigenza di condivisione di asset e dati cross-chain, verifica dell’identità, ecc. porterà enormi opportunità all’interoperabilità cross-chain. Ad esempio, il progetto Harry Pod e la soluzione cross-chain investita da Connet si concentrano sull’interazione cross-chain tra l’ecosistema di Bitcoin e altri ecosistemi, inclusi gli scambi swap e MP.</p>
<p>Con l’aumento della diffusione di Bitcoin e l’espansione degli asset, gli effetti di overflow dell’ecosistema di Bitcoin diventeranno sempre più evidenti. Questo overflow può fornire opportunità di connessione tra Bitcoin e altre reti non legate a Bitcoin. Sono convinto che in futuro l’ecosistema di Bitcoin giocherà un ruolo di rete ancora più importante, collegandosi ad altri ecosistemi, compresi l’ecosistema di Ethereum e altri ecosistemi non basati su EVM.</p>
<h4 id="h4-Bitrabbit240430"><a name="Bitrabbit:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitrabbit:</h4><p>Come ho descritto in precedenza, il progetto Stacks, mediante un approccio che non modifica il consenso di Bitcoin, trasforma le sidechain con budget di sicurezza indipendente in un secondo strato di contratti intelligenti Bitcoin con un ambiente di esecuzione completo, aprendo così a Bitcoin un’ampia programmabilità.</p>
<p>Con questa infrastruttura, i detentori di Bitcoin possono effettuare transazioni decentralizzate sulla rete Bitcoin, simili alle operazioni DeFi su Ethereum. Attualmente, Stacks ha raggiunto un livello di perfezione abbastanza elevato in questo ambito.</p>
<p>Durante l’evento hackathon di Londra della scorsa settimana, hanno partecipato 250 sviluppatori e presentato domande per vari progetti. Tra questi, ci sono quattro progetti rappresentativi, che rappresentano rispettivamente quattro direzioni: dex, derivati, prestiti e stabilità. Questi includono Dex (attualmente la più grande piattaforma di scambio decentralizzata su Alex), il protocollo di stablecoin decentralizzato (simile a MakerDao) Arkadiko e due protocolli che coinvolgono rispettivamente i derivati Velar e il prestito di Bitcoin Zest.</p>
<p>*GateLive è la principale piattaforma di live streaming per criptovalute, con analisti di mercato professionisti che forniscono in tempo reale le ultime notizie di mercato, analisi di mercato professionale e conoscenze del settore delle tendenze. Guarda subito GateLive per vedere il live streaming e goderti più programmi interessanti. <a href="https://www.gate.io/zh/live" target="_blank">https://www.gate.io/it/live</a></p>
<div>Autore:<strong>Squadra GateLive</strong>, Gate.io<div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista dell'autore e non costituisce alcun consiglio di trading.</em><div><em></em>Il contenuto di questo articolo è originale, il copyright è di proprietà Gate.io, se hai bisogno di ristampare, indica l'autore e la fonte, altrimenti sarai ritenuto legalmente responsabile.<p></p><br></div></div></div>