RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBIYWx2ZWQgQmxvY2sgYmV0YWFsZGUgZWVuIGV4dHJhICQyLjRNIGFhbiBiZWxvbmluZ3Nrb3N0ZW47IE1lcmxpbiBDaGFpbiBsYW5jZWVyZGUgVG9rZW4gTUVSTDsgTWFyaW5hZGUgREFPIHN0ZWxkZSB2b29yIG9tIDUwTSBNTkRFcyB0b2UgdGUgd2lqemVu

2024-04-22, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/171375825522.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Bitcoin20halveerde20blok20betaalde20een20extra202420miljoen20aan20beloningskosten20Merlin20Chain20lanceerde20token20MERL20Marinade20DAO20stelde20voor20om205020miljoen20MNDEs20toe20te20wijzen174744"><a name="Crypto Daily Digest: Bitcoin halveerde blok betaalde een extra $2,4 miljoen aan beloningskosten; Merlin Chain lanceerde token MERL; Marinade DAO stelde voor om 50 miljoen MNDEs toe te wijzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> halveerde blok betaalde een extra $2,4 miljoen aan beloningskosten; Merlin Chain lanceerde token MERL; Marinade DAO stelde voor om 50 miljoen MNDEs toe te wijzen</h2><p>Eerst kijken we naar <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Handelsactiviteiten van ETF’s. Volgens gegevens van Farside Investor had Grayscale Bitcoin spot ETFs (GBTC) op 22 april een uitstroom van $45,8 miljoen. Ondertussen was de instroom van Fidelity Bitcoin spot ETF (FBTC) $54,8 miljoen, instroom van Bitwise Bitcoin spot ETF (BITB) was $4,9 miljoen, instroom van ARK 21Shares Bitcoin spot ETF (ARKB) was $12,5 miljoen, en netto-instroom van iShares Trust Bitcoin spot ETF (IBIT) was $29,3 miljoen.</p>
<p>Na vijf opeenvolgende dagen van verliezen, registreerden investeringen in de Bitcoin ETF-markt een nettostroom vóór de halvering van Bitcoin. De marktwaarde van Bitcoin wordt verwacht te stijgen na de halvering, en wereldwijde beleggingsstrategieën suggereren om Bitcoin toe te voegen aan bestaande beleggingsportefeuilles. De Bitcoin ETF-markt weerspiegelt dit terwijl het de voortdurende uitstroom van fondsen sinds 12 april beëindigt.</p>
<p>Het bevestigen van het vierde gehalveerde Bitcoinblok is belangrijk in vergelijking met het Bitcoin-netwerk en de gehele crypto-industrie. Door te halveren wordt de voorraad Bitcoin gehalveerd, wat betekent dat de mijnbeloningen voor Bitcoin worden gehalveerd, met als gevolg de inflatie en groeisnelheid van de voorraad van Bitcoin.</p>
<p>Volgens de blockchain-browser lijkt dit gehalveerde blok afkomstig te zijn van de ViaBTC-mijnbouwpool, en mijnwerkers ontvingen een beloning van ongeveer 37,6256 BTC via mijnbouw als betaling voor het verifiëren en verwerken van 3050 transacties in het blok. Dit aantal weerspiegelt de handelsactiviteiten op het Bitcoin-netwerk en het belang van mijnwerkers die eraan bijdragen.</p>
<p>De lancering van de inheemse token van Merlin Chain, MERL, markeert een kritiek moment in de ontwikkeling van het project. Als een belangrijke verbetering van het Bitcoin-netwerk heeft Merlin Chain tot doel de ontwikkeling van gedecentraliseerde applicaties (DApps) te bevorderen, die verschillende gebieden beslaan, waaronder gedecentraliseerde financiën (DeFi), gaming en sociale platforms.</p>
<p>Sinds de lancering in februari 2024 heeft Merlin Chain een explosieve groei doorgemaakt, met een totale waarde opgesloten (TVL) van meer dan $3,6 miljard, en heeft het een levendig ecosysteem geïncubeerd met meer dan 200 inheemse DApps. De lancering van MERL biedt verbeterde governance, beveiliging en ecosysteemontwikkelingsmogelijkheden voor Merlin Chain-gebruikers.</p>
<p>MERL-tokens werken volgens de Bitcoin-compatibele blockchain-standaard BRC-20, met een totale voorraad van 2,1 miljard. Hiervan zal 20% van de totale tokenvoorraad worden uitgedeeld aan deelnemers via het Merlin’s Seal-evenement. Dit evenement liet een indrukwekkende TVL van $3,6 miljard zien, waarvan 91% afkomstig was van de Bitcoin-gemeenschap, waaronder $1,75 miljard aan BTC en $980 miljoen aan BRC-20-activa. De sterke steun van de Bitcoin-gemeenschap is cruciaal geweest voor de snelle groei en uitbreiding van Merlin Chain in de afgelopen maanden.</p>
<p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Het stakingsprotocol Marinade DAO heeft een nieuw voorstel voorgesteld om 50 miljoen MNDE-tokens te ontgrendelen voor de beloningsactiviteit “Marinade Earn Season 3”. Het belangrijkste verschil tussen Seizoen 3 en de vorige Seizoenen 1-2 is dat het zich meer zal richten op het verdiepen van de on-chain liquiditeit van mSOL, een relatieve zwakte van Marinade in het SOL LST-protocol in vergelijking met andere protocollen zoals Jito.</p>
<p>Specifiek stelt het voorstel voor om 25 miljoen MNDEs toe te wijzen door middel van een strategie op Solend te implementeren, waardoor de winstgevendheid van de stakingcyclus van Meteora mSOL/SOL wordt verhoogd in vergelijking met de huidige mSOL-pools (zoals Solend en Kamino) en andere SOL LST’s, waardoor de liquiditeit van mSOL in DeFi wordt verdiept.</p>
<p>Bovendien suggereert het voorstel ook om nog eens 25 miljoen MNDE’s toe te wijzen om het koppelen van bestaande en toekomstige Solana-ecosysteemtokens met mSOL te stimuleren, waardoor mSOL verder in de Solana-economie wordt ingebed en de liquiditeit wordt verdiept.</p>
<h2 id="h2-Markttrends20BTC20heeft20de20halvering20voltooid20en20de20markt20ondervindt20brede20schommelingen36510"><a name="Markttrends: BTC heeft de halvering voltooid en de markt ondervindt brede schommelingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC heeft de halvering voltooid en de markt ondervindt brede schommelingen</h2><p>Afgelopen vrijdagavond daalde Bitcoin kortstondig onder de $60.000, maar nadat het zijn vierde Bitcoin-halvering op zaterdagochtend had voltooid, veerde de prijs op naar $65.000. De algehele cryptomarkt vertoont een breed scala aan schommelingen, en in deze golf van herstel is de Meme-sector het meest actief geweest.</p>
<p>Met betrekking tot macro-economie heeft de Amerikaanse aandelenmarkt een scherpe daling meegemaakt, waarbij Nvidia de grootste daling in vier jaar heeft geboekt. Volgens gegevens die zijn waargenomen door de CME Federal Reserve is de waarschijnlijkheid dat de Fed de rentetarieven in mei ongewijzigd houdt 96,2%, terwijl de kans op een cumulatieve renteverlaging van 25 basispunten 3,8% is.</p>
<h3 id="h3-Markt20Hotspots611860"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Meme sector hersteld: Tijdens het weekend herstelden tokens zoals BONK, PEPE en FLOKI het meest briljant, met een gemiddelde stijging van meer dan 20%. Onder hen stelde BONK een vernietigingsvoorstel voor. Dit is in overeenstemming met eerdere verwachtingen, aangezien tokens in de Meme sector meestal het snelst herstellen na een marktdaling.</p>
<p>Runen en gerelateerde tokens: Inschrijvingen zoals SATS en RATS hebben enige prestaties getoond in de marktherstel, terwijl runestone, de runenleider, is ingestort; de luchtaanvallen hebben de daling niet gedekt. De algehele verwachting voor concurrentiegerelateerde runen is laag, met hoge operationele drempels en on-chain gas kosten, wat heeft geleid tot een groot aantal ontmoedigde gebruikers. Runen stellen projectpartijen in staat om vooraf te ontginnen, wat niet gedecentraliseerd en eerlijk genoeg is, en eerlijkheid is een belangrijk voordeel van de meme-sector.</p>
<p>AI+Depin concept: io.net heeft een integratiesysteem uitgebracht en bevindt zich momenteel in de bètatestfase. Het project is van plan om in de toekomst een airdrop te doen, en investeerders moeten aandacht besteden aan de verdere ontwikkeling en aankondigingen om mogelijke investeringskansen te grijpen.</p>
<p>Over het algemeen, ondanks de volatiliteit van de markt, toont de Meme sector nog steeds een sterke marktmomentum. Na de halvering van de BTC worden er momenteel ongeveer 450 BTC’s per dag geproduceerd. Investeerders moeten macro-economische trends en branchegerelateerd nieuws blijven volgen om tijdige investeringsbeslissingen te kunnen nemen.</p>
<h2 id="h2-Macro20Wall20Streetindex20daalde20op20vrijdag20de20Aziatische20markt20wordt20verwacht20te20herstellen20goud20en20olie20daalden20lichtjes702687"><a name="Macro: Wall Street-index daalde op vrijdag, de Aziatische markt wordt verwacht te herstellen, goud en olie daalden lichtjes" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wall Street-index daalde op vrijdag, de Aziatische markt wordt verwacht te herstellen, goud en olie daalden lichtjes</h2><p>Afgelopen vrijdag sloten de Nasdaq- en S&amp;P 500-indexen lager, maar de Dow Jones-index bleef stabiel, voornamelijk beïnvloed door de kwartaalverslagen van American Express. Het marktsentiment is verder verzwakt door het pessimistische sentiment dat de Federal Reserve mogelijk niet snel de rente zal verlagen.</p>
<p>Goud en veilige haven Amerikaanse dollars zijn gedaald vanaf de hoogtepunten en de prijzen van ruwe olie zijn ook gedaald. Op Wall Street heeft de S&amp;P 500-index zijn langste opeenvolgende daling sinds oktober 2022 geregistreerd. Nvidia in de technologiesector daalde met 10%, waardoor de NASDAQ-index werd meegesleurd, terwijl de vraag naar veilige haven schatkistpapier, goud en Zwitserse franken steeg.</p>
<p>Specifiek steeg de Dow Jones-index met 0,56%, terwijl de S&amp;P 500-index met 0,88% daalde en de Nasdaq-index met 2,05% daalde. De S&amp;P en NASDAQ-indices zijn zes opeenvolgende handelsdagen gedaald en hebben daarmee de langste neerwaartse trend sinds oktober 2022 gezet. Hoewel aandelen gerelateerd aan chips dit jaar een van de best presterende aandelen zijn geworden vanwege hun associatie met kunstmatige intelligentie, is de Philadelphia Semiconductor Index aanzienlijk gedaald.</p>
<p>In de Aziatische markt wordt verwacht dat maandag herstelt van de daling van vorige week, waarbij obligatierendementen stijgen. Echter, vanwege havikachtige opmerkingen van de Federal Reserve, spanningen in het Midden-Oosten en zwakke technologie-aandelen, is het herstel op maandag niet gemakkelijk.</p>
<p>De aandelenkoers van TSMC daalde vrijdag met 6,7% voordat het zijn financieel rapport van het eerste kwartaal vrijgaf. De gegevens en conclusies waren onverwacht, aangezien het bedrijf zijn verwachtingen voor groei in de chipindustrie verlaagde en zijn investeringsplan niet herzag. Ondanks dit verwacht TSMC, als ‘s werelds grootste OEM-chipfabrikant, dat zijn omzet in het tweede kwartaal met maximaal 30% zal groeien, gedreven door de stijgende vraag naar chips in toepassingen voor kunstmatige intelligentie. Bovendien overtrof de winst van TSMC in het eerste kwartaal ook de verwachtingen.</p>
<p>Bij de vroege Aziatische handel op maandag bleven de euro en de yen relatief stabiel, terwijl de Amerikaanse dollar in de buurt bleef van het hoogtepunt na de gespannen beleids- en geopolitieke ontwikkelingen van vorige week. Deze week ligt de focus van de markt op de Japanse yen en de beleidsbeoordeling van de Bank of Japan (BOJ) op vrijdag is een essentieel onderdeel geworden van de economische kalender.</p>
<p>Ondanks het nieuws van de Israëlische aanval steeg de Azië-Pacific aandelenindex met 0,93%, terwijl de Nikkei-index in Japan met 0,48% steeg. Vanwege de hoge concentratie van aandelen in de chipindustrie presteert de Japanse aandelenmarkt echter minder goed dan die van andere regio’s.</p>
<p>Wat betreft grondstoffen zijn de prijzen van ruwe olie gedaald nu handelaren hun aandacht weer richten op de fundamentals. Tegenover een toename van de voorraden in de Verenigde Staten daalden de Brent-ruwe-olie-futures met 54 cent of 0,6% naar $ 86,75 per vat.</p>
<p>Het mei-contract voor ruwe olie van West Texas Intermediate (WTI) loopt maandag af en daalde met 12 cent tot $83,02 per vat. Het actievere junicontract daalde met 47 cent, of 0,6%, tot $81,75 per vat.</p>
<p>De prijs van goud daalde tot $ 2.376,40.</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 beleggingssuggestie.<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 zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>