RGFnZWxpamtzIG5pZXV3cyB8IERlRmlUVkwgYmVyZWlrdGUgZWVuIG5pZXV3IGhvb2d0ZXB1bnQgaW4gMiBqYWFyLCBVbmlzd2FwIFY0IHN0YWF0IG9wIGhldCBwdW50IHRlIHdvcmRlbiBnZWxhbmNlZXJkLCBKdXBpdGVyIGtvbmRpZ3QgZGUgZWVyc3RlIHR3ZWUgcHJvamVjdGVuIGFhbiBkaWUgZ2VsYW5jZWVyZCB6dWxsZW4gd29yZGV

2024-03-11, 03:57

<p><img src="https://gimg2.gateimg.com/image/article/17101295371_6-06.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Onchain20DeFi20TVL20bereikt20een20nieuw20hoogtepunt20in20twee20jaar20Uniswap20v420staat20op20het20punt20gelanceerd20te20worden20Jupiter20LFG20Launchpad20eindigt20BVM20heeft20Filecoin20gentegreerd20als20de20opslaglaag143793"><a name="Crypto Daily Digest: On-chain DeFi TVL bereikt een nieuw hoogtepunt in twee jaar; Uniswap v4 staat op het punt gelanceerd te worden; Jupiter LFG Launchpad eindigt; BVM heeft Filecoin geïntegreerd als de opslaglaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: On-chain DeFi TVL bereikt een nieuw hoogtepunt in twee jaar; <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> v4 staat op het punt gelanceerd te worden; Jupiter LFG Launchpad eindigt; BVM heeft <a href="/price/filecoin-fil" target="_blank" class="blog_inner_link">Filecoin</a> geïntegreerd als de opslaglaag</h2><p>Op het gebied van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF-handelsactiviteiten, volgens Farside Investor-gegevens, op 8 maart (afgelopen vrijdag) bedroeg de uitstroom van Grayscale GBTC ongeveer $302,9 miljoen, BlackRock <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (IBIT) had een nettostroom van $336 miljoen per dag, Bitwise Bitcoin Spot ETF (BITB) had een instroom van $8 miljoen, ARK 21Shares Bitcoin Spot ETF (ARKB) had gisteren een instroom van $1,7 miljoen, en Fidelity Bitcoin Spot ETF (FBTC) had gisteren een instroom van $130,3 miljoen.</p>
<p>Volgens gegevens samengesteld door BitMEX Research, houdt BlackRock’s IBIT per 8 maart 197.943 Bitcoins ter waarde van meer dan $13,5 miljard, wat de cryptobezittingen van MicroStrategy overtreft.</p>
<p>Nadat Bitcoin een hoogtepunt van $70.000 bereikte, presteerden veel Altcoins ook goed; En de algehele stijging op de markt heeft het sentiment van de hele crypto-industrie verbeterd. De gegevens van DefiLlama tonen aan dat de wereldwijde totale vergrendelde waarde (TVL) van gedecentraliseerde financiële (DeFi) protocollen voor het eerst in ongeveer twee jaar is gestegen naar meer dan $100 miljard. Echter, zelfs na een aanzienlijke stijging, ligt de TVL nog steeds ver onder het record van $189 miljard dat in november 2021 werd bereikt.</p>
<p><a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> heeft officieel nieuws; Uniswap v4 staat op het punt uitgebracht te worden. De eerste fase die eerder werd uitgevoerd was code bevriezing, inclusief voltooiing van de kerncode, testen, enz. De tweede fase is voor het controleren en implementeren van het testnet, waar uitgebreide controle en community controle wedstrijden van meerdere controlebedrijven, evenals v4, zullen worden geïmplementeerd op het testnet. De derde fase is om de push te initiëren, en v4 zal worden gepusht naar de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> mainnet in het derde kwartaal.</p>
<p>DEX Jupiter op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> plaatste dat de eerste LFG Launchpad-stem is beëindigd. Er waren 175.000 stemmers in deze stem, en de eerste twee projecten die zijn geselecteerd door Jupiter DAO waren Zeus Network en SharkyFi. En er wordt benadrukt dat ‘het niet uitmaakt op wie je stemt, iedereen zal dezelfde beloning ontvangen op basis van hun stemrechten’. Eerder kreeg Jupiter ook veel aandacht vanwege de verwachte airdrop van 4 miljard tokens in vier fasen.</p>
<p><a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a> heeft officieel aangekondigd dat BVM (Bitcoin Virtual Machine) Filecoin heeft geïntegreerd als zijn opslaglaag. Deze integratie markeert een significante verbetering in de Bitcoin Layer2-oplossing ondersteund door BVM en Filecoin, wat zorgt voor een hogere beveiliging en schaalbaarheid.</p>
<p>BVM kan nu gebruik maken van Filecoin’s gedecentraliseerde opslag om transactiegegevens te archiveren, waardoor het indexeerwerk van Bitcoin-ontwikkelaars wordt vereenvoudigd via de Lighthouse-node aggregator.</p>
<h2 id="h2-Markttrends20Aanpassing20in20de20buurt20van20de20vorige20hoogte20van20BTC825209"><a name="Markttrends: Aanpassing in de buurt van de vorige hoogte van BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Aanpassing in de buurt van de vorige hoogte van BTC</h2><p>Vorige week doorbraken BTC-prijzen kort de vorige hoogte, maar ervoeren toen kortetermijnaanpassingen, waarbij de prijzen momenteel schommelen rond de vorige hoogte. De verwachte Altcoin-seizoen is echter nog niet aangebroken, en de meerderheid van de Altcoins heeft al overmatige groei in de vroege stadia doorgemaakt en bevindt zich momenteel in de aanpassingsfase. Bovendien heeft de Amerikaanse aandelenmarkt een daling doorgemaakt, is de aandelenprijs van Nvidia gekelderd en is de markt voor AI-concepttokens nog steeds aan het aanpassen.</p>
<h3 id="h3-Markt20hotspots65769"><a name="Markt hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots</h3><p>Gamefi concept coins zagen een aanzienlijke stijging: tokens zoals <a href="/price/gala-gala" rel="nofollow noopener noreferrer" target="_blank">GALA</a>, YGG en PIXELS zijn vorige week aanzienlijk gestegen. <a href="/price/gala-gala" target="_blank" class="blog_inner_link">GALA</a> en YGG worden marktgestuurd door DWF Labs, waarbij agressieve pull-up technieken worden gebruikt. Het dagelijkse aantal actieve gebruikers van PIXELS heeft 500.000 bereikt en de tokenprijs is vandaag boven de $1 gestegen, waarmee een nieuw historisch hoogtepunt is bereikt.</p>
<p>De sector van nutstokens kende aanzienlijke groei: <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, <a href="/price/okb-okb" rel="nofollow noopener noreferrer" target="_blank">OKB</a> en andere utility tokens aanzienlijk verhoogd, waardoor ID, EDU, BNX en anderen hetzelfde deden. Fondsen beginnen zich te verplaatsen naar de valuta met hogere marktwaarden maar lagere groeipercentages zoals hierboven vermeld. Het is vermeldenswaard dat ID op 27 maart een grote ontgrendeling zal ondergaan. Momenteel speculeert de markt dat er een terugtrekkingsfenomeen was voor de ontgrendeling, maar men verwacht dat de opwaartse trend niet zal voortduren.</p>
<p>De AI- en Meme-sectoren leidden de daling: AI- en Meme-munten leiden momenteel de markt in de daling. Vorige week braken meerdere Meme-munten nieuwe hoogtepunten, met een totale marktwaarde van meer dan $63 miljard. DOGE staat nog steeds op de eerste plaats met een marktwaarde van meer dan $25 miljard, gevolgd door PEPE, FLOKI, WIF en anderen. Als een nieuw uitgegeven Meme-munt in 2023, bereikte WIF vorige week meerdere keren nieuwe hoogtepunten en staat op de vijfde plaats in marktwaarde van Meme-munten met een marktwaarde van $21 miljard.</p>
<p>Verhoogde airdrop-activiteit: Saga heeft aangekondigd dat 60 miljoen SAGA’s zullen worden verdeeld onder in aanmerking komende adressen. Tegelijkertijd heeft Wormhole airdrop-query’s geopend en airdrop-details aangekondigd, waarvan 6,17% van de tokens zal worden gebruikt voor community airdrops.</p>
<p>Over het algemeen is er een rotatiefenomeen geweest tussen verschillende sectoren op de cryptomarkt. De Gamefi-conceptmunt en utility-tokensectoren hebben uitstekend gepresteerd, terwijl de AI- en Meme-sectoren aanzienlijke aanpassingen hebben laten zien. Investeerders moeten de markttrends nauwlettend volgen, voorzichtig investeringskansen grijpen en aandacht besteden aan het beheersen van risico’s. Tegelijkertijd moeten investeerders waakzaam blijven en blindelings de trend vermijden bij de aankomende grootschalige ontgrendelingsgebeurtenissen.</p>
<h2 id="h2-Macro20Amerikaanse20werkgelegenheidsrapport20uitgegeven20wereldwijde20marktdaling20Goudprijzen20bereiken20een20nieuw20hoogtepunt20terwijl20de20olieprijzen20licht20dalen424734"><a name="Macro: Amerikaanse werkgelegenheidsrapport uitgegeven, wereldwijde marktdaling; Goudprijzen bereiken een nieuw hoogtepunt, terwijl de olieprijzen licht dalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Amerikaanse werkgelegenheidsrapport uitgegeven, wereldwijde marktdaling; Goudprijzen bereiken een nieuw hoogtepunt, terwijl de olieprijzen licht dalen</h2><p>Volgens Reuters bereikten de S&amp;P 500- en NASDAQ-indexen historische hoogtepunten op de internationale markt tijdens de handel. Ze sloten lager op vrijdag, terwijl stijgende chipaandelen ook werden omgekeerd omdat de AI-gigant NVDA winst nam op vrijdag, met een daling van 5,6%.</p>
<p>Wat betreft arbeidsmarktverslagen zijn de resultaten gemengd, wat aangeeft dat er meer nieuwe banen zijn dan verwacht, maar de werkloosheid is toegenomen. Het Consumentenprijsindex (CPI) rapport van februari, dat op dinsdag is vrijgegeven, wordt verwacht met 0,4% te stijgen en te stabiliseren op een jaarlijks niveau van 3,1%. De kerninflatie wordt verwacht met 0,3% te stijgen, waardoor het jaarlijkse groeipercentage op het laagste niveau sinds begin 2021 van 3,7% komt. We zullen de zwakke situatie in het rapport van februari over de niet-agrarische loonlijst aanvullen, waarbij de werkloosheid op het hoogste niveau in twee jaar komt met 3,9% en de Federal Reserve op een koersverlagend spoor houdt in de komende maanden.</p>
<p>Aziatische aandelenmarkten daalden scherp op maandag, terwijl de Amerikaanse dollar daalde voordat de Amerikaanse inflatiegegevens de wereldwijde renteverlagingen zouden kunnen versnellen of vertragen. De Japanse yen is licht gestegen, en steeds meer beleidsmakers van de Bank of Japan neigen ertoe om deze maand een einde te maken aan negatieve rentetarieven vanwege de verwachtingen van een aanzienlijke salarisverhoging bij de jaarlijkse loononderhandelingen van dit jaar. De Nikkei-index van Japan (. N225) daalde met 2,3% na het bereiken van historische hoogtepunten vorige week; Chinese blue chip-aandelen (. CSI300) stegen met 0,2%.</p>
<p>Volgens gegevens die op maandag zijn vrijgegeven, is Japan volgens gegevens die op maandag zijn vrijgegeven, niet in een recessie beland nadat het geannualiseerde economische groeipercentage in het decemberkwartaal werd verhoogd tot 0,4%.</p>
<p>Wat betreft de goudprijzen werd de daling van de Amerikaanse dollar en obligatierendementen ondersteund door de rentevrije goudprijs, waarbij goud steeg naar $2180 per ounce, een stijging van 4,5% vorige week tot een historisch hoogtepunt.</p>
<p>Met betrekking tot grondstoffen compenseerden zorgen over de Chinese vraag de verlaging van de productie door OPEC+, een olieproducerende organisatie, en werden de olieprijzen beïnvloed. De prijs van Brent ruwe olie daalde met 54 cent naar $81.54 per vat, terwijl de prijs van Amerikaanse ruwe olie met 57 cent daalde naar $77.44 per vat.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggesties.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat 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>