T252ZXJ3YWNodGUgc3Byb25nIC0gQml0Y29pbiBicmVla3QgJDQwLjAwMDsgT1JESSBiZXJlaWt0IGVlbiBuaWV1dyBob29ndGVwdW50

2023-12-04, 09:29

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-Onverwachte20sprong20Redenen20voor20BTC20die20door20weerstandsniveaus20breekt20en20het20BRC2020ecosysteem114862"><a name="Onverwachte sprong: Redenen voor BTC die door weerstandsniveaus breekt en het BRC-20 ecosysteem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onverwachte sprong: Redenen voor BTC die door weerstandsniveaus breekt en het BRC-20 ecosysteem</h2><p>Op 4 december, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Doorbrak $40.000, de hoogste record sinds de eerste helft van 2022; En het momentum is volledig onstuitbaar. Volgens Gate-gegevens heeft de hoogste prijs van BTC in 24 uur $41743 overschreden, een stijging van meer dan 4%, ondanks de algehele marktsentiment die is ontstoken.</p>
<p>Eerder hadden de meeste cryptocurrency-analisten vergelijkbare opvattingen over de trend van Bitcoin, waarbij 39000 een belangrijk weerstandsniveau was. Als dit weerstandsniveau wordt doorbroken, wordt verwacht dat het binnen korte tijd $40.000 zal bereiken. En inderdaad, nu is de Grote Stier gearriveerd en heeft sneller dan verwacht $41.000 overschreden. Ondertussen heeft volgens gegevens van IntotheBlock het aantal adressen met meer dan 1000 BTC een nieuw hoogtepunt bereikt in 2023, en de marktwaarde van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> heeft de $780 miljard overschreden.</p>
<p>In de vorige maand bleef Bitcoin op een hoog niveau schommelen nadat het gestegen was tot $36.000. Over het algemeen, afgezien van enkele uitbraken van BRC20 en GameFi, schommelde de markt ook bijna altijd mee met de schommelingen van Bitcoin, wat ervoor zorgde dat mensen in de cryptocurrency-industrie horizontaal sprongen van twijfel en angst. Nu is de algemene situatie duidelijk en bereidt de markt zich voor om naar de volgende fase te gaan.<br><img src="https://gimg2.gateimg.com/image/article/17016816781.png" alt=""><br>Bron: Gate.io</p>
<p>De stijging van BTC wordt verwacht, maar de volgende zijn de drijvende krachten achter deze golf van doorbraak van het weerstandsniveau:</p>
<p>Ten eerste verwacht de markt dat de Federal Reserve de rente zal verlagen, wat ook de eerste keer is dat een vertegenwoordiger van de raad van bestuur van de Federal Reserve een renteverlaging heeft aangekondigd. Op dit moment stromen veilige haven fondsen naar goud en Bitcoin; Ten tweede hebben Bitcoin-houders een relatief sterke langetermijnwens, met minder verkoopdruk. Ondertussen stromen er gestaag over-the-counter fondsen binnen, met een aanzienlijke toename van de instroom van stablecoins in november; Ook is er nieuwe informatie die wijst op het goedkeuringsvenster voor Bitcoin ETF’s (rond 10 januari volgend jaar), en meerdere positieve nieuwsfactoren hebben geleid tot de huidige opwaartse trend van Bitcoin.<br><img src="https://gimg2.gateimg.com/image/article/17016818832.jpeg" alt=""><br>Bron: unsplash</p>
<p>Overeenkomstig is de situatie van Altcoins relatief stabiel en hebben L1 en L2 de algemene markt nog niet bijgehouden. Bijvoorbeeld, ETH is zelfs enkele maanden zeer stabiel gebleven zonder een sterke opwaartse trend; Maar ik geloof dat fondsen binnenkort zullen komen. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> door middel van belangrijke publieke ketens en hun afgeleide projecten.</p>
<p>Ondertussen toont de BRC20-token, die ups en downs heeft meegemaakt, opnieuw de dramatische aard van het inie-activum. Volgens Gate-gegevens behaalde ORDI de hoogste 24-uursstijging van TOP2. Als de BRC20-token die al een honderdvoudig wonder heeft gecreëerd en ook de eerste BRC20-token is, vertoonde ORDI vorige week een lichte daling, omdat het lijkt dat deelnemers geleidelijk winst maken en vertrekken. Het feit is dat het de wind van BTC draagt en op korte termijn zal terugkeren; Het moet gezegd worden dat hoewel er nog steeds een gebrek is aan praktische waarde op dit moment, het iniespoor de kracht van marktsentiment laat zien.</p>
<p>Echter is de trend van andere BRC20 tokens over het algemeen nog steeds behoorlijk onvoorspelbaar en fluctueert sterk, omdat de huidige BRC20 nog steeds ontbreekt aan infrastructuurconstructie. Het is pas wanneer er meer ontwikkelaars of instellingen deelnemen dat dit ecosysteem organisch kan worden opgebouwd, maar dit zal zeker tijd kosten. Spelers moeten zorgvuldig overwegen of ze al dan niet willen deelnemen aan inie en zelfs handelen op de secundaire markt. Het is het beste om grondig onderzoek te doen naar de projecteigenaar en gemeenschap voordat een beslissing wordt genomen.<br><img src="https://gimg2.gateimg.com/image/article/17016819343.png" alt=""><br>Bron: BRC-20.io</p>
<p>Afgezien van BRC20 hebben ook andere openbare keteninies een uitstekende prestatie laten zien, zoals ETHs die een golf van explosieve groei hebben doorgemaakt. Slimme contracten en lage GAS-kosten hebben aanzienlijk potentieel gebracht voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> inies. We hebben eerder analyseartikelen gepubliceerd op de Gate-blog, en geïnteresseerde lezers kunnen zoeken naar iniezoekwoorden om de mogelijke vooruitzichten van ETHs te ueren.</p>
<p>De explosie van energieopslagprojecten kan een plotseling fenomeen zijn. GameFi Track geleid door Xpet.<br>In de afgelopen twee dagen is de populariteit van GameFi niet nieuw. De financieringsschaal van de GAMEFI-sector in oktober was erg groot, en dergelijke resultaten werden verwacht; Maar zelfs met zoveel projecten, steekt de populariteit van Xpet nog steeds boven de opkomende GameFi uit.</p>
<p>Xpet is een uitbreiding gebaseerd op X, met een eenvoudige gameplay. Verzamel eenvoudigweg je huisdier en het wordt weergegeven op je X-startpagina. Spelers kunnen deelnemen aan interactieve activiteiten zoals voeren, huisdieren en boerderijen upgraden, fruit produceren, deze omzetten in gametokens, items kopen, enzovoort. Tegelijkertijd kan het worden uitgewisseld met ETH.</p>
<p>Eenvoud en begrijpelijkheid zijn precies de voordelen van Xpet, die geen complexe operaties vereist. Het heeft te maken met X, een mainstream sociaal platform, en in combinatie met een zeer schattige huisdierafbeelding is het zeer vriendelijk voor milde spelers en spelers die echt willen spelen om te verdienen. Hoewel er geen significante promotie is, wordt ook verwacht dat het fenomenale bereik van Xpet.</p>
<p>Echter, als je wilt deelnemen, onthoud dan om niet ‘betrokken te raken’, aangezien de tokens $BPET en $XPET nog niet zijn gelanceerd, en de projectontwikkeling is ook erg basis.<br><img src="https://gimg2.gateimg.com/image/article/17016819544.png" alt=""><br>Bron: Xpet (Google-extensie)</p>
<p>Naast dit kleine spel dat in feite GameFi en SocialFi combineert, zijn er ook veel spannende gameprojecten die op lancering wachten. Bijvoorbeeld het 3AFPS meesterwerk SHARPNEL, gemaakt door een professioneel ontwikkelingsteam; Goed gemaakt en zeer speelbaar RPG-spel BIG TIME; De Gas Hero gepromoot door het StepN-team. Als het spel jouw favoriet is, kun je ook zoeken naar GameFi op Gate om een overzicht te krijgen van trends, populaire projecten en professionele analyses.</p>
<p>Ik geloof dat XPET kan dienen als een startpunt om GameFi te revitaliseren, wat al lange tijd stil heeft gestaan, en daardoor GameFi-platforms zoals <a href="/price/gala-gala" rel="nofollow noopener noreferrer" target="_blank">GALA</a> Spellen, NFT-markten en op forums gebaseerde platforms. Tegelijkertijd hoop ik dat de verbetering van het productieniveau van Web3-games GameFi daadwerkelijk kan brengen in een gezond en welvarend ecosysteem.</p>
<h2 id="h2-Het20vinden20van20een20nieuwe20weg20leidt20tot20FOMOgekte20op20de20markt20Blast20en20LUNC386933"><a name="Het vinden van een nieuwe weg leidt tot FOMO-gekte op de markt: Blast en LUNC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het vinden van een nieuwe weg leidt tot FOMO-gekte op de markt: Blast en LUNC</h2><p>Als nieuw project van het ‘bekende’ BLUR-team kan de deelname van Blast wel een wonder genoemd worden. De laatste keer dat ik informatie verzamelde over Blast was twee weken geleden. Het aantal officiële volgers op Twitter was 25000, maar vandaag heeft het de 170.000 overstegen.</p>
<p>De logica van Blast is geenszins vernieuwend. Het verhaal is “rentedragende L2”, wat gebruikers in feite vertelt dat het hun ETH op de lange termijn stabiel kan houden en niet in waarde kan dalen als gevolg van inflatie - het lost ook het eigen TVL-probleem van het platform op, en aan de andere kant is het meest directe “passieve inkomen” als verkoopargument voldoende om de interesse van gebruikers in deelname te wekken.</p>
<p>Het moet gezegd worden dat het BLUR-team goed is in het creëren van onderwerpen en verkooppunten. Nu de TVL van Blast de 600 miljoen heeft overschreden en BLUR het derde seizoen van airdrops ingaat, zou deze nieuwe highlight over NFT en DeFi ook kunnen aanslaan.<br><img src="https://gimg2.gateimg.com/image/article/17016819815.png" alt=""><br>Bron: Blast.io</p>
<p>Laten we het tenslotte hebben over de ‘wederopstanding’ van de LUNA-gemeenschap - de lancering van een nieuw project genaamd Mint Cash. We hopen USTC (dat eigenlijk UST2.0 is) opnieuw te koppelen aan de Amerikaanse dollar en stellen voor limieten te stellen aan de maximale voorraad van LUNC en USTC. De <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Het team heeft voorgesteld om BTC als backup asset te gebruiken om dit stablecoin systeem volledig te ondersteunen.</p>
<p>Toen dit nieuws voor het eerst werd vrijgegeven, steeg de USTC met meer dan 300%, maar er had een terugval moeten zijn en vervolgens daalde het weer; De momentum is de afgelopen twee dagen weer opgeveerd en zweeft rond de 0,065 USDT.<br><img src="https://gimg2.gateimg.com/image/article/17016819966.png" alt=""><br>Bron: Gate.io</p>
<p>Het concept en de visie die door Mint Cash worden gepresenteerd, bieden een laag van zekerheid in vergelijking met de vorige ‘algoritmische stablecoin.’ Hoe dan ook, hoe gebruikers die de LUNA-crash hebben meegemaakt opnieuw vertrouwen kunnen geven, is een lange en uitdagende reis; Misschien kan USTC echt profiteren van de algehele marktstijging en zijn positie als stablecoin herwinnen, maar op zijn minst vanuit het perspectief van het project zelf heeft Mint Cash momenteel alleen een whitepaper en ontbreekt het aan voldoende informatie om dit alles te ondersteunen.</p>
<h2 id="h2-Conclusie843096"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De sterke doorbraak van BTC heeft ongetwijfeld de cryptoruimte geïnspireerd; Er zijn tekenen van de Federal Reserve die de rentetarieven verlagen, en de vierde halvering komt dichterbij, met steeds meer mensen die dienovereenkomstig instappen; Of het nu gaat om het volgen van de marktindex of het zoeken naar potentiële Altcoins, nu is een uitstekende gelegenheid.</p>
<p>Wanneer informatie explodeert, is het ook een tijd voor spelers om hun onafhankelijke denkvermogen en kalmte te testen - vooral voor particuliere beleggers die het moeilijk vinden om first-hand intelligentie te begrijpen. Ik hoop dat iedereen ook zijn vermogensallocatie goed kan beheren onder het sentiment van de snelle terugkeer van de stier, en niet in de problemen komt door FOMO of paniek.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>