RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0by1tYXJrdCBkYWFsdCBvdmVyIGhldCBhbGdlbWVlbjsgSGFzaGRleCB2YW4gcGxhbiBvbSBlZW4gZ2Vjb21iaW5lZXJkZSBTcG90IEJpdGNvaW4gZW4gRXRoZXJldW0gRVRGIHVpdCB0ZSBnZXZlbjsgQXJraGFtIGJpZWR0IGVlbiBiZWxvbmluZyB2YW4gJDE1SyBvbSB0ZSB6b2VrZW4gbmFhciB

2024-06-19, 03:47

<p><img src="https://gimg2.gateimg.com/image/article/17187687361_14.png" alt=""></p>
<h2 id="h2-Crypto20dagelijkse20samenvatting20De20cryptomarkt20blijft20dalen20Hashdex20plant20de20uitgifte20van20een20gecombineerde20spot20Bitcoin20en20Ethereum20ETF20Arkham20bood20een20beloning20van20150K20aan20voor20het20zoeken20naar20de20DJTtoken20pusher20Ethereum20Restaking20protocol20Renzo20Financing201720miljoen157870"><a name="Crypto dagelijkse samenvatting: De cryptomarkt blijft dalen; Hashdex plant de uitgifte van een gecombineerde spot Bitcoin en Ethereum ETF; Arkham bood een beloning van $150K aan voor het zoeken naar de DJT-token pusher; Ethereum Re-staking protocol Renzo Financing $17 miljoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto dagelijkse samenvatting: De cryptomarkt blijft dalen; Hashdex plant de uitgifte van een gecombineerde spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF; Arkham bood een beloning van $150K aan voor het zoeken naar de DJT-token pusher; Ethereum Re-staking protocol Renzo Financing $17 miljoen</h2><p>Allereerst gaan we de handelsactiviteiten van nader bekijken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens Farside Investor gegevens, op 18 juni, bleven de Grayscale Bitcoin spot ETF’s (GBTC) uitstroom ervaren van $62,3 miljoen aan fondsen. Ondertussen ervoer Fidelity Bitcoin spot ETF (FBTC) uitstroom van $83,1 miljoen, Bitwise Bitcoin spot ETF (BITB) had een instroom van $7 miljoen, en ARK 21Shares Bitcoin spot ETF (ARKB) had een instroom van $41,3 miljoen.</p>
<p>Maandag kelderde de cryptomarkt, waarbij de marktwaarde de afgelopen 24 uur met 3,5% daalde tot $ 2,46 biljoen. Sommige Altcoins zijn met meer dan 10% gedaald en er is geen duidelijke reden om dit fenomeen te verklaren. Een industrieanalist zei echter dat Bitcoin-mijnaandelen de afgelopen weken sterk hebben gepresteerd en een deel van de verliezen goedmaken die zijn veroorzaakt door de halvering in april.</p>
<p><strong>Hashdex heeft plannen om een gecombineerde spot Bitcoin en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF</strong><br>Hashdex, een bedrijf voor crypto-activabeheer, van plan is om een exchange traded fund (ETF) te lanceren dat fysieke Bitcoin en Ethereum bezit. De stap van Hashdex komt nadat de Amerikaanse Securities and Exchange Commission (SEC) eerder de spot Bitcoin ETF heeft goedgekeurd en vorige maand een reeks van 19b-4 formulieren heeft goedgekeurd voor de spot Ethereum ETF. De SEC moet nog steeds de registratieverklaring voor Ethereum-producten goedkeuren als onderdeel van het proces.</p>
<p>Hashdex heeft besloten om zijn voorstel voor een spot Ethereum ETF niet door te zetten, dus het behoort tot een groep die nog geen goedkeuring van de SEC heeft verkregen voor het formulier 19b-4, waaronder BlackRock en Fidelity. Bronnen verklaarden vorige week dat de SEC nog steeds feedback moet geven op de eerste ronde van opmerkingen over deze formulieren.</p>
<p>Volgens de 19b-4-tabel van de NASDAQ Crypto Index US ETF die is ingediend door Hashdex, zal de ETF ook contanten aanhouden. Hashdex benadrukt dat “het trust niet zal investeren in cryptocurrencies, getokeniseerde activa of stablecoins.” Naast Bitcoin en Ethereum zal het niet investeren in andere spot cryptocurrencies.</p>
<p><strong>Arkham bood een beloning van $150.000 aan om een pusher te vinden voor de op Trump-geïnspireerde token DJT</strong><br>Onlangs is de prijs van de tokens explosief gestegen als gevolg van een onbevestigd rapport dat voormalig president van de VS, Donald Trump, DJT-tokens heeft uitgegeven. Volgens GeckoTerminal-gegevens bedroeg het handelsvolume van de token om 17:31 uur Oostelijke Tijd meer dan $472 miljoen, een stijging van meer dan 300% binnen 24 uur tot $0.02185.</p>
<p>Arkham Intelligence heeft dinsdag een verklaring uitgebracht waarin een beloning van $150.000 wordt aangeboden voor het zoeken naar duidelijk bewijs van wie de Trump-thematische heeft gemaakt. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> token.</p>
<p>Dit evenement zit vol mysterie, en veel bronnen suggereren dat Trump zelf de bedenker ervan kan zijn. Martin Shkreli, een controversiële uitvoerende die werd gevangengezet voor effectenfraude, beweerde online dat ‘het team of de familie van Trump eigenlijk achter de DJT-token zitten’. Hij tweette op maandag dat DJT Trumps officiële token is. Het informatiemedium ‘Pirate Wires’ beweerde ook op X dat Trump DJT aan het pushen is.</p>
<p>ZachXBT, een beroemde blockchain-detective, heeft ook gereageerd op dit evenement: ‘De informatiebron moet origineel zijn, niet afkomstig van andere plaatsen op internet. Je kunt deze bonus niet ontvangen door de eerste persoon te zijn die’. <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> naar nieuws uit andere plaatsen.”</p>
<p><strong>Ethereum Herbeleggingsprotocol Renzo financiert $17 miljoen</strong><br>Renzo haalde $17 miljoen op uit een financieringsronde geleid door Galaxy Ventures en nog een financieringsronde door Brevan Howard Digital Nova Fund onder het herschikkingsprotocol. Deze financieringsronde volgt op de seedrondefinanciering van Renzo van $3,2 miljoen in januari van dit jaar, geleid door Maven11 en ondersteund door bedrijven als Segment Capital, SevenX Ventures en IOSG Ventures.</p>
<p>Renzo is gebouwd bovenop het Ethereum-stakingsprotocol EigenLayer, waardoor individuen Ethereum (ETH) opnieuw kunnen staken, verpakte beacon Ethereum (wBETH) kunnen verkrijgen en Ethereum (stETH) kunnen staken. Het storten van deze activa kan gebruikers voorzien van EzETH of Renzo’s vloeibare opnieuw gestaakte tokens (LRT’s), die kunnen worden gebruikt op andere DeFi-platforms.</p>
<p>Volgens de gegevens van DeFiLlama heeft Renzo een totale lock-in waarde van bijna $3,6 miljard en een marktkapitalisatie van $111,5 miljoen. De uniciteit van Renzo ligt in zijn vermogen om zowel native ETH als vloeibaar gestaakte tokens tegelijkertijd te accepteren. Deze mogelijkheid stelt Renzo in staat om samenwerking te bevorderen met bestaande marktdeelnemers en ervoor te zorgen dat deelnemers genieten van een soepel stakingsproces.</p>
<h2 id="h2-Markttrends20De20wisselkoers20van20ETH20versterkt20opnieuw20en20het20ETHecosysteem20kan20de20belangrijkste20focus20van20speculatie20zijn20in20de20komende20maand941942"><a name="Markttrends: De wisselkoers van ETH versterkt opnieuw, en het ETH-ecosysteem kan de belangrijkste focus van speculatie zijn in de komende maand" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De wisselkoers van ETH versterkt opnieuw, en het ETH-ecosysteem kan de belangrijkste focus van speculatie zijn in de komende maand</h2><p>BTC: Momenteel in een lage consolidatiefase, nadert onlangs $64.000. Deze consolidatie betekent dat de markt wacht op nieuwe aanjagers of nieuws om de volgende richting te bepalen. Beleggers moeten de handelsvolumes en belangrijke steun- / weerstandsniveaus nauwlettend in de gaten houden om de volgende trend te bepalen.</p>
<p>ETH: ETH heeft relatief sterke prestaties laten zien, met de ETH/BTC wisselkoers die opnieuw versterkt is. Na gisteren tot ongeveer $3.350 te zijn gedaald, steeg ETH weer boven $3.500, wat wijst op sterke koopondersteuning. Deze relatieve sterkte kan gerelateerd zijn aan de aankomende ETH spot ETF en investeerders kunnen zich richten op de voortgang van dit evenement.</p>
<p>Altcoins: Altcoins zijn hersteld na de algemene daling van gisteren, maar ze blijven over het algemeen zwak. Beleggers moeten zich richten op de algehele trend van de markt en de fundamentele situatie van specifieke projecten om te bepalen of ze geschikt zijn voor interventie.</p>
<p>Macroeconomie: Amerikaanse aandelen blijven stijgen en bereiken historische hoogtes, en de opleving van de Amerikaanse dollar-index kan enige druk uitoefenen op de cryptomarkt. Investeerders moeten de daaropvolgende prestaties in de gaten houden.</p>
<h3 id="h3-Markt20Hotspots711439"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>ETH ecosysteem:</strong><br>Met de versterking van de ETH/BTC wisselkoersen, hebben ETH ecosysteem tokens beter gepresteerd dan andere openbare keten ecoen.</p>
<p>De opkomst van tokens zoals ENS, LDO, RPL, PENDLE, CVX en anderen duidt op een toename van het marktvertrouwen in het ETH-ecosysteem.</p>
<p>De ETH spot ETF, die op 2 juli zal worden goedgekeurd, kan de belangrijkste marktaanstuurder worden voor de volgende maand.</p>
<p><strong>Bankroet concept token:</strong><br>FTT, USTC en andere tokens zijn met meer dan 20% gestegen en er wordt gefluisterd dat de $8 miljard aan activa van FTX mogelijk rechtstreeks aan gebruikers van het platform wordt teruggegeven. Als dit nieuws waar is, zal dit het marktvertrouwen aanzienlijk versterken, vooral voor deze tokens met een faillissementsconcept.</p>
<p><strong>Meme sector:</strong><br>PEPE, MOG, MANEKI, MAGA en andere tokens zijn aanzienlijk hersteld van de dieptepunten van gisteren.</p>
<p>MANEKI kan vandaag de lancering van de Tier1-uitwisseling aankondigen, wat de prijzen verder zou kunnen opdrijven.</p>
<p>MAGA is een concept token voor de Amerikaanse presidentsverkiezingen. De markt gelooft over het algemeen dat tijdens het presidentiële debat op 27 juni beide presidentskandidaten, Trump en Biden, hun steun voor cryptocurrencies zullen aankondigen, wat ook goed nieuws is voor de sector.</p>
<h3 id="h3-Analyse20van20vooruitzichten613712"><a name="Analyse van vooruitzichten:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analyse van vooruitzichten:</h3><p>BTC en ETH: beleggers kunnen doorgaan met het monitoren van belangrijke ondersteunings- en weerstandsniveaus, vooral de voortgang van ETH spot ETF’s.</p>
<p>Vanwege de algehele zwakte van Altcoins wordt het aanbevolen dat beleggers voorzichtig te werk gaan en wachten op duidelijkere marktsignalen.</p>
<p>Hotspot tokens: Voor ETH-ecosysteemtokens, faillissementsconcepttokens en memefonds-tokens kunt u relevante nieuwsberichten volgen en tijdig korte-termijnkansen grijpen.</p>
<p>Kortom, de markt is relatief onzeker en beleggers moeten voorzichtig blijven en de markttrends en de voortgang van belangrijke gebeurtenissen nauwlettend in de gaten houden.</p>
<h2 id="h2-Macro20Kunstmatige20intelligentie20bleef20de20SampP2050020en20Nasdaq20naar20nieuwe20hoogtepunten20leiden20terwijl20de20Aziatische20markt20synchroon20bleef20stijgen197684"><a name="Macro: Kunstmatige intelligentie bleef de S&amp;P 500 en Nasdaq naar nieuwe hoogtepunten leiden, terwijl de Aziatische markt synchroon bleef stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Kunstmatige intelligentie bleef de S&amp;P 500 en Nasdaq naar nieuwe hoogtepunten leiden, terwijl de Aziatische markt synchroon bleef stijgen</h2><p>Op 18 juni bereikten de S&amp;P 500 en Nasdaq-indexen historische hoogtepunten, gedreven door de voortdurende stijging van de aandelenkoers van Nvidia. Door lagere dan verwachte detailhandelsverkopen in de Verenigde Staten steeg de Dow Jones-index lichtjes in de handel voorafgaand aan de feestdag.</p>
<p>Nvidia is het grootste bedrijf ter wereld qua marktwaarde geworden, met een marktwaarde van 3,22 biljoen dollar bij het sluiten. Andere chipaandelen hebben hun recente winsten voortgezet, waardoor de Philadelphia Stock Exchange Semiconductor Index naar een historisch hoogtepunt is gestegen. De groei van de markt wordt gedreven door de verwachting van meerdere renteverlagingen, enthousiasme voor AI-gerelateerde bedrijven en sterke winsten van technologiebedrijven, waarbij de winsten geconcentreerd zijn in een paar zwaargewicht aandelen.</p>
<p>Technologieaandelen, met name die gerelateerd aan kunstmatige intelligentie, hebben bijzonder goed gepresteerd. De prestaties van de Amerikaanse markt zijn ook beïnvloed door macro-economische gegevens, met name de gegevens over de detailhandelsverkopen, die de gezondheid van de consumentenbestedingen en de algehele economische activiteit weerspiegelen.</p>
<p>De Amerikaanse markt zal op woensdag gesloten zijn vanwege de Junivakantie.</p>
<p>Op 19 juni opende de Aziatische markt hoger, gedreven door de stijging van de technologische aandelen, en steeg de Aziatische aandelenmarkt naar het hoogste niveau in drie weken. Ondertussen zijn door zwakke detailhandelsverkopen in de Verenigde Staten de marktverwachtingen voor een renteverlaging door de Federal Reserve later dit jaar versterkt, wat tot schommelingen in de Amerikaanse dollar heeft geleid. De handelsgegevens tussen Japan en Indonesië, de lopende rekeninggegevens van Nieuw-Zeeland en de kortetermijnbedrijvenquête van Japan kregen deze week extra aandacht op de economische kalender.</p>
<p>De Nikkei-index in Japan steeg met 0,59%, de Chinese blue-chip aandelen daalden met 0,42% en de Hang Seng-index in Hong Kong steeg met 1,3%. De gegevens die op dinsdag zijn vrijgegeven, toonden aan dat de detailhandelsverkopen in de Verenigde Staten bijna geen groei vertoonden in mei, terwijl de gegevens van vorige maand aanzienlijk werden verlaagd, wat aangeeft dat de economische activiteit in het tweede kwartaal traag bleef.</p>
<p>Het pond bleef onveranderd op $1,2704 in de vroege handel, met de marktaandacht gericht op de vandaag vrijgegeven inflatiegegevens van het VK. Deze gegevens zullen de basis leggen voor het beleidsbesluit van de Bank of England (BoE) op donderdag, en de centrale bank wordt verwacht de rentetarieven ongewijzigd te houden. Het inflatierapport laat naar verwachting zien dat het VK-inflatiepercentage is gedaald van 2,3% in april naar het streefcijfer van 2% van de Bank of England.</p>
<p>Met betrekking tot grondstoffen zijn de olieprijzen licht gestegen omdat zorgen over toenemende conflicten in Europa en het Midden-Oosten de zorgen over de vraag overschaduwen na een onverwachte toename van de Amerikaanse ruwe olievoorraden. Brent ruwe olie futures voor levering in augustus stegen met 6 cent naar $85.39 per vat; In juni stegen West Texas Intermediate ruwe olie futures in de Verenigde Staten met 10 cent naar $81.67 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 mening van de onderzoeker en vormt geen enkele beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt zich alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen 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>