RGFnZWxpamtzIE5pZXV3cyB8IENyeXB0by1pbnZlc3RlcmluZyBiZXJlaWt0IGhvb2dzdGUgcHVudCBpbiAxOCBtYWFuZGVuOyBCbGFzdCBsYW5jZWVyZGUgZGUgQmxhc3QgQm9udXMtZnVuY3RpZTsgVGV0aGVyIHdlcmQgZGUgN2UgZ3Jvb3RzdGUgaG91ZGVyIHZhbiBCVEM=

2024-04-02, 03:25

<p><img src="https://gimg2.gateimg.com/image/article/17120282211_3.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Cryptoinvesteringen20bereikten20een20hoogtepunt20van201820maanden20Blast20lanceerde20de20Blastbonusfunctie20Tether20verwierf20888820BTCs20en20werd20de20op20720na20grootste20houder97594"><a name="Crypto Dagelijkse Samenvatting: Crypto-investeringen bereikten een hoogtepunt van 18 maanden; Blast lanceerde de Blast-bonusfunctie; Tether verwierf 8888 BTC’s en werd de op 7 na grootste houder" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Crypto-investeringen bereikten een hoogtepunt van 18 maanden; Blast lanceerde de Blast-bonusfunctie; <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> verwierf 8888 BTC’s en werd de op 7 na grootste houder</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 zijn op 6 maart Grayscale’s GBTC-fondsen blijven <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flow</a> aanzienlijk gedaald, met een totaal van $302,6 miljoen; Ondertussen heeft het Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) een instroom van $44 miljoen, heeft het Bitwise Bitcoin spot ETF (BITB) een instroom van $1,1 miljoen, en heeft het ARK 21Shares Bitcoin spot ETF (ARKB) een uitstroom van $300.000.</p>
<p>Vanwege een grote hoeveelheid vroege investeringen in blockchain-gerelateerde ondernemingen in maart, bereikte het financieringsbedrag van crypto-bedrijven het hoogste niveau in 18 maanden.</p>
<p>Volgens The Block Deals Dashboard overschrijdt de nieuwe financiering voor crypto bedrijven $1.4 miljard. Dit maakt maart de beste maand sinds september 2022, toen de industrie meer dan $2 miljard aan fondsen wist binnen te halen.</p>
<p>John Dantoni, Research Director van The Block, verklaarde dat maart een iconische maand is, mede dankzij een stijging in vroege fase of A-ronde investeringen. Dandongni merkte op dat er deze maand meer dan 20 vroege investeringen waren, een aanzienlijke stijging ten opzichte van februari, met negen van dergelijke investeringen in februari, vergelijkbaar met het maandelijkse gemiddelde van vorig jaar.</p>
<p>Deze stijgingen zijn nauw verbonden met de stijging van de Bitcoin-prijzen. In de komende maanden kunnen er meer fondsen via durfkapitalisten in crypto-projecten worden gestoken. Zo werd donderdag bijvoorbeeld gemeld dat Marc Andreessen, Accolade Partners en Galaxy Digital hebben geïnvesteerd in het nieuwste fonds van het crypto-venture capital firm 1kx, dat $ 75 miljoen heeft opgehaald.</p>
<p>Blast heeft aangekondigd op het X-platform dat het officieel de Blast-bonusfunctie heeft gelanceerd, waardoor gebruikers hun Blast-punten kunnen verhogen door te handelen op specifieke spot- of eeuwigdurende contractbeurzen. Door met succes punten toe te voegen, kan het saldo en rendement van de gebruiker permanent toenemen. Met behulp van een specifieke DApp kunt u een puntbonus verdienen zonder enige transactiebedragbeperkingen. Bovendien kunnen gebruikers ook puntenbonussen delen tussen verschillende wallets, wat betekent dat ze puntenbonussen kunnen verdienen via hot wallets en deze kunnen toepassen op de hoofdwallet.</p>
<p>Het moet worden opgemerkt dat veiligheid altijd de hoogste prioriteit heeft bij interactie met een DApp, inclusief bij interactie met de specifieke integrale plus DApp gespecificeerd door Blast.</p>
<p>Voor het omwisselen van punten in mei zal Blast in totaal 12-punten bonussen lanceren. Gebruikers moeten ervoor zorgen dat ze alle puntenbonussen verzamelen voordat ze punten omwisselen in mei. Gebruikers kunnen nu de eerste twee puntenbonussen verkrijgen door toegang te krijgen tot de Blast airdrop pagina, en er zullen binnenkort meer bonussen worden vrijgegeven.</p>
<p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> heeft onlangs een overname gedaan om de Bitcoin-reserves te vergroten. Door 8.888 Bitcoin te verwerven, werd Tether de op zeven na grootste Bitcoin-houder. Volgens het bedrijf zijn ze van plan om 15% van hun nettowinst te investeren in Bitcoin om diversificatie van stablecoin-ondersteunde activa te bereiken.</p>
<p>Op 4 maart heeft de marktwaarde van Tether’s USDT een recordhoogte van $100 miljard bereikt, een stijging van 9% tot nu toe dit jaar. Tether heeft ook aangekondigd dat de succesvolle afronding van de  and Organizational Control 2 (SOC) audit, de hoogste audit voor beveiligingsnaleving die een organisatie kan aantonen, ontwikkeld door het American Institute of Certified Public Accountants (AICPA).</p>
<p>Tether CEO Paolo Ardoino schreef op 1 april dat de audit benadrukte dat Tether zich toelegt op het bieden van een veilige gebruikerservaring: “Deze nalevingsmaatregel zorgt ervoor dat onze klanten erop kunnen vertrouwen dat hun activa en gegevens worden beheerd in een omgeving die voldoet aan de hoogste normen voor gegevensbescherming en informatiebeveiliging. Onafhankelijke verificatie van deze beveiligingscontrole is cruciaal voor Tether en toont ons streven om ‘s werelds meest vertrouwde en conforme stablecoin te worden.”</p>
<h2 id="h2-Markttrends20De20verwachting20van20een20renteverlaging20van20de20Federal20Reserve20in20juni20wordt20verwacht20af20te20nemen20en20de20markt20stort20in117776"><a name="Markttrends: De verwachting van een renteverlaging van de Federal Reserve in juni wordt verwacht af te nemen en de markt stort in." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De verwachting van een renteverlaging van de Federal Reserve in juni wordt verwacht af te nemen en de markt stort in.</h2><p>Gisteren maakte BTC een aanzienlijke daling mee tot dicht bij de $68.000 grens, wat leidde tot een algemene daling in Altcoins. Op macro-economisch gebied is de prestatie van de Amerikaanse aandelenmarkt gemengd geweest en is de waarschijnlijkheid van de eerste renteverlaging in juni gedaald tot minder dan 50% als gevolg van de positieve impact van de Amerikaanse productiedata.</p>
<h3 id="h3-Markt20Hotspots126799"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>GHST van de Gamefi-sector is gestegen: Het GHST-project kondigde een verschuiving aan naar Base Chain-ontwikkeling Layer 3, waardoor de prijzen aanzienlijk stegen.</p>
<p>Het concept van Meme zag een aanzienlijke stijging in BOME: BOME zag een dagelijkse stijging van meer dan 20%, terwijl andere Meme-tokens op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> kettingzaag een basis pullback. De markt is nog steeds enthousiast over het hypen van nieuwe munten in populaire concept tokens, waarbij de trend van ‘speculeren op nieuw in plaats van oud’ wordt gevolgd.</p>
<p>Het BTC-ecosysteem daalt over het algemeen: Projecten in het BTC-ecosysteem ervaren over het algemeen een daling, waarbij ORDI met meer dan 10% keldert. Ondertussen was de gebruikerservaring van BTC’s Layer2-oplossing lager dan verwacht. Er zijn nog geen 20 dagen verstreken sinds het BTC-halveringsevenement en de markt neemt een afwachtende houding aan.</p>
<p>Cross-chain bridge Wormhole protocol airdrop: Het Wormhole-protocol zal vanavond om 11:30 (UTC) token W openen voor airdrop-ophaalactie, nadat Gate.io de lancering van de token heeft aangekondigd. De laatste financieringsronde van Wormhole wordt gewaardeerd op $2,5 miljard, en de investeringsinstelling is zeer luxueus, wat de aandacht van de markt heeft getrokken.</p>
<p>Over het algemeen bestrijken markthotspots de Gamefi-sector, het Meme-concept, het BTC-ecosysteem en de dynamiek van het cross-chain brug Wormhole-protocol. Investeerders moeten deze hete onderwerpen nauwlettend in de gaten houden en op tijd hun investeringsstrategieën aanpassen op basis van marktomstandigheden, en voorzichtig reageren op marktfluctuaties.</p>
<h2 id="h2-Macro20Het20afnemen20van20het20optimisme20over20renteverlagingen20kan20invloed20hebben20op20de20wereldwijde20aandelenmarkten20waarbij20de20goudprijzen20een20historisch20hoogtepunt20bereiken699995"><a name="Macro: Het afnemen van het optimisme over renteverlagingen kan invloed hebben op de wereldwijde aandelenmarkten, waarbij de goudprijzen een historisch hoogtepunt bereiken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Het afnemen van het optimisme over renteverlagingen kan invloed hebben op de wereldwijde aandelenmarkten, waarbij de goudprijzen een historisch hoogtepunt bereiken</h2><p>De meeste wereldwijde markten zijn gesloten op vrijdag, terwijl Europese markten gesloten zijn op maandag. Op Wall Street daalde de Dow Jones Industrial Average (.DJI) met 0,6%, de Standard &amp; Poor’s 500 Index (.SPX) daalde met 0,20%, maar de Nasdaq Composite Index (.IXIC) steeg met 0,11%.</p>
<p>De goudprijzen bereikten een historisch hoogtepunt en de aandelen op Wall Street sloten gemengd, omdat sterke economische gegevens uit de VS de markt temperden <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> over de komende renteverlaging van de Federal Reserve, waardoor mensen zo snel mogelijk gaan bezuinigen. Op vrijdag verklaarde de voorzitter van de Federal Reserve, Jerome Powell, dat de inflatiegegevens die die dag werden vrijgegeven ‘aan onze verwachtingen voldeden’ en ‘je zult ons niet overreageren zien’, wat aangeeft dat de Federal Reserve bereid is om zijn afwachtende houding voort te zetten.</p>
<p>Op dinsdag stegen de Aziatische aandelenmarkten, versterkte de Amerikaanse dollar en bleef de wisselkoers van de yen ten opzichte van de dollar rond de 152 yen per dollar. Handelaren beginnen zich zorgen te maken over mogelijke interventie, aangezien de marktverwachtingen voor de aanstaande renteverlaging van de Fed afzwakken.</p>
<p>De gegevens van maandag toonden aan dat de Amerikaanse maakindustrie voor het eerst in 1- groei doormaakte.1⁄2jaren, met een aanzienlijk herstel in de productie en een toename van nieuwe orders, waardoor de economische kracht benadrukt wordt en twijfels rijzen over het tijdstip van de renteverlaging van de Federal Reserve. Sterke productiegegevens hebben het rendement van Amerikaanse staatsobligaties verhoogd, en het rendement van tweejarige en tienjarige staatsobligaties steeg naar twee weken hoogtepunten, waardoor de Amerikaanse dollar werd versterkt.</p>
<p>Ondanks het wereldwijde economische optimisme leidt de Chinese aandelenmarkt het grootste deel van Azië. Gegevens tonen aan dat de Amerikaanse maakindustrie voor het eerst sinds september 2022 groei heeft doorgemaakt en de Amerikaanse dollar is ook dienovereenkomstig gestegen. De S&amp;P 500-index overtrof ‘s nachts de verwachtingen nadat sterke productiegegevens de Amerikaanse schatkistrendementen hoger duwden.</p>
<p>Echter, markt zorgen over het tijdstip van renteverlagingen sleepten de eerste handelsdag van het tweede kwartaal naar beneden, resulterend in een rustige toon op de markt. Het is het vermelden waard dat de index zijn grootste procentuele stijging in vijf jaar behaalde in het eerste kwartaal.</p>
<p>Met betrekking tot grondstoffen steeg Amerikaanse ruwe olie met 0,3% tot $83,96 per vat, gedreven door tekenen van verbeterde vraag en escalerende spanningen in het Midden-Oosten, terwijl Brent-ruwe olie met 0,34% steeg tot $87,72.</p>
<p>De goudprijs daalde met 0,1% tot $2.248 per ounce en bereikte op maandag een historisch hoogtepunt van $2.265,49.</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 visie van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>