UmluYXNjaW1lbnRvIGRlbGxhIGNyaXB0b3ZhbHV0YSBtZW1lIGRpIEJpdGNvaW46IGNvbWUgZ2xpIGludmVzdGl0b3JpIGlzdGl0dXppb25hbGkgZGVsbCdBc2lhIHBvdHJlYmJlcm8gZ3VpZGFyZSBsYSBjcmVzY2l0YSBkaSBSdW5lcw==

2024-06-13, 01:41

<p><img src="https://gimg2.gateimg.com/image/article/1718242605sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR712965"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Molte istituzioni con sede in Asia sono disposte a investire nel protocollo Runes.</p>
<p>Newman Group, Magic Eden e OKX sono esempi di organizzazioni che hanno già investito nel protocollo Runes.</p>
<p>Il token Dog Go to the Moon è una delle principali meme coin sul protocollo Runes.</p>
<h2 id="h2-Introduzione496510"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il lancio di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Le rune del 20 aprile, il giorno in cui è avvenuto l’havling di BTC, hanno suscitato molta speranza nel settore delle criptovalute. Molte persone credono che le iscrizioni runiche e ordinali abbiano portato vitalità alla blockchain, poiché i due protocolli potrebbero contribuire a sostenere la rete attraverso le commissioni di transazione. Quell’assunzione sembrava essere stata <a href="https://www.gate.io/learn/articles/introducing-runes-the-next-step-in-bitcoins-fungible-token-protocols/1327" target="_blank">convalidato dall’aumento delle commissioni di transazione Runes</a> nelle settimane successive. Tuttavia, la situazione è cambiata quando il livello delle commissioni di transazione generate da Runes è diminuito nelle ultime settimane. In questo articolo, discutiamo come gli investitori istituzionali dell’Asia potrebbero stimolare la crescita di Runes.</p>
<h2 id="h2-Il20difficile20inizio20di20Bitcoin20Runes209282"><a name="Il difficile inizio di Bitcoin Runes" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il difficile inizio di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Runes</h2><p>La storia del protocollo bitcoin Runes, un contratto intelligente per la creazione di meme coin, ha inviato segnali contrastanti tra la comunità crittografica. Dopo il lancio del protocollo il 20 aprile c’è stato un fiorire di attività che ha portato a un’impennata astronomica delle commissioni di transazione bitcoin. Pochi giorni dopo il lancio sono state aggiunte più di cento sigle sulla rete bitcoin <a href="https://www.gate.io/learn/articles/what-is-the-bitcoin-rune-protocol/2621" target="_blank">utilizzando il protocollo Runes</a>. In particolare, entro tre giorni dal lancio delle Rune, ci sono stati più di 1 milione di transazioni.</p>
<p>Purtroppo, durante la settimana successiva il volume delle transazioni sul protocollo è diminuito di oltre il 90%, portando alcuni analisti a mettere in dubbio la sostenibilità del protocollo Runes. Tuttavia, alla fine di maggio c’è stata una nuova attività sul protocollo. Proprio come prima, la frenesia sul protocollo Runes si è nuovamente placata. Da allora, il livello di attività sul protocollo è rimasto molto basso. Il grafico seguente mostra la crescita del volume di Runes dal lancio del protocollo.<br><img src="https://gimg2.gateimg.com/image/article/171824270511.jpeg" alt=""><br>Volumi di transazione Runes - <a href="https://www.aliteq.com/wp-content/uploads/2024/06/2Runes.png" rel="nofollow noopener noreferrer" target="_blank">GenniData</a></p>
<p>Come <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> Come indicato, il volume di scambi è stato elevato durante aprile e la prima settimana di maggio. Successivamente, è diminuito drasticamente. Tuttavia, la rinascita di bitcoin Runes potrebbe portare a un aumento delle meme coin. Inoltre, l’espansione dell’ecosistema di gioco di bitcoin potrebbe scatenare un aumento della domanda per il protocollo e i relativi volumi di scambio.</p>
<h2 id="h2-Lottimismo20istituzionale20alimenta20il20protocollo20Runes684814"><a name="L’ottimismo istituzionale alimenta il protocollo Runes" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’ottimismo istituzionale alimenta il protocollo Runes</h2><p>Anche se <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> intorno al protocollo Runes sembrava essersi raffreddato all’interno del mercato occidentale degli asset digitali, gli investitori istituzionali asiatici stanno dando vita al progetto poiché sono pronti a versare più risorse finanziarie di prima. Una ragione del loro interesse nel protocollo è costituita dalle sue forti caratteristiche come i suoi modelli di transazione ottimizzati, le caratteristiche di sicurezza e la robusta scalabilità.</p>
<p>Alcuni investitori istituzionali asiatici come il Newman Group, Magic Eden e OKX sono disposti ad adottare il protocollo Runes per guidare le loro diverse funzionalità e soddisfare le loro esigenze uniche. Ad esempio, il Newman Group, attraverso le sue società di portafoglio, Liquidium e Xverse, sta lavorando al lancio dei suoi prodotti sul protocollo Runes.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/understanding-bitcoin-s-layer-1-runes-protocol/1963" target="_blank">Comprensione del protocollo Rune di livello 1 di Bitcoin</a></p>
<p>D’altra parte, Magic Eden, un marketplace NFT cross-chain, ha integrato la sua piattaforma con il protocollo Runes. Allo stesso modo, OKX, una delle principali exchange centralizzate in Asia, si è integrata con esso, consentendo di offrire scambi senza commissioni. Un altro motivo di entusiasmo da parte delle istituzioni per Runes è la capacità del protocollo di interagire in modo fluido con altri progetti crittografici. Incidentalmente, questo è uno dei motivi per cui OKX ha scelto di integrare il protocollo della moneta meme di bitcoin.</p>
<p>Come dichiarato da Aliteq, <a href="https://www.aliteq.com/can-institutional-investors-in-asia-help-bitcoin-runes-revive/" rel="nofollow noopener noreferrer" target="_blank">Adrian Lai, fondatore di Newman Group, ha detto</a>, “Crediamo che alla fine le Rune potrebbero essere <a href="https://www.gate.io/learn/articles/what-are-bitcoin-runes-and-how-do-they-differ-from-brc-20-tokens/2782" target="_blank">maggiore di BRC-20</a>, soprattutto se si considerano i vantaggi per gli investitori istituzionali. I vantaggi tecnici di Runes e il potenziale di transazione efficiente tra catene potrebbero renderlo la scelta preferita per le istituzioni che desiderano accedere a DeFi su Bitcoin.</p>
<p>Paige Xu, un investitore presso OKX, crede anche nel potenziale a lungo termine del protocollo Runes. <a href="https://www.aliteq.com/can-institutional-investors-in-asia-help-bitcoin-runes-revive/" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>, Runes ha le cose giuste, inclusa l’efficienza e un’impronta di blockchain sottile (energeticamente efficiente, contribuisce alla riduzione delle emissioni di gas serra), tecnologia che le organizzazioni cercano spesso, aiutando a soddisfare rapidamente una grande domanda.</p>
<p>Tuttavia, Xu pensa che la crescita del protocollo Rune possa richiedere molto più tempo. A tal proposito, ha aggiunto: “L’adozione di tecnologie basate su Bitcoin come questa è ancora piuttosto nuova e dipende molto dal livello di istruzione e integrazione di questi asset nel mondo finanziario più ampio.”</p>
<h2 id="h2-Il20protocollo20Runes20raggiunge20un20tetto20di20220miliardi20di20dollari49852"><a name="Il protocollo Runes raggiunge un tetto di 2 miliardi di dollari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il protocollo Runes raggiunge un tetto di 2 miliardi di dollari</h2><p>Come accennato in precedenza, c’è stata molta attività sul protocollo Runes alcuni giorni fa <a href="https://www.gate.io/learn/articles/navigating-runes-protocol-launch-beyond-the-initial-hype/2850" target="_blank">dopo il suo lancio in aprile</a>. Alla fine di maggio, la capitalizzazione di mercato di Runes aveva raggiunto 1 miliardo di dollari. Tuttavia, a causa dell’interesse sostenuto nei memecoins basati su Bitcoin, la sua valutazione totale ha superato i 2 miliardi di dollari. Poiché l’adozione del protocollo Runes continua a crescere grazie al supporto istituzionale, la capitalizzazione di mercato di Runes potrebbe continuare a crescere.</p>
<p>Fondamentalmente, il team di sviluppo del protocollo Runes è focalizzato sul potenziamento dei vantaggi tecnici di Bitcoin come efficienza ed economicità. Ad esempio, la scalabilità del protocollo Runes è una delle principali attrattive dell’intero sistema. Casey Rodarmor, che è anche il fondatore del <a href="https://www.gate.io/learn/articles/what-are-bitcoin-ordinals/508" target="_blank">Protocollo degli ordinali</a>, ritiene che il protocollo Runes sia uno standard di contratto intelligente sicuro, scalabile ed efficiente per token fungibili di bitcoin.</p>
<h2 id="h2-Analisi20delle20caratteristiche20delle20Rune312612"><a name="Analisi delle caratteristiche delle Rune" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi delle caratteristiche delle Rune</h2><p>Come detto, molti investitori preferiscono il protocollo Runes rispetto al protocollo Ordinals per diversi motivi, tra cui la facilità d’uso. Inoltre, diversi analisti hanno commentato i vantaggi tecnici di bitcoin Runes come scalabilità ed efficienza. Ad esempio, <a href="https://decrypt.co/233430/bitcoin-runes-resurgence-asia-institutional-investors" rel="nofollow noopener noreferrer" target="_blank">Ciara Sun, fondatrice</a> e managing partner di C Squared Ventures, una società di investimenti crittografici focalizzata sull’Asia, ha detto a Decrypt: “Runes è strutturato per potenzialmente soddisfare i rigorosi requisiti degli investitori istituzionali, enfatizzando scalabilità, efficienza e sicurezza.”</p>
<p>Citato dalla stessa fonte, Xu ha detto: ‘Runes ha ciò che serve: efficienza e una traccia di blockchain leggera che le istituzioni cercano tipicamente nella tecnologia, in grado di gestire in modo sicuro una forte domanda’.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/runes-protocol-and-the-open-etching-issuance-mechanism/2610" target="_blank">Protocollo Runes e il meccanismo di emissione “incisione aperta”</a></p>
<h2 id="h2-Aumento20del20prezzo20di20DOG20e20altri20token20Runes327426"><a name="Aumento del prezzo di DOG e altri token Runes" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aumento del prezzo di DOG e altri token Runes</h2><p>Il token Dog Go to the Moon (DOG), lanciato il 20 aprile sul protocollo Runes, ora è classificato al terzo posto nella rete bitcoin e al settimo posto nell’intero mercato dei memecoin. Con una capitalizzazione di mercato di $759,987,083 e un trading a $0.00774, DOG ha guadagnato un 86% nelle ultime 2 settimane e un 189% negli ultimi 30 giorni. Nell’immagine seguente sono mostrati alcuni dei principali token sul protocollo Runes che stanno anche performando bene.<br><img src="https://gimg2.gateimg.com/image/article/171824284412.jpeg" alt=""><br>memecoin su Runes Protocol - <a href="https://s3.magazine.cointelegraph.com/magazine/wp-content/uploads/2024/04/0xNefu.png" rel="nofollow noopener noreferrer" target="_blank">Cointelegraph</a></p>
<p>Come hai notato, RSIC con una capitalizzazione di mercato di oltre 300 milioni di dollari è un’altra delle principali memecoin sul protocollo Runes.</p>
<h2 id="h2-Il20Potenziale20delle20Rune20Oltre20lHype854186"><a name="Il Potenziale delle Rune: Oltre l’Hype" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il Potenziale delle Rune: Oltre l’Hype</h2><p>Le prospettive del protocollo Runes sono ottime considerando che molti investitori hanno molto interesse per esso. Tuttavia, per aumentare la sua adozione, è necessario educare i membri della comunità criptata, inclusi gli sviluppatori e i leader di progetto. La capacità del protocollo Runes di integrare gli asset nel mondo finanziario più ampio è fondamentale per la sua crescita e adozione futura.</p>
<h2 id="h2-Conclusion732715"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>C’è la speranza che il mercato possa assistere a una ripresa delle criptovalute meme di bitcoin a seguito di numerosi investimenti istituzionali asiatici nel protocollo Runes. Ad esempio, Newman Group, Magic Eden e OKX hanno già investito nel progetto. Tali investitori istituzionali sono disposti a investire nel protocollo grazie alle sue eccellenti caratteristiche come l’alta scalabilità, la convenienza economica e l’efficienza.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore di Gate.io<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 ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>