RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBoZXJzdGVsZGUgemljaCB0b3QgJDY1SyBuYSBlZW4gc2NoZXJwZSBkYWxpbmc7IEwxIEJsb2NrY2hhaW4gQmVyYWNoYWluIGhhYWxkZSAkMTAwTSBvcCBpbiBmaW5hbmNpZXJpbmdzcm9uZGUgQjsgRXRoZXJldW0gUGVjdHJhIFVwZ3JhZGUgYnJlbmd0ICdTbGltbWUgQ29udHJhY3Rwb3J0ZW1vbm5

2024-04-15, 03:45

<p><img src="https://gimg2.gateimg.com/image/article/171315265215.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20herstelde20tot2065K20na20een20val20L120blockchain20Berachain20haalde2010020miljoen20op20in20serie20Bfinanciering20Ethereum20Pectra20Upgrade20Brengt20Slim20Contract20Portemonnee882200"><a name="Crypto Dagelijkse Samenvatting: BTC herstelde tot $65K na een val; L1 blockchain Berachain haalde $100 miljoen op in serie B-financiering; Ethereum Pectra Upgrade Brengt “Slim Contract Portemonnee”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC herstelde tot $65K na een val; L1 blockchain Berachain haalde $100 miljoen op in serie B-financiering; <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Pectra Upgrade Brengt “Slim Contract Portemonnee”</h2><p>Laten we eerst de handelsactiviteit van onderzoeken. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor bedroegen op 12 april de uitstroom van Grayscale’s <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (GBTC) $166,2 miljoen en de instroom van fondsen van iShares Bitcoin spot ETF (IBTC) $111,1 miljoen.</p>
<p>De prijs van Bitcoin is de afgelopen twee dagen sterk fluctueerd, wat ook invloed heeft gehad op de trend van de meeste Altcoins. Op 14 april zakte Bitcoin onder de $63.000, maar herstelde snel en wordt nu gerapporteerd op $65.067,54.</p>
<p>De markt neergang gedomineerd door Bitcoin kan te wijten zijn aan de volgende belangrijkste redenen:<br>De Bitcoin halvering brengt een halvering van blok beloningen met zich mee, aangezien de stijgende kosten van mijnwerkers de aanbodsdruk zullen verhogen en de prijzen verlagen. In de recente cryptomarkt zullen meer mensen geneigd zijn om winst te maken.<br>De vermindering van de liquiditeit van de Amerikaanse dollar werd veroorzaakt door de vermindering van het balanstotaal van de Federal Reserve.</p>
<p>Framework Ventures en Brevan Howard Digital (BH Digital) Abu Dhabi hebben gezamenlijk $100 miljoen aan serie B-financiering geleid voor Layer 1 blockchain-ontwikkelaar Berachain.</p>
<p>Berachain is een modulaire Layer 1 blockchain gebaseerd op het consensusmechanisme ‘proof of liquidity’, dat de beschikbare liquiditeit van bepaalde activa op de keten verifieert en compatibel is met <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> virtuele machines. Berachain heeft gouvernementstokens BGT, gastokens BERA, en een inheemse consensus onderpand-stabiele munt HONEY.</p>
<p>Gebruikers kunnen BGT verkrijgen door specifieke taken uit te voeren binnen het Layer 1-ecosysteem, zoals het verschaffen van liquiditeit op de gedecentraliseerde exchange van Berachain, of kunnen BGT omwisselen voor HONEY gekoppeld aan Amerikaanse dollars en BERA gebruiken om handelskosten te betalen.</p>
<p>Het bedrijf is van plan deze fondsen te gebruiken ter ondersteuning van uitbreiding in Hong Kong, Singapore, Zuidoost-Azië, Latijns-Amerika en Afrika. Het voegt eraan toe dat het testnetwerk van Berachain al meer dan 100 miljoen transacties heeft verwerkt. Investeerders gebruiken de Simple Agreement for Future Tokens (SAFT) om fondsen te verstrekken voor Berachain.</p>
<p>Eerder, in april 2023, haalde Berachain $42 miljoen op aan privé-tokenfinanciering onder leiding van Polychain Capital.</p>
<p>Ontwikkelaars van Ethereum hebben aangegeven dat EIP-3074 is opgenomen in de volgende upgrade van Ethereum, die ‘wallet smart contracting’ zal ondersteunen. Deze upgrade staat gepland voor de ‘Pectra upgrade’, die later dit jaar kan plaatsvinden.</p>
<p>EIP-3074 heeft de gebruikerservaring van de portemonnee verbeterd door functies toe te wijzen aan slimme contracten. Zo is het bijvoorbeeld mogelijk om tegelijkertijd veel transacties goed te keuren, verschillende ERC20-tokens te gebruiken om gas te betalen, de beveiliging te verbeteren of accounts te herstellen.</p>
<p>Echter wezen ontwikkelaars er ook op dat EIP-3074 mogelijk een nieuw risico met zich meebrengt. Een enkele kwaadwillige transactie kan een gebruikers volledige portemonnee uitputten door middel van bulktransacties. Professionele analisten zijn echter van mening dat een goed ontworpen portemonnee kan helpen om potentiële risico’s te elimineren.</p>
<h2 id="h2-Markttrends20de20markt20herstelde20zich20na20een20scherpe20neergang20waarbij20de20AI20en20Memesectoren20een20uitstekende20prestatie20lieten20zien896516"><a name="Markttrends: de markt herstelde zich na een scherpe neergang, waarbij de AI- en Meme-sectoren een uitstekende prestatie lieten zien." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: de markt herstelde zich na een scherpe neergang, waarbij de AI- en Meme-sectoren een uitstekende prestatie lieten zien.</h2><p>Na de marktcrash van vrijdag herstelde de markt, waardoor de BTCD (Bitcoin marktwaarde ratio) steeg naar een nieuw hoogtepunt in bijna vier jaar. De sterkste herstelsectoren zijn nog steeds de eerder sterke concepten van AI, Meme en RWA (tastbare wereldactiva).</p>
<p>Op macro-economisch gebied kende de Amerikaanse aandelenmarkt een aanzienlijke daling, terwijl de Amerikaanse dollarkoers een nieuw hoogtepunt bereikte in bijna een half jaar.</p>
<h3 id="h3-Markt20Hotspots205375"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>AI-sector: Tokens in de kunstmatige intelligentie sectoren zoals TAO, AGIX, RNDR en WLD zijn aanzienlijk toegenomen. De AI-sector was de eerste die steeg en de aanpassingsfase inging in de vorige markttrend, en presteerde goed bij het herstel na de marktcrash.</p>
<p>Memesector: Prijzen van tokens in memesectoren zoals SLERF, MEW en WIF zijn ook aanzienlijk gestegen. De kenmerken van de memesector zijn een grote circulatie van chips en een hoge omzet in de markt.</p>
<p>RWA sector: Tokens in RWA-sectoren zoals TRU, ONDO en PENDLE zijn ook aanzienlijk toegenomen. Door het toetreden van BlackRock tot tokenfondsen hebben de tokens in de RWA-sector de laatste tijd een sterke prestatie laten zien, niet alleen relatief bestand tegen dalingen op dalende markten, maar ook aanzienlijke winsten op stijgende markten.</p>
<p>Multi-Sign Wallet Safe problemen met tokens: Multi-Sign Wallet Safe staat op het punt om SAFE-tokens uit te geven, en er is gemeld dat Ethereum-oprichter Vitalik Buterin $700 miljoen heeft gestort in de Safe Wallet. Dit nieuws kan de aandacht van de markt naar zijn tokens trekken.</p>
<p>Over het algemeen herstelde de markt zich na een scherpe daling op vrijdag, maar de Amerikaanse aandelenmarkt daalde sterk en de Amerikaanse dollarkoers bereikte een nieuw hoogtepunt. Wat betreft markthotspots, hebben tokens in de AI-, Meme- en RWA-sectoren een uitstekende prestatie laten zien, en investeerders moeten de markttrends nauwlettend volgen en hun beleggingsstrategieën nauwkeurig aanpassen.</p>
<h2 id="h2-Macro20De20spanning20in20het20MiddenOosten20stimuleert20een20golf20van20risicoaversie20waarbij20de20aandelenmarkten20dalen20en20de20goudprijzen20stijgen345481"><a name="Macro: De spanning in het Midden-Oosten stimuleert een golf van risicoaversie, waarbij de aandelenmarkten dalen en de goudprijzen stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De spanning in het Midden-Oosten stimuleert een golf van risicoaversie, waarbij de aandelenmarkten dalen en de goudprijzen stijgen</h2><p>De afgelopen weken zijn de zorgen over inflatie toegenomen en dit heeft geleid tot onzekerheid op de markt. De spanningen in het Midden-Oosten hebben gezorgd voor een sterke vraag naar veilige haven activa zoals de Amerikaanse dollar, goud en Amerikaanse staatsobligaties, en de wereldmarkt is gedaald. Naast de aandelenmarkt heeft dit ook geleid tot een historisch hoogtepunt voor goud. Tegelijkertijd hebben energie-aandelen ook een krachtige groei doorgemaakt.</p>
<p>Op vrijdag 12 april vond er een verkoopgolf plaats op de Amerikaanse aandelenmarkt, waarmee een week werd afgesloten die werd gekenmerkt door volatiele inflatiegegevens, veranderingen in de verwachtingen voor het beleid van de Federal Reserve en dreigende geopolitieke spanningen.</p>
<p>De drie belangrijkste indexen daalden allemaal met meer dan 1%, waarbij de Dow Jones met 1,24% daalde, de S&amp;P met 1,46% daalde en de Nasdaq met 1,62% daalde.</p>
<p>Na de door winst gedreven beurscrash van Bank of America is het beleggerssentiment negatief geworden. De aandelenprijs van JPMorgan Chase daalde het meest in bijna vier jaar, terwijl de wereldwijde aandelenmarkten hun grootste daling in zes maanden meemaakten. Tegelijkertijd zijn energie-aandelen in de VS echter gestegen, wat investeerders ten goede komt door stijgende olieprijzen en een sterker dan verwachte economische prestatie, terwijl ze ook proberen hun beleggingsportefeuilles te beschermen tegen de impact van inflatie.</p>
<p>Er wordt voorspeld dat de energiesector van de S&amp;P 500-index tegen 2024 met ongeveer 17% zal stijgen, wat ongeveer twee keer zo groot is als de algehele index. In de afgelopen weken is de groei van de energiesector versneld en is het een van de best presterende sectoren geworden in de S&amp;P 500-index in de afgelopen maand.</p>
<p>Olieprijzen zijn een van de belangrijkste drijfveren: als gevolg van de onverwacht sterke prestaties van de Amerikaanse economie en zorgen over de escalatie van conflicten in het Midden-Oosten, is de Amerikaanse ruwe olie dit jaar met 20% gestegen.</p>
<p>Sommige investeerders geloven dat de stijging van energieaandelen kan dienen als een bescherming tegen inflatoire druk in de Verenigde Staten. Dit jaar zijn de consumentenprijzen als inflatie-indicator hardnekkiger gestegen dan verwacht, wat mogelijk de marktverwachtingen voor de renteverlaging van de Federal Reserve in 2024 heeft verzwakt en een zekere remmende invloed op de aandelenmarkt heeft gehad.</p>
<p>Op maandag zal de Aziatische markt conservatief openen, waarbij de Nikkei-index van Japan met meer dan 1% daalt, de S&amp;P/ASX 200-index van Australië met 0,6% daalt en de Hang Seng-index van Hong Kong met 0,8% daalt.</p>
<p>Op 12 april stegen de goudprijzen boven de $2.400 per ounce, waarmee ze een historisch hoogtepunt bereikten en hun vierde week van winsten ingingen. De spanningen in het Midden-Oosten namen toe, waardoor beleggers op zoek gingen naar veilige haven activa.</p>
<p>Spot goud bereikte een historisch hoogtepunt van $2.419,79 en daalde met 0,8% tot $2.353,35 per ounce. De prijs is deze week met ongeveer 1% gestegen. Amerikaanse goud futures stegen met 0,1% tot $2.374,1.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen nauwelijks veranderd, aangezien handelaren de Iraanse vergeldingsaanvallen grotendeels hebben verwerkt. Brent ruwe olie futures daalden met 0,5% tot $90,01 per vat, terwijl West Texas medium ruwe olie futures in de Verenigde Staten ongeveer 0,6% daalden tot $85,13 per vat.</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 standpunten van de onderzoeker en vormt geen beleggingsaanbevelingen.<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>