RGFnZWxpamtzIE5pZXV3cyB8IFRpZGFsIGVuIEhhc2hkZXggbGFuY2VlcmRlbiBTcG90IEJpdGNvaW4gRVRGIFRyYWRpbmc7IFRoZSBHYW1lIE11bmNoYWJsZXMgb24gQmxhc3QgdmVybG9vciAkNjIgbWlsam9lbiB2YW53ZWdlIGVlbiBrd2V0c2JhYXJoZWlkOyBEb21vIHphbCBoZXQgQlJDMjAtcHJvdG9jb2wgdXBncmFkZW4=

2024-03-27, 04:00

<p><img src="https://gimg2.gateimg.com/image/article/17115120011_19.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Tidal20en20Hashdex20kondigden20de20lancering20aan20van20spot20Bitcoin20ETFhandel20Het20spelproject20op20Blast20leed20een20verlies20van206220miljoen20Domo20zal20het20BRC20protocol20upgraden216989"><a name="Crypto Dagelijkse Samenvatting: Tidal en Hashdex kondigden de lancering aan van spot Bitcoin ETF-handel; Het spelproject op Blast leed een verlies van $62 miljoen; Domo zal het BRC20-protocol upgraden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Tidal en Hashdex kondigden de lancering aan van spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF-handel; Het spelproject op Blast leed een verlies van $62 miljoen; Domo zal het BRC20-protocol upgraden</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 was de uitstroom van de Grayscale Bitcoin spot ETF (GBTC) op 26 maart $ 212,3 miljoen; Ondertussen was de instroom van de Fidelity Bitcoin spot ETF (FBTC) $ 279,1 miljoen, de instroom van de Bitwise Bitcoin spot ETF (BITB) $ 16,7 miljoen en de instroom van de ARK 21Shares Bitcoin spot ETF (ARKB) $ 73,6 miljoen.</p>
<p>Tidal Investments en Hashdex Asset Management hebben dinsdag aangekondigd dat ze hun spot Bitcoin ETF zullen verhandelen in de Verenigde Staten en de naam van Hashdex Bitcoin Futures ETF zullen veranderen in Hashdex Bitcoin ETF (DEFI).</p>
<p>Het ETF wordt verwacht ten minste 95% van zijn fondsvermogen te investeren in spot Bitcoin, en tot 5% van zijn resterende activa zal worden geïnvesteerd in Bitcoin-futurescontracten die worden verhandeld op CME, evenals contant geld of contante equivalenten. Volgens de Hashdex-website bedroeg de totale nettowaarde op 27 maart $11,16 miljoen.</p>
<p>Medeoprichter en CEO Marcelo Sampaio zei: “We zijn verheugd om de conversie van DEFI te voltooien en samen te werken met Tidal om een innovatief product te lanceren, waarmee we onze missie verder bevorderen om individuen en instellingen wereldwijd in staat te stellen deze revolutionaire innovatie te bereiken.” Functionarissen van Hashdex verklaarden in een verklaring.</p>
<p>Een NFT-spel genaamd Munchables op Blast leed een verlies van $62 miljoen als gevolg van een kwetsbaarheid. Het protocol stelt spelers in staat om Blast ETH en Blast USD (USDB) in te zetten om Blast-punten te verdienen en extra in-game voordelen te ontgrendelen. Munchables kondigde in een bericht op de avond van 26 maart UTC aan dat het was aanglen en verklaarde dat het de bewegingen van de aanvaller volgde en probeerde transacties te blokkeren.</p>
<p>Het portefeuilleadres toont aan dat de aanvaller om 9:26 AM World Standard Time met het Munchables-protocol heeft geïnterageerd en 17.413 ETH heeft geëxtraheerd. Nu roepen X-gebruikers het Blast-team op om in te grijpen en de keten terug te draaien voordat de kwetsbaarheid zich voordoet.</p>
<p>Volgens een bericht van BRC20-ontwikkelaar domo op het X-platform staat de voorgestelde verbetering van de release en vernietiging van BRC20 op het punt te worden geïmplementeerd. Het wordt verwacht dat het zal worden opgewaardeerd op blokhoogte van 837.090. De voorgestelde wijzigingen omvatten het introduceren van een zelfpublicatiemechanisme, het wijzigen van implementatie-inies, het aannemen van een 5-byte-code en het bereiken van consensus over de verbrandingsmethode voor BRC-20-activa.</p>
<p>Er wordt verwacht dat er veel nieuwe upgrades en optimalisaties zullen plaatsvinden. Volgens ontwikkelaars maakt de standaard BRC-20 standaard gebruik van openbaar beschikbare methoden om activa te implementeren en te distribueren. Nu zal er een nieuwe methode worden voorgesteld waarbij alleen implementeerders kunnen deelnemen aan het maken van munten na implementatie van activa.</p>
<h2 id="h2-Markttrends20BTC20consolideert20op20een20hoog20niveau20nadert20het20Altcoinseizoen263897"><a name="Markttrends: BTC consolideert op een hoog niveau, nadert het Altcoin-seizoen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC consolideert op een hoog niveau, nadert het Altcoin-seizoen?</h2><p>De huidige markt is relatief stabiel, met Bitcoin-prijzen die blijven boven de $70.000, en de algehele markt is volatiel. Het is het vermelden waard dat de netto instroom van Bitcoin spot ETF’s is toegenomen, wat een positieve invloed heeft op de markt. Tegelijkertijd zijn de contracttarieven op verschillende beurzen over het algemeen gestegen, wat aangeeft dat de markt herstelt van een bullish sentiment en suggereert dat het Altcoin-seizoen nadert.</p>
<p>De Amerikaanse aandelenmarkt bleef zakken op het macro-economische front terwijl de Amerikaanse dollar index herstelde. Dit fenomeen kan een zekere mate van invloed hebben op de cryptomarkt en vereist nauwe aandacht.</p>
<h3 id="h3-Markt20Hotspots872275"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De RWA-sector zag een toename van valuta’s zoals TRU, RSR, OM en LTO. Na de stijging van projecten zoals POLYX en TOKEN gisteren, stroomden fondsen naar andere valuta’s in de RWA-sector. De RWA-sector blijft een populaire sector op de markt.</p>
<p>POW-sector: Valuta’s zoals RVN en LTC stegen. Verwacht wordt dat naarmate de halvering van Bitcoin nadert, de POW-sector het middelpunt van de marktaandacht zal worden en investeerders mogelijk nieuwe investeringsmogelijkheden in deze sector zullen zoeken.</p>
<p>Meme op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> chain: Het Meme-project op de Solana-keten heeft weer marktaandacht gekregen, met een aanzienlijke stijging van WEN en WIF. Dit duidt erop dat investeerders nog steeds een sterke interesse hebben in het Meme-project op de Solana-keten en de gerelateerde trends en risico’s nauwlettend moeten volgen.</p>
<p>Over het algemeen is de markt nog steeds volatiel en moeten beleggers voorzichtig blijven en tijdig hun beleggingsstrategieën aanpassen op basis van marktomstandigheden. Risicobeheer is noodzakelijk om mogelijke schommelingen en risico’s te voorkomen, met name voor hotspots zoals RWA, POW en <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> on chain Meme-projecten.</p>
<h2 id="h2-Macro20De20marktprestaties20zijn20zwak20met20Wall20Street20die20daalt20Inflatiegegevens20blijven20de20focus20Ruwe20olie20en20goud20dalen122519"><a name="Macro: De marktprestaties zijn zwak, met Wall Street die daalt; Inflatiegegevens blijven de focus; Ruwe olie en goud dalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De marktprestaties zijn zwak, met Wall Street die daalt; Inflatiegegevens blijven de focus; Ruwe olie en goud dalen</h2><p>Volgens Reuters daalde de Amerikaanse aandelenmarkt op dinsdag 26 maart en gaf het een lichte stijging in de late handel op. De Dow Jones en S&amp;P 500-indexen daalden voor de derde opeenvolgende keer en investeerders wachtten op economische gegevens gedurende de verkorte week van de vakantie om de economische vooruitzichten te meten. De Amerikaanse markt zal op vrijdag gesloten zijn vanwege de Goede Vrijdag Pasen, en het wordt verwacht dat de handelsvolumes gedurende de hele week vlak zullen blijven.</p>
<p>De focus blijft liggen op de belangrijkste lezing van de Persoonlijke Consumptie Uitgaven Prijs Index (PCE), de favoriete inflatie-indicator van de Federal Reserve. De gegevens worden vrijdag vrijgegeven. Er wordt verwacht dat de index in februari met 0,4% zal stijgen, met een jaarlijkse stijging van 2,5%. Economen die door Reuters zijn ondervraagd, zeiden dat het kerninflatiepercentage, exclusief volatiele voedsel- en energiecomponenten, naar verwachting vorige maand met 0,3% zal stijgen, met een jaarlijkse groeisnelheid van 2,8%.</p>
<p>Wat betreft de economie overtrof de stijging van duurzame goederenorders in februari de verwachtingen in de Verenigde Staten, terwijl de uitgaven voor bedrijfsmiddelen voorlopige tekenen van herstel vertoonden. In een ander rapport verklaarde de World Federation of Large Enterprises dat het consumentenvertrouwen in maart niet veel veranderde en 104,7 bereikte.</p>
<p>CME’s FedWatch-tool toont aan dat de marktverwachtingen voor de centrale bank om de rente in juni met minstens 25 basispunten te verlagen langzaam stijgen, met een huidige waarschijnlijkheid van 70,4%, tegenover vorige week 59,2%.</p>
<p>De aandelenmarkt in Azië heeft gemengde ups en downs gezien. Over het algemeen steeg de meest gebruikte Aziatisch-Pacifische aandelenindex van MSCI (MIAP00000 PUS) met 0,11%, maar exclusief Japanse aandelen daalde het met 0,22%.</p>
<p>Na ingrijpen van de Japanse autoriteiten op 151,94 in oktober 2022, steeg de yen lichtjes naar de $152 tegen de Amerikaanse dollar, wat door sommigen wordt gezien als een rood gebied voor interventie van de centrale bank. Uiteindelijk daalde de Japanse yen met ongeveer 0,1% naar $151,73.</p>
<p>Van 24 tot 25 maart ontmoette de Chinese premier Li Qiang geen bezoekende buitenlandse CEO’s op het Han Chinese Development Forum in Beijing, wat opnieuw zorgen deed rijzen over de economische transparantie van Han en verslechterende economische betrekkingen met de Verenigde Staten. Xi’s tussenkomst kan echter wijzen op zijn toewijding om de commerciële openheid van China te waarborgen en de betrekkingen tussen China en de VS te verbeteren. Of op zijn minst kan het voorkomen dat ze verder verslechteren.</p>
<p>Wat betreft grondstoffen zijn de ruwe olieprijzen voor de tweede opeenvolgende dag gedaald na berichten over een stijging van de ruwe olievoorraden in de Verenigde Staten, ‘s werelds grootste olieverbruiker, en tekenen dat belangrijke olieproducerende landen waarschijnlijk hun productiebeleid niet zullen wijzigen bij de technische vergadering van volgende week. Brent ruwe olie futures in mei daalden met 69 cent, of 0,8%, tot $85,56 per vat. Het contract voor mei loopt donderdag af, en het actievere junicontract daalde met 60 cent, of 0,7%, tot $85,03.</p>
<p>Na te zijn gestegen naar een recordhoogte van $2.222,39 op donderdag, bleef goud op zoek naar een korte termijn bodem, met een daling van 0,1% tot ongeveer $2.176.</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 opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel te herposten, mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>