QW5hbHlzZSB2YW4gd2VrZWxpamtzZSB0cmVuZGluZyBjcnlwdG8gdHJhY2sgLSBMYXllcjE=

2024-07-29, 03:35

<p><img src="https://gimg2.gateimg.com/image/article/1722223853rdzz.jpeg" alt=""></p>
<h2 id="h2-TL20DR436536"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>De <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> heeft de afgelopen week continue schommelingen en dalingen meegemaakt, met een snelle daling vlak voor het weekend. Hoewel er in het weekend over het algemeen een terugval was, lieten de meeste tracks gedurende de week een relatief duidelijke neerwaartse trend zien. Onder de verschillende trackprojecten die hoog scoren in de top rankings, gemeten aan de hand van de twee dimensies van algemene daling en marktrangschikking, is de track met relatief veel aandacht deze week Layer1.</p>
<p>De algehele wekelijkse daling van Layer1 track was 1,0%, wat relatief klein is onder de belangrijkste tracks. De best gerangschikte valuta’s wat betreft marktwaarde zijn voornamelijk mainstream valuta’s gerangschikt naar algemeen marktaandeel, aangezien Layer1 het grootste deel van de totale waarde van de cryptomarkt bestrijkt. De wekelijkse marktveranderingen van BTC waren voornamelijk lichte stijgingen, maar het presteerde goed onder de top mainstream valuta’s. Vanwege de algehele marktstijging vorige week en de impact van marktvolatiliteit en nieuwsfactoren, is de hoofdtoon deze week een correctie in de algehele markt. Daarom hebben we deze week gekozen om een basisoverzicht te geven van de Layer1 track en kort populaire projecten te introduceren, waaronder populaire dApps of informatie over muntuitgifte, terwijl we ook enkele voorspellingen doen over de markt.</p>
<p>De huidige totale marktwaarde van het MEME-trace is $2,02 biljoen, goed voor het grootste deel van het marktaandeel van crypto, met een stijging van 0,4% binnen 24 uur. De algemene markttrend is voornamelijk volatiel geweest voor de week.</p>
<p>Dit artikel richt zich voornamelijk op de trendanalyse van mainstream projecten in de Layer1-track en biedt ook enkele algemene verklaringen voor de topgroei-projecten.</p>
<h2 id="h2-Top20Munten507275"><a name="Top Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Top Munten</h2><h3 id="h3-BTC19857"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p>BTC heeft deze week een lichte stijging ervaren, met een stijging van 2,2% in zeven dagen. De prijs bleef gedurende de week boven de $68.000, maar kende een snelle neerwaartse trend tijdens de midweek periode, waarbij de piek doorbrak tot $69.000. Over het algemeen, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">BTC-prijs</a> De trend gedurende de week wordt voornamelijk gekenmerkt door fluctuerende opwaartse bewegingen, waarbij de algehele markt gedurende de week een fluctuerende trend vertoont.</p>
<p>Hoewel de algehele stijging van BTC gedurende de week relatief klein was en de slotkoers vergelijkbaar was met de openingskoers, is het al een van de top mainstream valuta met de beste prestaties van de week. Dit is gebaseerd op de herhaalde impact van nieuwsfactoren tijdens deze week, en de sleutel is de reeks opmerkingen die Trump heeft gemaakt tijdens de VS Crypto Conference. Dit heeft ook deze week de algehele markttrend van crypto beïnvloed, en BTC heeft sinds vorige week een voortdurende netto instroom van grote hoeveelheden geld meegemaakt. Hoewel deze trend deze week is afgenomen, is de bullish markt van BTC nog steeds relatief stabiel en wordt verwacht dat deze volgende week een volatiele opwaartse trend zal handhaven.<br><img src="https://gimg2.gateimg.com/image/article/17222239081.jpeg" alt=""><br>BTC Prijsgegevens (Bron: coingecko)</p>
<h3 id="h3-ETH817021"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p>De prestaties van ETH deze week waren volatieler in vergelijking met BTC, met een aanvankelijke stijging gevolgd door een daling, en bij het ingaan van het weekend is de markt licht hersteld. ETH heeft deze week een algemene neerwaartse trend laten zien, met een daling van 5,7%, en de wekelijkse prijspiek ligt rond de $ 3.538. Over het algemeen bereikte de valuta aan het begin van de week een hoogste punt in een week, gevolgd door voornamelijk volatiele fluctuaties, en kende hij een snelle daling tijdens de midweekperiode met veranderingen in de markt. Vanaf nu heeft de prijs van de valuta ongeveer $ 3.273 bereikt.</p>
<p>De wekelijkse daling van ETH valt binnen het normale bereik binnen het Layer1-traject, maar onder de belangrijkste mainstream valuta’s is de daling relatief groot. Hoewel ETH deze week officieel een spot ETF heeft gelanceerd, was de prestatie niet goed en was de instroom van externe fondsen niet optimistisch, wat een zekere invloed had op de prijstrend van ETH. Hoewel de algehele marktsituatie in de toekomst is hersteld, is het moeilijk voor de prijs van ETH om terug te keren naar boven de $3.500. ETH volgde tijdens de openingsperiode de algehele trend van de markt van vorige week, met een lichte schommeling en daling als belangrijkste trend. Het daalde echter snel als gevolg van de invloed van nieuwsfactoren. De waarschijnlijkheid dat de valuta volgende week weer een opwaartse trend zal doormaken, is nog steeds relatief laag, en de waarschijnlijkheid dat het wordt beïnvloed door de algehele marktvolatiliteitstrend is relatief hoog.<br><img src="https://gimg2.gateimg.com/image/article/17222239402.jpeg" alt=""><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">ETH Prijs</a> Gegevens (Bron: coingecko)</p>
<h3 id="h3-BNB305721"><a name="BNB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BNB</h3><p><a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> De prestaties van deze week volgden de algemene markttrend. Sinds de opening is de prijs fluctuerend gedaald, van boven de $600 naar onder de $580. Daarna is de algehele markt op korte termijn gedaald, waarbij BNB-prijzen het laagste punt hebben bereikt en onder het niveau van $560 zijn gezakt. De BNB-prijzen zijn deze week aanzienlijk fluctuerend geweest, met een wekelijkse daling van ongeveer 1,8% en een wekelijks hoogtepunt van ongeveer $602 tijdens de openingsronde. Over het algemeen bereikte de prijs van deze valuta het hoogste punt van de week aan het begin van de week en bleef daarna fluctueren en dalen.</p>
<p>De wekelijkse schommelingsrange van <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> is relatief klein onder de belangrijkste mainstream valuta, maar de prijsschommelingsrange is relatief groot. Als een uitwisselingsplatformtoken fluctueert BNB voornamelijk met de algehele marktvolatiliteit, en het tijdstip van fluctuaties is duidelijker dan bij andere valuta’s. Het is echter zeer waarschijnlijk dat deze valuta volgende week een aanhoudende kleine fluctuatie op de markt zal doormaken, waarbij vooral significante marktveranderingen vereist zijn.<br><img src="https://gimg2.gateimg.com/image/article/17222239983.jpeg" alt=""><a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB Prijs</a> Gegevens (Bron: coingecko)</p>
<h2 id="h2-Populaire20projecten807550"><a name="Populaire projecten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Populaire projecten</h2><h3 id="h3-CCDConcordium34615"><a name="CCD-Concordium" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CCD-Concordium</h3><p>Concordium is een Layer 1 blockchain ondersteund door technologie en verantwoordelijk voor het milieu. Het stelt individuen en bedrijven in staat om te navigeren <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Met vertrouwen. Deze blockchain maakt controleerbare autonome gegevensbezit en veilige transacties tegen lage kosten mogelijk.</p>
<p>Met Concordium kunnen gebruikers verantwoord gebruikmaken van de kracht van blockchaintechnologie terwijl ze vertrouwen kweken in de digitale wereld.</p>
<p>CCD, de inheemse token gelanceerd door Concordium, werd gelanceerd in het eerste kwartaal van 2022 en bereikte snel een historisch hoogtepunt van $0.115550. De prijs daalde echter snel en vertoont sinds het tweede kwartaal van 2022 een voortdurende neerwaartse trend.</p>
<p>CCD lanceerde deze week een nieuw stimuleringsprogramma, gebaseerd op ID-oplossingen om het ecosysteem te versterken. Tegelijkertijd werd Boris, die 20 jaar ervaring heeft in digitale activa-infrastructuur, aangekondigd als CEO, en meerdere acties hebben geleid tot de snelle stijging van de valuta in de afgelopen week.</p>
<p>De wekelijkse stijging van CCD is gestegen tot 31,4%, met een hoogste prijs van $0,00412. Dit is de hoogste wekelijkse stijging in de Layer1-categorie, maar het behoort tot de niet-mainstream valutacategorie, met een marktkapitalisatierangschikking van ongeveer 700+.<br><img src="https://gimg2.gateimg.com/image/article/17222240324.jpeg" alt=""><br>CCD Prijsgegevens (Bron: coingecko)</p>
<h3 id="h3-AIOZAIOZ20Netwerk93140"><a name="AIOZ-AIOZ Netwerk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AIOZ-AIOZ Netwerk</h3><p>AIOZ Network is een uitgebreide infrastructuuroplossing die wordt aangestuurd door menselijke hulpbronnen. Het wordt gebruikt voor Web3-opslag, gedecentraliseerde AI-berekening, live streaming en video on demand (VOD).</p>
<p>Naarmate de wereldwijde vraag naar digitale inhoud blijft groeien, explodeert de vraag naar betrouwbare en schaalbare oplossingen voor bestandsopslag, videostreaming en contentlevering. AIOZ streeft ernaar om een nieuwe vraag te creëren die veel traditionele infrastructuren overstijgt en voldoet aan de behoeften van ‘online first’.</p>
<p>AIOZ Network is een goed gevestigd project dat zich richt op het gebied van Web3-infrastructuurbouw. De inheemse governance-token, AIOZ, werd gelanceerd in het tweede kwartaal van 2021 en bereikte onmiddellijk een historisch hoogtepunt van $2,2. Vervolgens stortte de prijs in tot binnen het bereik van $0,3 en schommelde rond, maar er waren nog steeds twee rondes van aanzienlijke muntstijgingen, en het bevindt zich momenteel in de tweede cyclus.</p>
<p>Deze week richtte AIOZ Network zich voornamelijk op externe project samenwerking en het tonen van technische functies, waarbij een speciale X Space werd gehouden. Tegelijkertijd staat de lancering van het nieuwe Web3-platform van het project op het punt te gebeuren, met nieuwe functies zoals AI, gedecentraliseerde opslag en GPU-rekenkracht. Meerdere nieuwsberichten hebben de stijging van de AIOZ-token gestimuleerd.</p>
<p>AIOZ heeft echter aanzienlijke schommelingen in de prijs gekend in de afgelopen week, met een stijging van 16,8% en een hoogtepunt van ongeveer $0,5721. Het maakt momenteel een nieuwe opwaartse trend door. AIOZ staat echter boven de 100 in marktkapitalisatie en is relatief minder mainstream.<br><img src="https://gimg2.gateimg.com/image/article/17222240795.jpeg" alt=""><br>AIOZ Prijsgegevens (Bron: coingecko)</p>
<h3 id="h3-XECeCash411143"><a name="XEC-eCash" class="reference-link"></a><span class="header-link octicon octicon-link"></span>XEC-eCash</h3><p><a href="/price/ecash-xec" rel="nofollow noopener noreferrer" target="_blank">eCash</a> werd voorheen bekend als BCHA en later hernoemd naar eCash. <a href="/price/ecash-xec" target="_blank" class="blog_inner_link">eCash</a> heeft de visie van de legendarische figuur Milton Friedman gerealiseerd, waarmee de financiële vrijheid ongekende hoogten bereikt. Met eCash hebben gebruikers een eenvoudige ervaring bij het versturen van e-mails bij het doen van geldovermakingen.</p>
<p>XEC is een inheemse token gelanceerd door eCash in het derde kwartaal van 2021. Na twee maanden steeg de muntwaarde snel naar een historisch hoogtepunt van $0.00033265, maar de duur was kort. Vervolgens onderging de muntwaarde voortdurende schommelingen en dalingen, en bleef relatief laag na 2022.</p>
<p>De updates van eCash deze week draaien voornamelijk om het promoten van de wallet-applicatie, en er zijn overeenkomstige acties binnen de gemeenschap ondernomen. De token XEC is echter met 10,8% gestegen in een week, wat niet bijzonder significant is tussen de verschillende valuta’s op Layer1. De wekelijkse prijspiek staat op $0,00004181.<br><img src="https://gimg2.gateimg.com/image/article/17222240926.jpeg" alt=""><a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">OP Prijs</a> Gegevens (Bron: coingecko)</p>
<h2 id="h2-Postmarktprognose277608"><a name="Postmarktprognose" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Postmarktprognose</h2><p>Vergeleken met andere projecten op het gebied vertegenwoordigt de prestatie van de Layer1 track deze week de algehele markttrend van de cryptomarkt, met een wekelijkse schommeling van -1,0% en relatief kleine veranderingen. Hoewel de markt als geheel deze week sterk is beïnvloed door nieuwsfactoren, zal het herstelproces van de markt geleidelijk duidelijk worden vanuit de algehele markttrend. De Layer1 track heeft deze week een relatief kleine daling en heeft goed gepresteerd onder verschillende crypto tracks.</p>
<h2 id="h2-Hot20Nieuws582688"><a name="Hot Nieuws" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hot Nieuws</h2><p>WATER heeft deze week een voortdurende volatiele opwaartse trend doorgemaakt en het is een van de nieuw gelanceerde cryptocurrencies.</p>
<p>Vanwege de korte lanceringstijd en het aanzienlijke potentieel voor prijsstijgingen, heeft de markt over het algemeen een bullish sentiment. Bovendien promoot de officiële instantie continu het netwerktestproces, wat resulteert in veel updates met betrekking tot deze valuta. De wekelijkse stijging bereikte 26,8%, en het wekelijkse hoogtepunt van de muntwaarde bereikte $0,01015, wat een continue fluctuatie op het $0,01 niveau handhaaft.<br><img src="https://gimg2.gateimg.com/image/article/17222241187.jpeg" alt=""><br>De algehele prestaties van de cryptomarkt zijn deze week beïnvloed door de marktcyclus en nieuwsfactoren, wat heeft geleid tot enkele fluctuaties en een relatief duidelijke neerwaartse trend. Laag 1, als de baan met de grootste marktwaarde in de huidige markt, heeft een relatief kleine algehele daling, wat in feite aangeeft dat de hoofdtoon van de huidige markt een lichte fluctuatietrend vertoont. Momenteel lijkt het erop dat deze trend zich op korte termijn zal voortzetten en dat de fluctuaties relatief klein zullen zijn.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Charles T.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen beleggingssuggesties.<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>