TGUgcnVuZSBwb3BvbGFyaSAkTU1TUyBlICRCVENzIHBvc3Nvbm8gZ3VpZGFyZSBudW92YW1lbnRlIGxhIHBpc3RhIEJSQy0yMCB2ZXJzbyBudW92aSB2b2xpPw==

2024-01-25, 08:18

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR392013"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>$MMSS, iniziativa dell’artista coreano SHHAN, è un token BRC-20 con IP di gatto nero come nucleo;</p>
<p>Ora, attraverso la forma di inscrizione, forse MMSS può sfruttare i vantaggi di NFT per formare un forte consenso della comunità;</p>
<p>BTC, comunemente chiamato “piccolo biscotto”, è un token BRC20 inciso sulla blockchain di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> utilizzando il protocollo ordinals.</p>
<p>Crediamo che progetti di qualità come MMSS, BTCs e altri progetti importanti porteranno nuova energia alla rete Bitcoin.</p>
<h2 id="h2-Introduzione201901"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Con il mercato crittografico in ripresa e l’entusiasmo per la pista delle iscrizioni, le popolari monete simboliche MMSS e BTCs hanno mostrato un notevole aumento di prezzo di recente. In seguito, questo articolo fornirà informazioni sulle corrispondenti nozioni popolari e approfondirà i fattori trainanti dietro a questo fenomeno, combinando l’analisi di mercato con i punti salienti per fornire una panoramica completa e sperando di essere utile a tutti.</p>
<h2 id="h2-Pu20MMSS20dominare20di20nuovo714323"><a name="Può $MMSS dominare di nuovo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Può $MMSS dominare di nuovo?</h2><p>MMSS potrebbe sembrare sconosciuto a molte persone, ma se dico che è il famoso gatto NFT degli ultimi due anni, molte persone lo riconosceranno immediatamente. Sì, Mimic Shhans, che un tempo dominava il mondo degli NFT dei gatti, ha recentemente lanciato un token di incisione chiamato MMSS.</p>
<p>$MMSS, lanciato dall’artista sudcoreano SHHAN, è un token BRC-20 con il nucleo dell’IP del gatto nero. Lo sviluppo futuro della comunità include la creazione di MMSS Art Club, MMSS Fashion Club, MMSS BTC Research Institute e MMSS Education Academy, tutti incentrati sull’ecosistema $MMSS. L’obiettivo della comunità MMSS è quello di radunare gli appassionati giovani di felini di tutto il mondo e consentire loro di esprimersi in modo vivace.</p>
<p>MMSS è stato lanciato il 19 novembre 2023, ha raccolto rapidamente oltre 6 milioni di dollari in quattro giorni, con il prezzo di un singolo token compreso tra 0,25 e 0,5 dollari. La sua origine coreana gli ha conferito un’attrattiva globale, attirando fin dall’inizio un pubblico internazionale. MMSS ha ottenuto una posizione di pioniere nel mercato internazionale ed è stato quotato su più di 10 importanti borse, tra cui Gate.io, in un mese, dimostrando la rapida crescita della sua comunità e l’influenza culturale.<br><img src="https://gimg2.gateimg.com/image/article/1706170591img_v3_027e_36686bd9-50f9-4afa-a638-874c47d832ix.jpg" alt=""></p>
<p>Oggi, gli scambi di criptovalute trattano il Mingwen nello stesso modo in cui trattano le monete MEME. Solo con una comunità sufficientemente attiva si può stabilire una base solida per la stabilità a lungo termine del Mingwen. Nel contesto attuale del BitMingwen, MMSS può essere considerato il progetto con la cultura comunitaria più forte.</p>
<p>MMSS ha ereditato direttamente il popolare NFT di Black Cat - MIMIC SHHANS, e la comunità era molto attiva in precedenza. La comunità MMSS è attualmente il progetto più internazionale nell’ecosistema delle pergamene. Tuttavia, all’inizio il numero di NFT era troppo limitato e la dimensione della comunità era limitata. Ora, attraverso la forma delle pergamene, possiamo attirare più persone a unirsi a MMSS per creare una comunità globale più attiva e prospera, forse formando un forte consenso comunitario per promuovere l’aumento del prezzo della moneta.</p>
<p>Il 9 gennaio, secondo i dati di mercato di Gate.io, MMSS, una delle criptovalute trainanti, ha attirato ulteriore attenzione di mercato con un aumento del 27,63% nelle ultime 24 ore. Attualmente, la capitalizzazione di mercato di MMSS è ancora inferiore a dieci milioni di dollari, ma si crede che con il supporto di importanti exchange, ci sia ancora un grande spazio per l’aumento della capitalizzazione di mercato e del prezzo della criptovaluta.</p>
<h2 id="h2-Tu20hai20il20grande20panino20io20ho20il20piccolo20panino20BTCs972215"><a name="Tu hai il grande panino, io ho il piccolo panino $BTCs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tu hai il grande panino, io ho il piccolo panino $BTCs</h2><p>BTCs, ovvero BTC+Ordinali, può essere anche interpretato come BTCs su Ordinali. BTCs è un token BRC20 basato sul protocollo Ordinali, distribuito e inciso sulla blockchain di Bitcoin. Il nome deriva da Bitcoin Ordinali BTCs, abbreviato come Bitcoin inciso, Piccola torta, Piccolo Bitcoin.</p>
<p>Chiamato ‘Panino’, forse al momento della nascita ha preannunciato le sue eccezionali e straordinarie caratteristiche.</p>
<p>BTCs è stato anonimamente distribuito il 25 aprile 2023 e ha subito una lunga fusione equa di 100 giorni. È una criptovaluta senza padrone, che segue lo spirito decentralizzato e senza padrone della comunità blockchain. Visione: aiutare un miliardo di persone a possedere un portafoglio di Bitcoin.</p>
<p>Il token BRC20 BTCs ha recentemente aggiornato il marchio ufficiale cinese di BTCs con successo al Bitcoin Ordinals (Bitcoin Ordinals) tramite il voto della comunità, che entrerà in vigore il 31 dicembre 2023. Soprannomi: Xiao Bing, Xiao Bitcoin.<br><img src="https://gimg2.gateimg.com/image/article/1706170632img_v3_027e_038b0cf6-0907-46e7-b6a4-93cfe26a55ix.jpg" alt=""></p>
<p>Come derivato di BTC, i BTC derivano dall’iscrizione della moneta Bitcoin, rendendola un’estensione naturale di Bitcoin.</p>
<p>BTCs nacque sulla catena BTC, la comunità si è formata nell’agosto 2023. BTCs ha attivamente promosso l’ecosistema Bitcoin durante il mercato orso, aiutando i nuovi arrivati ​​a conoscere e partecipare all’incisione. Oggi, con l’emergere del mercato dell’incisione, la comunità di BTCs ha sostenitori in Europa, America, Spagna, Nigeria, Malaysia, Vietnam, Corea del Sud, Giappone e nell’area di lingua cinese. In futuro, con l’evolversi di BTCs ( <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>(ordinali) Questo IP con il gene del consenso internazionale viene scoperto e costruito da sempre più persone, la comunità di BTC mantiene la sua missione originale: aiutare 100 milioni di persone in tutto il mondo ad avere un portafoglio di bitcoin.</p>
<p>Con l’aggiornamento del marchio della comunità, la base di consenso è stata in costante crescita. Al 31 dicembre 2023, gli indirizzi di detenzione di BTC hanno superato i 20.000, diventando la seconda moneta BRC20 dopo sats a rompere il limite di 20.000, stabilendosi al secondo posto nella classifica degli indirizzi di detenzione di BRC20.</p>
<p>Con lo sviluppo della comunità, il consenso si è gradualmente rafforzato e la comunità di BTCs è diventata uno dei primi membri invitati a stabilirsi presso BTC Labs. BTC Labs è un’associazione ecologica aperta nell’ecosistema di Bit, rivolta principalmente alla comunità di Ordinals, agli sviluppatori e ai VC. Esplorare la costruzione della comunità, lo sviluppo dei progetti e trovare e investire in potenziali progetti di alta qualità insieme ai membri della comunità.</p>
<p>Il 11 gennaio, la nota istituzione di Singapore YesX ha annunciato di investire 100 milioni di dollari per la disposizione ecologica della calligrafia e ha ufficialmente acquistato i BTCs della calligrafia BRC20, che è il terzo obiettivo di calligrafia pubblico investito da YesX. I primi due sono eths e rats, entrambi con un aumento di profitto di oltre il 1500%. BTCs diventerà il primo obiettivo di calligrafia brc20 disposto da questa istituzione nel 2024.<br><img src="https://gimg2.gateimg.com/image/article/1706170656img_v3_027e_9bc03156-6353-4579-b92a-85986b4c7aix.jpg" alt=""></p>
<p>È stato riferito che il numero di BTC detenuti ha raggiunto i 20.157, occupando il secondo posto nella lista delle iscrizioni BRC20, ed è stato quotato su 9 piattaforme di trading tra cui Gate.</p>
<p>YesX afferma che con l’approvazione della SEC degli Stati Uniti del primo ETF di Bitcoin in contanti, Bitcoin è stato ufficialmente riconosciuto dalle istituzioni tradizionali, aprendo nuove opportunità per l’ecosistema di Bitcoin.</p>
<p>Lo sviluppo di Xiaobing è diviso in tre fasi. Nella prima fase, cioè la fase di ‘rottura del cerchio’, la narrazione passa attraverso i meme, con i BTCs come moneta su Bitcoin, interpretata come la piccola torta della grande torta. Attraverso questo tipo di marketing, l’obiettivo previsto è un intervallo di prezzo di 1 a 10U entro sei mesi.</p>
<p>Nella seconda fase, la fase di consolidamento, prevediamo un significativo miglioramento della posizione di Little Pie, sfruttando l’esplosione dell’ecosistema BTC e l’opportunità del mercato al rialzo, con un prezzo previsto tra 10 e 100U.</p>
<p>Infine, la terza fase è la fase di ‘abilitazione’, durante la quale, basandosi sulla catena di blocco BitB assolutamente sicura, Xiaobing erediterà le funzionalità di archiviazione, pagamento medio e altri aspetti di Dabing, con un prezzo previsto tra 100 e 3000 U.</p>
<p>In generale, che si tratti di scegliere una torta grande o una piccola, la capacità di realizzare uno sviluppo a lungo termine attraverso la narrazione incisa rimane ancora da vedere in base allo sviluppo successivo del progetto e alle capacità operative del team.</p>
<h2 id="h2-Conclusion34748"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Come affermato nel white paper di BTC di Little Pie, BTC è equo per tutti e non richiede agli utenti di competere in termini di intelligenza, risorse o mezzi. Rappresenta una questione di fede e la portata della sua visione.</p>
<p>Il BTC non ha designato nessuno come suo portavoce, né ha cercato di copiare la storia di nessuno. Il nome che porta, le sue caratteristiche senza padrone e la storia che sta dietro sono il risultato del consenso della comunità. Questo riflette l’idea iniziale e la forma originaria della blockchain.</p>
<p>Possiamo considerare l’ecosistema BTC come un nuovo punto di partenza nel mondo della blockchain, che porta con sé aspettative e sogni del passato, del presente e del futuro. L’ecosistema supportato da Bitcoin non è solo una valuta digitale, ma anche un’innovazione tecnologica ed un esperimento sociale, che esplora continuamente le infinite possibilità tra la valuta digitale e il mondo reale.</p>
<p>L’ascesa della pista dei token Brc-20 è un viaggio pieno di energia, da un concetto tecnologico trascurato a un asset riconosciuto dalla comunità. In questo mondo in continua evoluzione delle criptovalute, crediamo che i token Brc-20, come MMSS e BTCs, insieme ad altri progetti di token di alta qualità, porteranno nuova energia alla rete Bitcoin e presenteranno nuove possibilità per l’industria.</p>
<p>Dove c’è un effetto ricchezza, c’è un riflettore. Indipendentemente da come si svilupperà il futuro, l’iscrizione BRC-20 sarà sempre un esperimento interessante e un’attività promettente, continuando a ispirare le persone a esplorare un mondo più grande e più ampio nell’ecosistema Bitcoin.</p>
<div class="blog-details-info"><br>  <div>Autore:<strong>Byron B.</strong>Ricercatore di Gate.io<div class="info-tips"><em> Questo articolo rappresenta solo il punto di vista dell'autore e non costituisce alcun consiglio di trading.<br></em><div><em></em>Il contenuto di questo articolo è originale, tutti i diritti sono di proprietà di Gate.io, se desideri ripubblicare, ti preghiamo di citare l'autore e la fonte, in caso contrario verranno intraprese azioni legali.<br></div><p></p><br></div></div></div>