TmVsbGEgY29uZnVzaW9uZSBkZWkgdmFyaSBwcm90b2NvbGxpIFJDLTIwLCBxdWFsIMOoIGlsIGZ1dHVybyBkaSBCaXRjb2luIChCVEMpPw==

<p><img src="https://gimg2.gateimg.com/image/b16955a5-527d-4c86-ae1d-88dec47ecc25202506181721458302863811.png" alt="">
</p><h2 id="h2-Aggiornamento20pi20recente20del202025682089"><a name="Aggiornamento più recente del 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aggiornamento più recente del 2025</h2><p>Entro il 2025, il campo RC-20 si è sviluppato notevolmente, con RoboCalls (RC20) che diventano un attore importante nell’ecosistema dei token. I dati di mercato mostrano che, oltre alle criptovalute consolidate, il protocollo RC-20 ha ricevuto anche molta attenzione.</p>
<p>Le criptovalute popolari che stanno attualmente mostrando una crescita significativa includono:</p>
<table>
<thead>
<tr>
<th>criptovaluta</th>
<th>tasso di crescita</th>
</tr>
</thead>
<tbody>
<tr>
<td>Axelar</td>
<td>58,15%</td>
</tr>
<tr>
<td><a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a></td>
<td>18,72%</td>
</tr>
<tr>
<td>Ethereum (ETH)</td>
<td>8,21%</td>
</tr>
<tr>
<td>Bitcoin (BTC)</td>
<td>1,89%</td>
</tr>
<tr>
<td><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a></td>
<td>1,77%</td>
</tr>
</tbody>
</table>
<p>RoboCalls ha stabilito una crescente presenza nella comunità e ha canali di supporto dedicati. Il token sta guadagnando trazione tra i trader che stanno gradualmente diversificando i loro investimenti tradizionali in BRC-20.</p>
<p>L’analisi di più piattaforme mostra che i token RC20 sono ora integrati nei portafogli di criptovalute mainstream insieme ad asset consolidati come BTC, ETH e SOL, indicando che il mercato è maturato rispetto al primo boom degli RC-20.</p>
<p>Gate (Gate) continua a monitorare questi sviluppi, prestando particolare attenzione al potenziale di integrazione dei RoboCalls nelle applicazioni decentralizzate, poiché l’ecosistema XRC-20 sta espandendo la sua utilità oltre la speculazione.</p>
<h2 id="h2-Una20variet20di20protocolli20RC2020mescolati20insieme20qual2020il20futuro20di20Bitcoin153788"><a name="Una varietà di protocolli RC-20 mescolati insieme, qual è il futuro di Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Una varietà di protocolli RC-20 mescolati insieme, qual è il futuro di Bitcoin?</h2><h2 id="h2-TLDR550838"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Il concetto di BRC-20, costantemente esaltato dal mercato, ha portato a una proliferazione di vari protocolli di token RC-20 che spuntano come funghi dopo la pioggia;</p>
<p>Attualmente, vari concetti RC-20 emessi sul mercato si basano tutti sul protocollo Ordinals.</p>
<p>L’emergere di vari token basati su XRC-20 ha innescato una serie di impatti sulla rete Bitcoin;</p>
<p>XRC-20 potrebbe diventare un componente importante della futura economia decentralizzata.</p>
<h2 id="h2-Introduzione709867"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Con la crescente popolarità dei token BRC-20, il valore dei token sta aumentando.</p>
<p>Il primo token BRC-20 ORDI ha avuto un prezzo iniziale di $0,1, ha raggiunto un picco di $68,77 e ha raggiunto una capitalizzazione di mercato massima di $1,35 miliardi. Di conseguenza, l’istituzione dello standard BRC-20 ha riacceso l’interesse per Bitcoin.</p>
<p>L’entusiasmo continuo del concetto BRC-20 sul mercato ha portato all’emergere di vari protocolli di token RC-20 come funghi dopo la pioggia.</p>
<h2 id="h2-X2020RC2021567"><a name="X + RC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>X + RC-20</h2><p>Attualmente, vari concetti RC-20 emessi sul mercato si basano sul protocollo Ordinals.</p>
<p>Ci sono ARC20,<br>IERC20 (Ethereum), CBRC20, SOL20, DRC20, ASC20, ORC20, LRC20, TRC20, SRC20 (supporta solo gli indirizzi <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> che iniziano con 1), Ethrunes (rune di Ethereum) e molti altri nuovi protocolli RC20 basati su Ordinals provenienti da varie catene pubbliche, e ne verranno aggiunti continuamente, troppi per essere contati completamente.
</p><p>Con così tanti protocolli BRC20 basati su Ordinals, non è necessario comprenderli tutti o afferrare pienamente ciascuno di essi. È sufficiente comprendere l’essenza sottostante di questi protocolli per avere una comprensione fondamentale dell’insieme.</p>
<p>In definitiva, sono fondamentalmente gli stessi dei BRC20, che emettono anche token, NFT, nomi di dominio, biglietti, francobolli, ecc. trasferendo 1 Satoshi e scrivendo informazioni identificative nelle note di trasferimento (l’unità più piccola di Bitcoin è 1 Satoshi; altri protocolli RC20 emettono anche token utilizzando l’unità più piccola dei token della catena L1), e le informazioni identificative in ogni unità sono riconosciute da un indicizzatore.</p>
<p>La differenza tra loro e BRC20 è che sono state apportate alcune modifiche basate sui fondamenti, come semplificare le informazioni e ridurre i dati in byte, variare le lunghezze dei nomi dei token, migliorare l’efficienza degli indexer e aumentare la sicurezza del protocollo, ecc. Proprio come alcune catene pubbliche migliorano il TPS, alcune danno priorità alla sicurezza, e altre cercano di aumentare la flessibilità della codifica dei contratti, ecc.</p>
<h2 id="h2-Protocollo20RC2020popolare6756"><a name="Protocollo RC-20 popolare" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Protocollo RC-20 popolare</h2><h3 id="h3-ORC20545995"><a name="ORC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ORC-20</h3><p>L’ORC-20, come il BRC-20, è uno standard di token che funziona sulla blockchain di Bitcoin. È codificato come un file JSON (JavaScript Object Notation) e registrato con un numero di serie su Satoshi.<br>L’ORC-20 è una versione aggiornata dello standard BRC-20, che affronta alcune delle sue carenze.
</p><p>ORC-20 è stato lanciato da OrcDAO, con l’obiettivo di migliorare la funzionalità dei token Ordinals sulla rete Bitcoin per migliorare l’attuale BRC-20. ORC20 rimuove le restrizioni di denominazione sui token e aggiunge funzionalità aggiornabili, consentendo alle parti del progetto di abilitare ulteriori capacità basate sui token. Inoltre, introduce funzionalità avanzate come la definizione delle royalty e la creazione di whitelist.</p>
<p>L’ORC-20 è retrocompatibile con il BRC-20 e migliora l’adattabilità, la scalabilità e la sicurezza, eliminando la possibilità di doppia spesa. Tuttavia, a causa dell’infrastruttura poco sviluppata dell’ORC20 e dell’effetto ricchezza ancora concentrato sul BRC20, l’ORC20 riceve attualmente molta attenzione limitata.</p>
<h3 id="h3-SRC2091977"><a name="SRC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SRC-20</h3><p>A differenza di BRC-20 e ORC-20 che si basano sulla teoria degli Ordinals, SRC-20 adotta <a href="/zh/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a><br>I timbri vengono utilizzati per incidere testo. I Bitcoin Stamps sono simili ai token semi-fungibili ERC-1155 o ai collezionabili digitali e sono direttamente memorizzati nel Bitcoin UTXO - il registro dei Bitcoin non utilizzati durante una transazione tra due indirizzi, piuttosto che essere memorizzati nei dati del testimone come gli Ordinals.
</p><p>Tuttavia, poiché attualmente non esiste un mercato che supporti SRC20, l’unico metodo di trading è tramite trading over-the-counter, e SRC-20 richiede ancora un supporto significativo. Pertanto, questo progetto attrae principalmente investitori al dettaglio che hanno perso l’opportunità dei token BRC-20 Ordi. A causa del limitato afflusso di capitali speculativi, è comunque necessario osservare con cautela.</p>
<p>Sebbene Binance abbia condotto un’indagine su SRC-20, non ha adottato misure finanziarie sostanziali come ha fatto OKX per BRC-20, e attualmente il mercato tende ancora verso BRC-20.</p>
<h3 id="h3-ARC20183201"><a name="ARC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ARC-20</h3><p>Il protocollo Atomicals è costruito sulla rete Bitcoin. Attraverso il protocollo Atomicals sulla rete Bitcoin, è possibile creare (mint), trasferire e aggiornare oggetti digitali (NFT, come NFT digitali nativi, NFT di gioco, identità digitali, nomi di dominio, reti sociali, ecc.), oltre a creare token fungibili.</p>
<p>Questo significa che attraverso il protocollo Atomicalas, possono essere generati NFT non fungibili sulla rete Bitcoin, e possono essere creati anche token fungibili. Questo token fungibile è il token ARC20.</p>
<p>Il protocollo Atomicals sfrutta appieno le caratteristiche del Bitcoin UTXO, utilizzando i satoshi come unità di conto. Ciò significa che qualsiasi elemento digitale creato sulla base del protocollo Atomicals può tracciare la propria storia delle transazioni, rendendolo veramente verificabile. Gli utenti, i portafogli, le parti del progetto e qualsiasi individuo o istituzione possono verificare la storia delle transazioni attraverso semplici regole per determinare se è autentica e affidabile.</p>
<p>Il protocollo Atomicals è relativamente compatibile con le caratteristiche di BTC e il suo metodo di implementazione è relativamente semplice, il che ha attirato l’attenzione delle persone e ha guadagnato favori nella comunità tecnologica. In breve, il percorso tecnico è relativamente semplice e si allinea bene con le caratteristiche e la situazione attuale di Bitcoin.</p>
<h3 id="h3-IERC20608020"><a name="IERC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IERC-20</h3><p>IERC-20 è un protocollo di token basato su Ethereum, responsabile della standardizzazione dei token di iscrizione. Fornisce un ecosistema di token a basso costo per gli utenti di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> senza influenzare l’infrastruttura esistente, consentendo a chiunque di distribuire, coniare e scambiare token su IERC-20. EthinscXYZ introduce un modello di Mining equo di PoW nel protocollo IERC-20 e collabora attivamente con altri progetti per lanciare iscrizioni.</p>
<p>Il primo token nell’ecosistema IERC20 è Ethi, conosciuto anche come la moneta principale di IERC20. Tuttavia, è già stato completamente coniato.</p>
<p>L’unicità di iERC20 risiede non solo nello sviluppo di Swap, ma anche nella sua integrazione della funzionalità cross-chain EVM, costruendo un ponte tra le iscrizioni di Ethereum e il tradizionale Layer2. Introduce più monete mainstream e stablecoin, espandendo il TVL dell’ecosistema delle iscrizioni e fornendo maggiori possibilità per l’intero sistema.</p>
<p>Inoltre, il team del progetto prevede di introdurre un modello di mining equo di PoW nel protocollo IERC20 e di collaborare attivamente con altri progetti per lanciare iscrizioni. Simile al metodo di mining del protocollo Atom, questo ha portato a un nuovo modello per l’ecosistema Ethereum Launchpad in una certa misura.</p>
<h2 id="h2-Quale20sar20il20futuro20del20Bitcoin151703"><a name="Quale sarà il futuro del Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quale sarà il futuro del Bitcoin?</h2><p>L’ascesa di vari tipi di token XRC-20 ha innescato una serie di impatti sulla rete Bitcoin.</p>
<p>Principalmente manifestato in tre aspetti:</p>
<p>In primo luogo, porta a congestione nella rete Bitcoin perché i dati delle transazioni di questi token devono essere memorizzati su tutti i blocchi di Bitcoin, aumentando il carico delle transazioni;</p>
<p>In secondo luogo, i token XRC-20 hanno danneggiato la reputazione di Bitcoin, costringendo Bitcoin a affrontare notizie negative non correlate ai progetti XRC-20.</p>
<p>Infine, i token XRC-20 mancano di utilizzo pratico e, rispetto ad altri standard di token, non hanno compatibilità con i contratti intelligenti, il che limita le loro applicazioni pratiche.</p>
<p>Sebbene i token XRC-20 abbiano registrato una rapida crescita in un breve periodo, non è ancora chiaro se siano solo una moda passeggera o veri e propri cambiamenti di gioco.</p>
<p>Sebbene l’XRC-20 affronti numerose sfide, l’aumento del traffico e dell’attenzione che porta potrebbe attrarre più investitori che in precedenza non si erano avventurati nello spazio delle criptovalute ad unirsi alla comunità di Bitcoin. Questo potrebbe anche avere un impatto positivo sul futuro di Bitcoin.</p>
<h2 id="h2-Conclusione738290"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Lo standard di token XRC-20 ha le caratteristiche necessarie per promuovere ecosistemi emergenti e, in futuro, potrebbe consentire a questi token sperimentali di interoperare con altri sistemi blockchain e asset digitali, fornendo garanzie per le piattaforme DeFi o essendo integrati nelle dApp.</p>
<p>Oggi, XRC-20 esplora una possibilità nel campo emergente del <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> e potrebbe diventare un componente importante dell’economia decentralizzata in futuro. Gate continuerà a monitorare da vicino lo sviluppo dei token XRC-20 nei prossimi mesi.</p>
<div class="blog-details-info"><br>  <div>Autore: Team del Blog<br>  <div class="info-tips"><em>Questo contenuto non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br>  <div></div>Si prega di notare che Gate potrebbe limitare o vietare tutti o parte dei servizi da aree ristrette. Si prega di leggere il contratto utente per ulteriori informazioni, link:<a href="https://www.gate.io/zh/user-agreement。" data-index="4"></a><a href="https://www.gate.io/en/user-agreement" data-index="5">https://www.gate.io/it/user-agreement</a>.<br><p></p><br></em></div></div></div>