S3VubmVuIHBvcHVsYWlyZSBpbnNjcmlwdGllcyAkTU1TUyBlbiAkQlRDcyBkZSBCUkMtMjAgcmFjZWJhYW4gb3BuaWV1dyBkb2VuIG9wc3Rpamdlbj8=

2024-01-25, 08:18

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR778560"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>$MMSS, gelanceerd door de Zuid-Koreaanse kunstenaar SHHAN, is een BRC-20-token met de zwarte katten-IP als kern.</p>
<p>Nu kan MMSS misschien profiteren van de voordelen van NFT’s in de vorm van inies om een sterke gemeenschappelijke consensus te vormen;</p>
<p>BTC, ook wel bekend als ‘kleine taart’, is een BRC20-token gegraveerd op de Bitcoin-blockchain op basis van het ordinals-protocol;</p>
<p>Ik geloof dat hoogwaardige inieprojecten zoals MMSS, BTCs enz. nieuwe energie zullen brengen in het Bitcoin-netwerk.</p>
<h2 id="h2-Inleiding923857"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Met de opleving van de cryptomarkt en de hype rondom de iniebaan, hebben populaire inietokens $MMSS en $BTCs onlangs aanzienlijke stijgingen laten zien. In dit artikel zullen we relevante populaire concepten uitleggen en de drijvende factoren achter dit fenomeen diepgaand bespreken, en een uitgebreide analyse maken in combinatie met markthotspots. We hopen dat dit nuttig voor jullie zal zijn.</p>
<h2 id="h2-Kan20MMSS20opnieuw20heersen674448"><a name="Kan $MMSS opnieuw heersen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kan $MMSS opnieuw heersen?</h2><p>MMSS lijkt misschien niet bekend bij veel mensen, maar als ik zeg dat het de NFT van die zwarte kat was die erg populair was in de afgelopen twee jaar, zullen veel mensen het waarschijnlijk meteen begrijpen. Ja, Mimic Shhans, die ooit ‘s werelds NFT-dominantie van katten had, heeft onlangs weer een inietoken uitgegeven, genaamd MMSS.</p>
<p>$MMSS, initiated by Korean artist SHHAN, is a BRC-20 token with the black cat IP as its core. The future development of the community includes the establishment of MMSS Art Club, MMSS Fashion Club, MMSS BTC Research Institute, and MMSS Education Academy, all revolving around the $MMSS eco. The goal of the MMSS community is to gather young cat lovers from around the world and let them express themselves in a lively way.</p>
<p>MMSS werd gelanceerd op 19 november 2023 en haalde snel meer dan 6 miljoen dollar op in vier dagen, met een prijs per token tussen $0,25 en $0,5. De oorsprong in Zuid-Korea heeft het wereldwijde aantrekkingskracht gegeven en trok vanaf het begin internationale belangstelling. MMSS heeft een pionierspositie op de internationale markt verworven en is binnen een maand genoteerd op meer dan 10 grote beurzen, waaronder Gate.io, waarmee het zijn snelgroeiende gemeenschap en culturele invloed heeft laten zien.<br><img src="https://gimg2.gateimg.com/image/article/1706170591img_v3_027e_36686bd9-50f9-4afa-a638-874c47d832ix.jpg" alt=""></p>
<p>De houding van grote beurzen ten opzichte van het inie is nu net als ten opzichte van MEME-munten. Alleen met een actieve gemeenschap kan een solide basis worden gelegd voor de langdurige stabiliteit van het inie. In de huidige Bitcoin-inie is MMSS wellicht het project met de sterkste gemeenschappelijke culturele cohesie.</p>
<p>MMSS erft direct de populaire Black Cat NFT van MIMIC SHHANS en heeft ook een hoge mate van gemeenschapsactiviteit in het verleden. De MMSS-gemeenschap is momenteel het meest internationale project binnen het mainstream inie-ecosysteem. Het enige probleem was dat er aanvankelijk te weinig NFT’s waren, waardoor de gemeenschap beperkt was in omvang. Nu kan MMSS door middel van inies meer mensen aantrekken om samen een actievere en bloeiendere wereldwijde gemeenschap te creëren, wat mogelijk een sterke gemeenschapsconsensus kan vormen en de prijs van de munt kan stimuleren.</p>
<p>Op 9 januari, volgens de marktgegevens van Gate.io, heeft MMSS, een van de leidende munten, de aandacht van de markt getrokken met een stijging van meer dan 27,63% in 24 uur. Op dit moment is de marktwaarde van MMSS nog steeds minder dan tien miljoen dollar. Naar verwachting zal de marktwaarde en de muntwaarde nog steeds aanzienlijk stijgen met de daaropvolgende notering op eersteklas beurzen.</p>
<h2 id="h2-Jij20hebt20grote20pannenkoeken20ik20heb20kleine20pannenkoekenBTCs114332"><a name="Jij hebt grote pannenkoeken, ik heb kleine pannenkoeken$BTCs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Jij hebt grote pannenkoeken, ik heb kleine pannenkoeken$BTCs</h2><p>De zogenaamde BTCs, dat wil zeggen BTC+Ordinals, kan ook worden begrepen als BTCs op Ordinals. BTCs zijn BRC20-tokens die zijn geïmplementeerd en gegraveerd op de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> blockchain op basis van het ordinals-protocol. De naam komt van Bitcoin Ordinals BTCs, ook wel bekend als gegraveerde versie van Bitcoin, kleine cakejes, kleine bitcoins.</p>
<p>Het noemen van “Xiao Bing” suggereert misschien op het moment van geboorte al zijn uitstekende en buitengewone kenmerken.</p>
<p>BTCs werd anoniem ingezet op 25 april 2023. Na 100 dagen eerlijke productie is het een niet-eigendoms-token geworden. Het volgt de gedecentraliseerde, niet-eigendoms-gebaseerde gemeenschapsconsensus van blockchain. Visie: Help 100 miljoen mensen aan een Bitcoin-portemonnee.</p>
<p>Op 31 december 2023 heeft de BRC20-token BTCs onlangs via een gemeenschapsstemming succesvol geüpgraded naar het officiële Chinese merk Bitcoin Ordinals, bijnaam: kleine taart, kleine bitcoin.<br><img src="https://gimg2.gateimg.com/image/article/1706170632img_v3_027e_038b0cf6-0907-46e7-b6a4-93cfe26a55ix.jpg" alt=""></p>
<p>Als derivaat van BTC, BTCs, afgeleid van de inie van Bitcoin, maakt het tot een natuurlijke uitbreiding van Bitcoin.</p>
<p>BTCs is geboren op de BTC-keten, de gemeenschap werd opgericht in augustus 2023, BTCs heeft actief bijgedragen aan de verspreiding van het Bit-ecosysteem tijdens de berenmarkt, heeft nieuwkomers geholpen om inies te begrijpen en eraan deel te nemen, en nu, met de opkomst van de iniemarkt, heeft de BTCs-gemeenschap al consensusleden in Europa, Amerika, Spanje, Nigeria, Maleisië, Vietnam, Zuid-Korea, Japan, en de Chinese taalregio, in de toekomst met BTCs ( <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Deze IP met een internationaal consensus-gen wordt ontdekt en opgebouwd door meer mensen in de BTC-gemeenschap, met als oorspronkelijke bedoeling: het helpen van 100 miljoen mensen wereldwijd om een Bitcoin-portemonnee te hebben.</p>
<p>Met de upgrade van het communitymerk is de consensusbasis continu gegroeid. Op 31 december 2023 heeft het BTCs-holdingsadres de 20.000 doorbroken en is het de tweede brc20-iniemunt die de grens van 20.000 na sats overschrijdt, en staat het stevig op de tweede plaats in de hele BRC20-holdingsadreslijst.</p>
<p>Met de ontwikkeling van de gemeenschap neemt de consensus geleidelijk toe, en de BTCs-gemeenschap is ook een van de eerste leden die zijn uitgenodigd om zich bij BTC Labs te vestigen. BTC Labs is een open ecosysteemvereniging van het Bit-ecosysteem, gericht op de gemeenschap, ontwikkelaars en VC van het Ordinals-ecosysteem. Samen met de gemeenschapsleden verkennen ze de gemeenschapsopbouw van het Bit-ecosysteem, projectontwikkeling en zoeken ze naar en investeren ze in potentiële hoogwaardige projecten.</p>
<p>Op 11 januari kondigde het bekende Singaporese instituut YesX aan dat het $100 miljoen zal investeren in het ontwikkelen van het Mingwen-ecosysteem en de aankoop van BRC20 Mingwen Bitcoin BTCs zal aankondigen. Dit is YesX’s derde openbare investering in Mingwen, na eths en rats, die beide meer dan 1500% rendement hebben opgeleverd. BTCs zal het eerste BRC20 Mingwen-doelwit zijn dat door het instituut in 2024 wordt ontwikkeld.<br><img src="https://gimg2.gateimg.com/image/article/1706170656img_v3_027e_9bc03156-6353-4579-b92a-85986b4c7aix.jpg" alt=""></p>
<p>Naar verluidt heeft BTCs het aantal munten bereikt 20157, goed voor de tweede plaats op de BRC20-inie van de munt, die momenteel al op 9 beurzen, waaronder Gate, genoteerd staat.</p>
<p>YesX zei dat met de eerste goedkeuring van 11 bitcoin-spot ETF’s in de cryptosector door de Amerikaanse SEC, bitcoin nu wordt erkend door traditionele instellingen en dat het bitcoin-ecosysteem opnieuw een kans heeft om te bloeien.</p>
<p>De ontwikkeling van de pie wordt in drie fasen verdeeld. In de eerste fase, de ‘Escape the Circle’-fase, wordt het verhaal overgangen met memes en worden BTC’s als kleine cakes begrepen op de top van Bitcoin. Door middel van deze marketing wordt verwacht dat de prijs in een periode van zes maanden zal variëren tussen 1 en 10U.</p>
<p>In de tweede fase, de ‘consolidatiefase’, voorzien we dat de positie van kleine cake aanzienlijk zal verbeteren, met een verwachte prijs tussen 10 en 100U, profiterend van de uitbarsting van het BTC-ecosysteem en de stierenmarkt.</p>
<p>Tot slot is de derde fase de ‘empowerment-fase’, waarin Xiaobing zal profiteren van de absolute veiligheid van het Bit B openbare blockchain om de functionaliteit van opslag, middelgrote betalingen enzovoort van Daobing over te nemen, met een verwachte prijs tussen 100 en 3000 U.</p>
<p>Over het algemeen is het nog steeds afwachten of het mogelijk is om duurzame ontwikkeling te bereiken door middel van inieve verhalen, ongeacht of men kiest voor een grote of kleine cake, en het hangt af van de ontwikkeling van toekomstige projecten en het operationele vermogen van het team.</p>
<h2 id="h2-Conclusie815765"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Zoals vermeld in het witboek van BTC’s Kleinste Koekjes, is BTC eerlijk voor iedereen en vereist het geen intelligentie, tools of trucs van gebruikers. Het vertegenwoordigt een kwestie van geloof en de omvang van de visie.</p>
<p>BTC heeft geen specifieke vertegenwoordiger en probeert ook geen verhalen van anderen te kopiëren. De naam, het gedecentraliseerde karakter en het verhaal erachter zijn het resultaat van consensus in de gemeenschap. Dit weerspiegelt het oorspronkelijke concept en de vorm van blockchain.</p>
<p>We kunnen de BTC-ecologie beschouwen als een nieuw startpunt in de wereld van blockchain, die de hoop en dromen van verleden, heden en toekomst draagt. De ecologie die door Bitcoin wordt gedragen, is niet alleen een vorm van digitale valuta, maar ook een technologische innovatie en een sociaal experiment dat voortdurend de oneindige mogelijkheden tussen digitale valuta en de echte wereld verkent.</p>
<p>De opkomst van de Brc-20-iniebaan is een levendige reis, van een genegeerd technisch concept tot een door de gemeenschap erkend actief. In deze steeds veranderende wereld van cryptogeld geloven we dat Brc-20-inietokens, zoals MMSS, BTCs en andere hoogwaardige inieprojecten, nieuwe energie zullen injecteren in het Bitcoin-netwerk en nieuwe mogelijkheden voor de branche zullen bieden.</p>
<p>Waar er een welvaartseffect is, is er een schijnwerper. Ongeacht hoe de toekomst zich ontwikkelt, zal BRC-20-inie een opvallend experiment en een veelbelovend bezit blijven, en mensen blijven stimuleren om een grotere en bredere wereld te verkennen in het Bitcoin-ecosysteem.</p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Byron B.</strong>，Gate.io onderzoeker<div class="info-tips"><em> Dit artikel vertegenwoordigt alleen de mening van de auteur en vormt geen enkel handelsadvies.<br>  </em><div><em></em>本文内容为原创，版权为Gate.io所有，如需转载请注明作者和出处，否则将追究法律责任。<br></div><p></p><br></div></div></div>