RGFnZWxpamtzIG5pZXV3c3wgSlBNb3JnYW4gemVndCBkYXQgQlRDIHphbCBkYWxlbiBuYWFyICQ0Mi4wMDA7IFNsZXJmIHZvbHRvb2l0IGVlcnN0ZSByZXN0aXR1dGllIHZhbiAzLjgwMCBTT0w7IEJsYXN0IGdhbWluZyBwcm9qZWN0IHZlcmR1YmJlbHQgZWlnZW4gZm9uZHNlbiB2YW4gZ2VicnVpa2VycyB2YW53ZWdlIGVlbiBtYWFzIGl

2024-03-22, 03:32

<p><img src="https://gimg2.gateimg.com/image/article/17110896441_16.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20JPMorgan20zegt20dat20BTC20zal20dalen20naar204200020Slerf20en20LBank20voltooien20eerste20terugbetaling20van20in20totaal20380020SOL20Blast20Gaming20Project20verdubbelt20eigen20fondsen20van20gebruikers20vanwege20kwetsbaarheid274449"><a name="Crypto Dagelijkse Samenvatting: JPMorgan zegt dat BTC zal dalen naar $42.000; Slerf en LBank voltooien eerste terugbetaling van in totaal 3.800 SOL; Blast Gaming Project verdubbelt eigen fondsen van gebruikers vanwege kwetsbaarheid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: JPMorgan zegt dat BTC zal dalen naar $42.000; Slerf en LBank voltooien eerste terugbetaling van in totaal 3.800 SOL; Blast Gaming Project verdubbelt eigen fondsen van gebruikers vanwege kwetsbaarheid</h2><p>Laten we eerst de handelsactiviteiten van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s onderzoeken. Volgens gegevens van Farside Investor zag de Grayscale Bitcoin Spot ETF (GBTC) op 21 maart uitstroom van $358,8 miljoen; de Fidelity Bitcoin Spot ETF (FBTC) zag instroom van $2,9 miljoen; de Bitwise Bitcoin Spot ETF (BITB) zag instroom van $12 miljoen; en de ARK 21Shares Bitcoin Spot ETF (ARKB) zag instroom van $2 miljoen.</p>
<p>Analysts bij JPMorgan zeiden dat hoewel <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ervoer vorige week een scherpe terugval en herstelde deze week, het blijft echter in ‘overgekochte gebied’, wat suggereert dat het verder kan dalen.</p>
<p>Op de lange termijn is de markt opmerkelijk optimistisch dat de bitcoinprijzen tegen het einde van het jaar zullen stijgen vanwege de verwachting van aanhoudende groei in de vraag naar spot-ETF’s, maar een terugval op korte termijn is onvermijdelijk. Vorige week voorspelden analisten dat de prijs van bitcoin zou kunnen dalen tot ongeveer $42.000 na de halvering, onder andere wijzend op een vermindering van de stimulansen voor miners en stijgende productiekosten.</p>
<p>De analisten concludeerden: ‘Het is waarschijnlijker dat er winst wordt genomen op Bitcoin naarmate de 4e halvering nadert, vooral tegen de achtergrond dat het er nog steeds overbought uitziet ondanks de correctie van de afgelopen week.’</p>
<p>De memecoin Slerf op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> is veel besproken omdat de ontwikkelaar per ongeluk tokens heeft verbrand terwijl ze zeiden dat ze de deelnemers zouden terugbetalen. Slerf en het LBank-team bundelden hun krachten om in 24 uur bijna 4.000 <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> (SOL) in te zamelen. Volgens on-chain gegevens is 3.800 daarvan terugbetaald aan kleine gebruikers die deelnamen in de vroege stadia van de donatie van Slerf.</p>
<p>Op dit moment zijn de voorverkoopdonaties voor Slerf nog steeds gaande. Het Slerf-team heeft gezegd dat ze luchtdalingsbeloningen zullen geven aan gebruikers nadat de donatie is afgerond, maar de inhoud van de luchtdaling is nog niet aangekondigd.</p>
<p>Het ‘voorverkoopdonatiemodel’ heeft de activiteit van meme-projecten gestimuleerd, maar heeft ook tot chaos geleid. Zo voegde het project ‘OrbitX’ op MerlinChain LP toe aan het grootste deel van de fondsenwerving en werd het aandeel van de airdroptokens verlaagd tot 2,5%. Echter, slechts twee uur na de opening van de handelssessie, haalde het projectadres alle fondsen uit de LP-pool en annuleerde het X-platformaccount, waardoor de waarde van de tokens tot nul werd teruggebracht.</p>
<p>Tot slot, een project op het Blast-netwerk - een Telegram-spel genaamd Super <a href="/price/sushi-sushi" rel="nofollow noopener noreferrer" target="_blank">Sushi</a> De Samurai - werd aanglen door misbruik te maken van een kwetsbaarheid. Een slim contractontwikkelaar bij Yuga Labs wees erop dat er een bug zat in het contract voor de token SSS. Als een gebruiker het volledige saldo van zijn portemonnee naar zichzelf overmaakte, dan zou hun fondsen verdubbeld worden.</p>
<p>De aanvallers maakten hier gebruik van en verkochten de nieuw geslagen tokens voor 1.310 verpakte Ether, waarbij ze die fondsen gebruikten om liquiditeit uit de gedecentraliseerde exchange te halen. Dit resulteerde in een verlies van $4,6 miljoen voor het project tegen de heersende prijs.</p>
<p>Er was nog steeds een onverwacht vervolg op dit verhaal. Het project zei dat de aanvallers contact met hen hadden opgenomen en dat het een white hat hack was. De andere partij heeft contactgegevens verstrekt en zei dat gebruikers gecompenseerd moeten worden. Projectfunctionarissen zijn gecontacteerd op Blockscan en kunnen een samenwerking aangaan om het probleem op te lossen.</p>
<h2 id="h2-Marktanalyse20De20brede20markttrend20blijft20schokken20ondergaan20altcoins20daalden20over20het20algemeen99695"><a name="Marktanalyse: De brede markttrend blijft schokken ondergaan, altcoins daalden over het algemeen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktanalyse: De brede markttrend blijft schokken ondergaan, altcoins daalden over het algemeen</h2><p>Onlangs heeft de verwachting van een renteverlaging door de Fed invloed gehad op de markttrend, en de algemene trend laat een aanpassing zien na een scherpe opleving.</p>
<p>In het proces vertoonden de Altcoins als geheel een algemeen dalend patroon, terwijl de bitcoin spot ETF nettostroom vertoonde gedurende vier opeenvolgende handelsdagen, wat wijst op een voorzichtige sentiment van investeerders. Ondertussen stegen Amerikaanse aandelen en bleven ze nieuwe recordhoogtes bereiken, wat enkele optimistische signalen voor de markt bood, maar we moeten voorzichtig zijn met mogelijke schokken op hoog niveau.</p>
<h3 id="h3-Markt20Hot20Spots194387"><a name="Markt Hot Spots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hot Spots:</h3><ol>
<li><p>De toetreding van het BlackRock-fonds tot RWA baart zorgen: Het nieuws over de toetreding van het BlackRock-fonds tot het tokenisatiefonds blijft gisten op de markt, wat heeft geleid tot een stijging van concepttokens zoals RSR en TRU. Bovendien zijn ook POLYX, MKR, ONDO en andere tokens gestegen, waarbij ONDO zelfs gisteren een recordhoogte bereikte, met meer dan 50% op één dag. Deze reeks rally’s toont aan dat de markt optimistisch is over de toetreding van instellingen zoals BlackRock, maar we moeten ook waakzaam zijn voor de risico’s van overmatige speculatie.</p>
</li><li><p>Meme Concept Rebound: De meme concept token BOME herstelde scherp en wisselde vaak van eigenaar nadat het online was gegaan op grootschalige beurzen. Volgens de gegevens van de Chain Browser is het totale aantal BOME dat op het CEX-adres wordt aangehouden meer dan 50%. Tegelijkertijd is BOME-oprichter Darkfarm van plan een nieuw inschrijvingsproject uit te geven, waarvan de opbrengsten zullen worden gebruikt om de vernietigde BOME terug te kopen, een reeks ontwikkelingen die het sentiment op de markt ten opzichte van BOME nieuw leven hebben ingeblazen.</p>
</li><li><p>Duikprotocol Sociaal Concept: Sociaal Concept Protocol ID heeft een grote daling ondergaan en de organisatie heeft ontgrendeld en begon te verzenden. Dit is een typische ontgrendeling vóór het verzenden van het bordgedrag, vergelijkbaar met het recente gedrag van APT, ARB, enz. Dit suggereert dat sommige marktbeleggers ervoor hebben gekozen om hun bezittingen te verkopen voordat ze ontgrendelen, hetzij vanwege zorgen over toekomstige waarde of om geld op te nemen. Dit fenomeen is zorgwekkend en kan de prijsprestaties van de relevante tokens beïnvloeden.</p>
</li></ol>
<p>Over het algemeen bevindt de markt zich nog steeds in een fase van aanpassing en moeten investeerders voorzichtig blijven en nauwlettend letten op de ontwikkeling van elke hete markt, terwijl ze hun risico onder controle houden om mogelijk volatiliteit het hoofd te bieden.</p>
<h3 id="h3-Macro20Wereldwijde20markten20stijgen20als20Wall20Street20sluit20op20hoog20niveau20vanwege20vooruitzicht20op20renteverlaging20chipaandelen20leiden20winsten20Apple20aangeklaagd20wegens20monopolie431088"><a name="Macro: Wereldwijde markten stijgen als Wall Street sluit op hoog niveau vanwege vooruitzicht op renteverlaging; chipaandelen leiden winsten, Apple aangeklaagd wegens monopolie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wereldwijde markten stijgen als Wall Street sluit op hoog niveau vanwege vooruitzicht op renteverlaging; chipaandelen leiden winsten, Apple aangeklaagd wegens monopolie</h3><p>Na de Federal Reserve de Amerikaanse rentetarieven tussen 5,25% en 5,5% hield, zei Powell dat recente hoge inflatiegegevens het onderliggende beeld van langzaam afnemende prijsdruk niet hebben veranderd, en hij bevestigde dat de economie op een solide tempo zal blijven groeien.</p>
<p>De marktprijzen weerspiegelen nu de verwachtingen dat de Fed en de ECB hun rentetarieven zullen verlagen tijdens hun vergaderingen in juni. Amerikaanse schatkistrendementen daalden bij aanvang van de handel en stegen vervolgens weer als gevolg van een daling in wekelijkse initiële werkloosheidsaanvragen en een positief rapport over de inkoopmanagersindex van de industrie.</p>
<p>Op donderdag bereikten de drie belangrijkste aandelenindexen van Wall Street voor de tweede opeenvolgende dag nieuwe hoogtepunten na geruststellende opmerkingen van de Federal Reserve over mogelijke renteverlagingen later dit jaar. Ondertussen stegen de aandelen van chipfabrikant Micron Technology na een positieve voorspelling.</p>
<p>Apple Inc. werd aangeklaagd door het Amerikaanse ministerie van Justitie omdat het naar verluidt ‘monopolie’ heeft op de smartphonemarkt. Dit is de eerste grote antitrustrechtszaak van de regering Biden tegen het bedrijf, waardoor het met 4,1 procent daalde ten opzichte van de markt.</p>
<p>Aziatische aandelen naderden wekelijkse winsten op vrijdag, met de Nikkei die een recordhoogte bereikte, en wereldwijde aandelen stegen nadat een verrassende renteverlaging door de centrale bank van Zwitserland beleggers liet speculeren wie de volgende zou kunnen zijn om de rente te verlagen. De Zwitserse centrale bank verlaagde de rente met 25 basispunten op donderdag, wat het vertrouwen in het wereldwijde risicosentiment vergrootte omdat de markten wedden dat grote centrale banken dit jaar de leenkosten zullen verlagen, waardoor Wall Street op een recordhoogte werd afgesloten.</p>
<p>De Dow Jones Industrial Average (.DJI) steeg met 269,24 punten, of 0,68%; de Standard &amp; Poor’s 500 Index (.SPX) steeg met 16,9 punten, of 0,32%; en de Nasdaq Composite Index (.IXIC) steeg met 32,43 punten, of 0,2%.</p>
<p>Japan’s Nikkei (.N225) en de Taiwan Weighted Index (.TWII) stegen beide met 2% naar recordhoogtes, terwijl de MSCI Global Equity Index (.MIWD00000PUS) met 5,28 punten of 0,68% steeg.</p>
<p>Op de grondstoffenmarkt daalden de prijzen van Brent ruwe olie met 43 cent tot $85,35 per vat, terwijl de prijzen van Amerikaanse ruwe olie met 41 cent daalden tot $80,66 per vat.</p>
<p>Wat betreft de goudprijs, raakte spotgoud donderdag een nieuw recordhoogte voordat het met 0,28% daalde tot $2.174,89 per ounce.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Sherry S. &amp; Icing.</strong>, Gate.io-onderzoeker<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 op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>