RGFnZWxpamtzIG5pZXV3cyB8IE1hcmt0IGZsdWN0dWVlcnQgb21ob29nOyBTdGFja3MgYmVnaW50IGRlIOKAnE5ha2Ftb3RvLWhlcnZvcm1pbmfigJ07IFBheVBhbCBzdGltdWxlZXJ0IOKAnGdyb2VuZSBtaW5lcnPigJ07IE5ldXJhIGJyZW5ndCBlZW4gb3BlbmJhcmUgdGVzdG5ldCB1aXQ=

2024-04-23, 03:48

<p><img src="https://gimg2.gateimg.com/image/article/171384407223.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Stacks20begint20de20Nakamoto20Reform20PayPal20stelt20een20Green20Miner20Incentive20Plan20voor20Ankrs20Layer120Network20Neura20Releases20Public20Testnet383442"><a name="Crypto Daily Digest: Stacks begint de “Nakamoto Reform”; PayPal stelt een “Green Miner Incentive Plan” voor; Ankr’s Layer1 Network Neura Releases Public Testnet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: <a href="/price/stacks-stx" target="_blank" class="blog_inner_link">Stacks</a> begint de “Nakamoto Reform”; PayPal stelt een “Green Miner Incentive Plan” voor; Ankr’s Layer1 Network Neura Releases Public Testnet</h2><p>Laten we eerst eens kijken naar de handelsactiviteit van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor stroomden op 22 april de spot-ETF-fondsen van Grayscale GBTC uit $35 miljoen; Ondertussen, instroom van $19,7 miljoen in iShares Trust <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (IBIT); instroom van $34,8 miljoen in Fidelity Bitcoin spot ETF (FBTC), instroom van $2,2 miljoen in Bitwise Bitcoin spot ETF (BITB) en instroom van $22,6 miljoen in ARK 21Shares Bitcoin spot ETF (ARKB).</p>
<p><a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> blockchain staat op het punt om een grote hervorming te ondergaan, genaamd ‘Nakamoto’, als eerbetoon aan de anonieme makers van Bitcoin. De hervorming zal beginnen vanaf de hoogte van het Bitcoin-blok op 840.360 en zal in twee stappen worden uitgevoerd, naar verwachting eind mei voltooid. Deze hervorming heeft als doel om het blokproductieplan van Stacks los te koppelen van Bitcoin.</p>
<p>Volgens Muneeb Ali, de oprichter van het Stacks-netwerk, CoinDesk, hoewel de transactiedoorvoer van het Layer 2-netwerk hoger is dan die van Bitcoin (ongeveer zeven transacties per seconde verwerken), had Stacks volgens het oorspronkelijke ontwerp dezelfde blokuitvoersnelheid als Bitcoin, wat congestieproblemen veroorzaakte.</p>
<p>Momenteel bedraagt de waarde van gestorte STX op de ketting ongeveer $1,3 miljard, wat overeenkomt met een derde van het totale circulerende aanbod van $4,2 miljard, waardoor het een van de grootste rentebetalende kapitaalpools met betrekking tot Bitcoin is. In de afgelopen 24 uur is de prijs van deze token met meer dan 16% gestegen en voor het eerst tot de top 25 tokens qua marktwaarde toegetreden.</p>
<p>PayPal en EnergyWeb werken samen aan de ontwikkeling van een oplossing die Bitcoin-miners beloont voor het gebruik van koolstofarme energie in hun activiteiten.</p>
<p>PayPal heeft maandag op zijn blog verklaard dat hun blockchain-onderzoeksteam heeft samengewerkt met de non-profitorganisatie EnergyWeb om een platform voor verificatie van schone energie te ontwikkelen voor het monitoren en belonen van Bitcoin-mijnbouwbedrijven met een lager energieverbruik. De ontwikkeling van deze oplossing komt op een moment dat Bitcoin-mijnbouw enorme druk legt op lokale stroomnetten en belastingbetalers in de Verenigde Staten.</p>
<p>Bitcoin-mining is een proces waarbij miners grote, energieverslindende computers gebruiken. De oplossing die door PayPal is voorgesteld, zal Bitcoin verdelen naar “groene” Bitcoin-miners, die gebruikmaken van laag-koolstofenergie bij hun mining-operaties. De National Oceanic and Atmospheric Administration van de Verenigde Staten stelt dat het gebruik van laag-koolstof mining-methoden koolstofemissies kan beperken en de opwarming van de aarde kan vertragen.</p>
<p>De <a href="/price/ankr-ankr" rel="nofollow noopener noreferrer" target="_blank">Ankr</a> Het team van Protocol Village heeft aangekondigd dat hun AI Layer 1 chain “Neura” is vrijgegeven aan het publieke testnetwerk. Dit testnetwerk is gebouwd op de Cosmos SDK en is compatibel met <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De Neura Virtual Machine (NVM). Neura heeft als doel een platform te bieden voor ontwikkelaars die dApps willen ontwikkelen die kunstmatige intelligentie en <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> integreren.</p>
<p>Neura heeft belangrijke uitdagingen voor AI-startups aangepakt, zoals het waarborgen van financiering, het verkrijgen van GPU-bronnen en het effectief opslaan van gegevens door middel van innovatieve technologiecombinaties. Het ‘Road to Mainnet’-programma van Neura omvat een ontwikkelaarswedstrijd, waarbij de beste projecten $100.000 aan financiering ontvangen. Daarnaast zal Neura ook beloningen bieden aan ANKR-tokenhouders, waaronder unieke voordelen zoals de mogelijkheid om te investeren in nieuwe tokens voor kunstmatige intelligentie-modellen.</p>
<h2 id="h2-Markttrends20De20cryptomarkt20fluctueert20omhoog20en20Meme20coin20presteert20sterk347695"><a name="Markttrends: De cryptomarkt fluctueert omhoog, en Meme coin presteert sterk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De cryptomarkt fluctueert omhoog, en Meme coin presteert sterk</h2><p>Vandaag vertoont de cryptomarkt een volatiele opwaartse trend, waarbij de Meme- en LSD-sectoren de markt presteren. In de contractmarkt tonen zowel BTC- als ETH-tarieven negatieve waarden, wat aangeeft dat de marktsentiment mogelijk overdreven pessimistisch is, wat een potentieel keerpunt in markttrends kan aangeven.</p>
<p>Met betrekking tot de macro-economie is de Amerikaanse aandelenmarkt hersteld na zes opeenvolgende dalingen. Toch is de prestatie van het financiële rapportageseizoen niet ideaal, wat een zekere invloed kan hebben op het sentiment van de cryptomarkt.</p>
<h3 id="h3-Marktplaats20hotspots315516"><a name="Marktplaats hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktplaats hotspots:</h3><p>De Meme sector boekte aanzienlijke winsten: tokens zoals PEPE, MOG, SLERF en FOXY zagen allemaal aanzienlijke stijgingen. Als motor van de vorige ronde van de Meme markt heeft PEPE opnieuw de leiding genomen bij de lancering, wat erop wijst dat het een nieuwe ronde van de Meme markt kan stimuleren. Daarnaast heeft Slerf een miljoen dollar terugbetaling voltooid aan token pre-sales, wat heeft geleid tot een aanzienlijke stijging van de prijs.</p>
<p>Staking-tokens voor liquiditeit hebben ook een sterke prestatie laten zien: PENDLE, ANKR, SSV en andere tokens zijn aanzienlijk gestegen. On-chain data geeft aan dat er onlangs veel PENDLEs zijn teruggetrokken uit beurzen, met een totale waarde van meer dan $11 miljoen. Deze grootschalige cash <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flow</a> kan duiden op de lange termijn <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> naar deze tokens toe.</p>
<p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De rage van on-chain Meme-tokens: MANEKI behaalde kort na de lancering een prijsstijging van 300-voud, met een marktwaarde van meer dan $100 miljoen. De Meme-token van de kattenafbeelding is onlangs veel gehypet op de markt, en het Maneki-project heeft aanzienlijk meer aandacht gekregen op sociale media.</p>
<p>Het BTC-ecosysteem heeft slecht gepresteerd: zowel het rune-project als BTC Layer2 hebben niet aan de verwachtingen voldaan en het hele BTC-ecosysteem heeft over het algemeen een scherpe daling doorgemaakt in de afgelopen tijd. Naarmate het BTC-halveringsevenement voorbij is, kan de marktfocus verschuiven naar andere veelbelovende gebieden.</p>
<p>Hoewel de markt een fluctuerende opwaartse trend vertoont, is er een duidelijke differentiatie tussen verschillende sectoren. De Meme sector en sommige liquiditeitsstakingprojecten hebben sterke marktactiviteit en investeerdersinteresse aangetoond, terwijl het BTC-gerelateerde ecosysteem aanzienlijke druk ondervindt. Investeerders moeten overwegen om risico’s te diversifiëren bij deelname aan de markt en aandacht besteden aan de mogelijke impact van marktsentiment en macro-economische factoren op de cryptomarkt.</p>
<h2 id="h2-Macro20Wereldwijde20markten20hebben20sinds20een20week20van20neergang20een20eerste20herstel20laten20zien411376"><a name="Macro: Wereldwijde markten hebben sinds een week van neergang een eerste herstel laten zien." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wereldwijde markten hebben sinds een week van neergang een eerste herstel laten zien.</h2><p>Op 22 april sloot de Wall Street-aandelenmarkt hoger omdat beleggers zich deze week richtten op de kwartaalresultaten van grote bedrijven om de gezondheid van de Amerikaanse economie te begrijpen. Wat betreft de afsluiting steeg de Dow Jones-index met 0,67%, steeg de Standard&amp;Poor’s-index met 0,87% en steeg de Nasdaq-index met 1,11%.</p>
<p>Grote techaandelen presteerden goed voordat ze deze week kwartaalresultaten bekendmaakten, wat de Nasdaq-index deed stijgen. De aandelenkoersen van Alphabet, Amazon en Apple stegen tussen 0,5% en 1,5%, terwijl Nvidia met 4,4% steeg, na een daling van 10% op de vorige handelsdag.</p>
<p>Naast het controleren van de winstgevendheid van topbedrijven, wacht de markt nog steeds op de vrijgave van Amerikaanse BBP-gegevens en gegevens over persoonlijke consumptie-uitgaven in maart later deze week. Deze gegevens zijn cruciaal voor het bepalen van de koers van het monetair beleid, met name de impact ervan op de Federal Reserve.</p>
<p>Op Europees niveau verklaarde de Italiaanse minister van Economie dat de Europese Centrale Bank naar verwachting de rentetarieven in de tweede helft van 2024 zal verlagen. Dit nieuws heeft een zekere impact gehad op de markt, vooral op de stroom van bankkrediet.</p>
<p>Op 23 april, gesteund door het herstel van de technologische aandelen, rustige vastrentende markten en afnemende geopolitieke spanningen, openden de wereldwijde aandelenmarkten positief op maandag en wordt verwacht dat de Aziatische aandelenmarkten op dinsdag zullen herstellen. Beïnvloed door Wall Street bleven de Aziatische aandelenmarkten vandaag hun opwaartse trend voortzetten. De focus van deze week is verschoven naar de winstgevendheid van Amerikaanse technologiereuzen, waarbij de Amerikaanse dollar sterk blijft ten opzichte van valuta, waardoor de Japanse yen naar een 34-jarig dieptepunt daalt.</p>
<p>Met de voortdurende popularisering en ontwikkeling van toepassingen voor kunstmatige intelligentie kunnen technologiebedrijven zoals TSMC profiteren van deze trend, waardoor de aandelenkoersen kunnen herstellen. Het wordt verwacht dat de aandelenkoers van TSMC zal herstellen na de daling van 6% op vrijdag en de daling van 1% op maandag. Volgens officiële gegevens uit Taipei was de groeisnelheid van de exportorders in maart lager dan verwacht. Desalniettemin heeft de overheid nog steeds vertrouwen in de stijgende vraag naar toepassingen voor kunstmatige intelligentie, wat zal leiden tot toekomstige groei in de vraag naar hoogtechnologische producten in Taiwan.</p>
<p>Met de voortdurende popularisering en ontwikkeling van toepassingen voor kunstmatige intelligentie, kunnen technologiebedrijven zoals TSMC profiteren van deze trend, waardoor de aandelenkoersen kunnen herstellen.</p>
<p>De economische kalender van dinsdag is behoorlijk vol, met inkoopmanagersindexrapporten uit Japan, Australië en India, consumenteninflatieverslagen uit Singapore en Hong Kong, producenteninflatieverslagen uit Zuid-Korea en industriële productieverslagen uit Taiwan.</p>
<p>Wat betreft grondstoffen, terwijl beleggers doorgaan met het ueren van de situatie in het Midden-Oosten, herstelden de olieprijzen zich van aanzienlijke dalingen ‘s nachts. Brent ruwe olie futures stegen met 0,2% naar $87,16 per vat, terwijl de Amerikaanse ruwe olie futures met 0,2% stegen naar $82,06 per vat.</p>
<p>Na een daling van 2,7% van de ene op de andere dag, bleef de goudprijs met 1% dalen tot $ 2.295,9 per ounce.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S. &amp; Icing</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 enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>