RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBvdmVyc2NocmlqZHQgb3BuaWV1dyAkNzBLOyBQYXJhU3dhcCByZXBhcmVlcnQga3dldHNiYWFyaGVkZW4gZW4gZ2VlZnQgZ2VicnVpa2Vyc211bnRlbiB0ZXJ1ZzsgQXZhbGFuY2hlIHdlcmt0IHNhbWVuIG1ldCBBTlogQmFuayB2b29yIG9uLWNoYWluIGFjdGl2YS1hZndpa2tlbGluZw==

2024-03-26, 04:06

<p><img src="https://gimg2.gateimg.com/image/article/17114259461_18.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20breekt20opnieuw20door20de207000020ParaSwap20verhelpt20kwetsbaarheden20en20geeft20gebruikersmunten20terug20Avalanche20werkt20samen20met20Chainlink20voor20onchain20activaverrekening20in20Australi732983"><a name="Crypto Dagelijkse Samenvatting: BTC breekt opnieuw door de $70.000; ParaSwap verhelpt kwetsbaarheden en geeft gebruikersmunten terug; Avalanche werkt samen met Chainlink voor on-chain activaverrekening in Australië" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC breekt opnieuw door de $70.000; ParaSwap verhelpt kwetsbaarheden en geeft gebruikersmunten terug; <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> werkt samen met Chainlink voor on-chain activaverrekening in Australië</h2><p>Allereerst laten we de handelsactiviteiten van onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens Farside Investor-gegevens hebben de GBTC-fondsen van Grayscale op 25 maart doorgelopen. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Vloeien</a> Daarentegen daalde de instroom van de Bitcoin-futures ETF van ProShares (BITO) aanzienlijk tot $350,1 miljoen. Ondertussen was de instroom van de Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) $261,8 miljoen en de instroom van de Bitwise Bitcoin spot ETF (BITB) $14 miljoen.</p>
<p>Bitcoin keerde op 25 maart terug naar het niveau van $70.000 en bereikte een hoogtepunt van 9 dagen. Deze opwaartse trend heeft de verliezen van de vorige week goedgemaakt, waardoor handelaren twijfelen of het een nieuwe historische hoogte zal bereiken. De markt voor spot Bitcoin ETF’s wordt gedomineerd door een uitstroom van $2 miljard aan fondsen uit GBTC, waarbij de uitstroom voor het eerst in 7 weken de instroom overtreft. Ondanks deze uitstroom van fondsen zijn de instromen voor spot Bitcoin ETF’s deze week met $1,1 miljard toegenomen.</p>
<p>Volgens gegevens van CoinShares hebben institutionele beleggers in 2024 $12,3 miljard geïnvesteerd in de cryptosector. Wat de achtergrond betreft, registreerden cryptoproducten in 2021 een jaarlijkse instroom van $ 10,6 miljard.</p>
<p>De DeFi-aggregator ParaSwap heeft vorige week een kritische kwetsbaarheid opgelost in het onlangs gelanceerde Augustus V6 smart contract en geeft nu cryptocurrency terug aan gebruikers.</p>
<p>ParaSwap ontdekte deze kwetsbaarheid in zijn pas gelanceerde slimme contract Augustus V6 op 20 maart, slechts enkele dagen na de lancering van het contract op 18 augustus, met als doel het verbeteren van token swaps en het verminderen van transferkosten. Na de ontdekking heeft het platform de toepassingsprogrammeringsinterface (API) opgeschort en financiële beveiliging gewaarborgd door middel van white hat hacking-aanvallen.</p>
<p>Op 24 maart heeft het Paraswap-team een verklaring uitgegeven over X waarin staat dat alle activa met succes zijn teruggegeven aan de portemonnee die met succes is hersteld door de ethische hacker, en de toestemming voor AugustusV6 is ingetrokken.</p>
<p>De Australian and New Zealand Banking Group (ANZ) en Chainlink Labs hebben onlangs samenwerkingsresultaten vrijgegeven met als doel het verbinden <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a> en de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het blockchain-netwerk biedt oplossingen voor on-chain afwikkeling. ANZ maakte gebruik van een interoperabiliteitsoplossing die door Chainlink Cross Chain Interoperability Protocol (CCIP) wordt genoemd, waardoor het kan aantonen hoe klanten toegang kunnen krijgen, kunnen handelen en naadloos kunnen afwikkelen van getokeniseerde activa over netwerken in verschillende valuta’s.</p>
<p>Via CCIP simuleert ANZ de aankoop van getokeniseerde activa op het Ethereum-netwerk tegen een prijs uitgedrukt in een stablecoin, en initieert en vereffent transacties op Avalanche met behulp van een andere stablecoin.</p>
<p>ANZ Bank verklaarde dat het doel van het project is om de oplossing uit te rollen op het blockchain-mainnet en een nieuw tijdperk van blockchain-vermogensafwikkeling in de financiële dienstverleningsindustrie te bevorderen.</p>
<p>Dit is ook een stap voor Avalanche om zich te richten op de RWA-richting. Bijvoorbeeld, in februari van dit jaar heeft Citigroup, een Amerikaanse investeringsbank en financiële dienstverlener, samengewerkt met de ontwikkelaar van Avalanche Network, Ava Labs, om de conceptvalidatie van het tokeniseren van private equity fondsen via de Avalanche blockchain te voltooien.</p>
<h2 id="h2-Markttrends20BTC20keert20terug20naar207000020RWAsector20blijft20stijgen908714"><a name="Markttrends: BTC keert terug naar $70.000; RWA-sector blijft stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC keert terug naar $70.000; RWA-sector blijft stijgen</h2><p>De algehele cryptomarkt vertoont een stabiele opwaartse trend, vooral met Bitcoin (BTC) die weer boven $70.000 komt, wat duidt op een relatief sterke markt. Echter, op macro-economisch gebied is er een collectieve daling geweest op de Amerikaanse aandelenmarkt en is de offshore RMB-wisselkoers ook gedaald tot onder 7.28, wat mogelijk een zekere invloed kan hebben op de cryptomarkt en nauwlettend moet worden gevolgd.</p>
<h3 id="h3-Markt20hotspots339005"><a name="Markt hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots</h3><p>De RWA-sector heeft een sterke prestatie getoond: tokens in de RWA (Real World Assets) sector, zoals POLYX, ONDO, OM, TOKEN, DUSK, RSR, TRU, enz., hebben aanzienlijke winsten gezien. Dit fenomeen kan verband houden met de aankondiging van BlackRock om getokeniseerde fondsen op te richten, wat wijst op de aandacht van de markt en de zoektocht naar digitalisering van echte wereld activa.</p>
<p>Bovendien zijn er deze week meerdere crypto-projecten met token-ontgrendeling, waaronder:</p>
<ol>
<li><p>Yield Guild Games (YGG) zal op 27 maart om 14:00 (UTC) 16,69 miljoen tokens ter waarde van ongeveer $ 16,89 miljoen vrijgeven, wat overeenkomt met 5,39% van de circulerende voorraad;</p>
</li><li><p>SingularityNET (AGIX) zal 8,84 miljoen tokens ter waarde van ongeveer $9,26 miljoen ontgrendelen om 0:00 (UTC) op 28 maart, wat overeenkomt met 0,69% van het circulerende aanbod;</p>
</li><li><p><a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> Op 29 maart om 4:00 uur (UTC) zal (OP) 24,16 miljoen tokens ter waarde van ongeveer $84,32 miljoen ontgrendelen, wat overeenkomt met 2,4% van de circulerende voorraad;</p>
</li><li><p>EchelonPrime (PRIME) zal om 0:00 (UTC) op 31 maart 1,66 miljoen tokens ter waarde van ongeveer $37,53 miljoen ontgrendelen, wat overeenkomt met 4,65% van de omloopvoorraad;</p>
</li><li><p>Op 31 maart om 0:00 uur (UTC) zal Sui (SUI) 4 miljoen tokens ter waarde van ongeveer $6,68 miljoen ontgrendelen, wat overeenkomt met 0,32% van het circulerende aanbod.<br>Deze ontgrendelde gegevens kunnen van invloed zijn op het aanbod en de prijzen op de markt en de marktreacties moeten worden gemonitord.</p>
</li></ol>
<p>Op basis van de bovenstaande analyse toont de cryptomarkt over het algemeen een stabiele opwaartse trend. Er moet echter nog steeds aandacht worden besteed aan de impact van macro-economische factoren en het ontgrendelen van specifieke projecten op de markt.</p>
<p>Vooral met de voortdurende ontwikkeling van de digitaliseringstrend van reële activa, neemt de aandacht van de RWA-sector geleidelijk toe en kunnen investeerders nauwlettend investeringsmogelijkheden op dit gebied volgen. Ondertussen is het noodzakelijk om de projecten die deze week zijn vrijgegeven zorgvuldig te ueren op hun impact op de markt en investeringsstrategieën te ontwikkelen op basis van de werkelijke situatie.</p>
<h2 id="h2-Macro20Wall20Street20viel20voordat20belangrijke20gegevens20werden20vrijgegeven20Geopolitieke20spanningen20kunnen20de20olieprijzen20opdrijven51694"><a name="Macro: Wall Street viel voordat belangrijke gegevens werden vrijgegeven; Geopolitieke spanningen kunnen de olieprijzen opdrijven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wall Street viel voordat belangrijke gegevens werden vrijgegeven; Geopolitieke spanningen kunnen de olieprijzen opdrijven</h2><p>De Federal Reserve besloot afgelopen woensdag om de belangrijkste beleidsrentetarieven ongewijzigd te handhaven, en de ‘Policy Path Chart’ weerspiegelt nog steeds de verwachting van drie renteverlagingen dit jaar. Vanwege de relatief kleine hoeveelheid economische gegevens deze week, is de marktfocus verschoven naar het rapport over persoonlijke consumptie uitgaven (PCE) dat op vrijdag is vrijgegeven. Dit kan de richting van het vooruitzicht voor de Amerikaanse rentetarieven bepalen. Er wordt verwacht dat de kernindex voor persoonlijke consumptie uitgaven (PCE) in de Verenigde Staten in februari met 0,3% zal stijgen, met een jaarlijkse groeipercentage van 2,8%.</p>
<p>IG-marktanalist Tony Sycamore zei: “Aan het begin van dit jaar probeerde de voorzitter van de Federal Reserve de markt te bevrijden van agressieve renteverwachtingen, en hij heeft altijd geloofd dat dit een hobbelige weg zal zijn.”</p>
<p>Vorige week heeft voorzitter van de Federal Reserve Jerome Powell de inflatieverwachting versoepeld, waardoor renteverlagingen weer op de agenda staan.</p>
<p>De voorspelde verlaging van de rente voor juni bedraagt 75%, een afname ten opzichte van 55% een week geleden. Deze rente is opgenomen in de drie tot vier renteverlagingen dit jaar. Powell zal het beleidsvergadering op vrijdag voorzitten en ook Federal Reserve-directeuren Lisa Cook en Christopher Waller zullen deze week aanwezig zijn.</p>
<p>Voorafgaand aan de publicatie van de gegevens sloot Wall Street lager, waarbij de Dow Jones Industrial Average (.DJI) met 162,26 punten of 0,41% daalde tot 39.313,64 punten, de S&amp;P 500-index daalde tot 5.218,19 punten of 0,31%, en de Nasdaq Composite-index (.IXIC) daalde met 44,35 punten of 0,27% tot 16.384,47.</p>
<p>In de handel in grondstoffen bleven de prijzen van goud en olie relatief stabiel, met goudprijzen op $2.169 per ounce en Brent ruwe olie futures die met 24 cent stegen naar $86.99 per vat.</p>
<p>De mondiale politieke situatie zal echter ook waarschijnlijk van invloed zijn op de olieprijzen. Rusland eist dat zijn oliebedrijven de productie verminderen om het doel van de Organisatie van Olie-Exporterende Landen (OPEC) van 9 miljoen vaten per dag (bpd) te bereiken. De dagelijkse productie van Rusland was eind februari ongeveer 9,5 miljoen vaten. Ondertussen gaan de aanvallen van Oekraïne op Russische raffinaderijen door. De Gubyshev-raffinaderij in Rusland moest de helft van haar productiecapaciteit stilleggen nadat er zaterdagochtend een brand uitbrak.</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 enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voorbehouden voor dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>