RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBtYWFrdGUgZWVuIHRlcnVndHJla2tpbmcgbWVlLCBhbHRjb2lucyBkYWFsZGVuIG92ZXIgaGV0IGFsZ2VtZWVuOyBHcmF5c2NhbGUgdHJvayBFdGhlcmV1bSBGdXR1cmVzIEVURi1hYW52cmFhZyBpbjsgU29sYW5hIERlUElOLXByb2plY3QgdmVyd2llcmYgUGxhbmV0V2F0Y2ggTmV0d29yaw==

2024-05-08, 04:12

<p><img src="https://gimg2.gateimg.com/image/article/17151415141_4.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Grayscale20trok20de20aanvraag20voor20Ethereum20Futures20ETF20in20Solana20DePINproject20heeft20het20PlanetWatchnetwerk20overgenomen497379"><a name="Crypto Dagelijkse Samenvatting: Grayscale trok de aanvraag voor Ethereum Futures ETF in; Solana DePIN-project heeft het PlanetWatch-netwerk overgenomen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Grayscale trok de aanvraag voor <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Futures ETF in; <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> DePIN-project heeft het PlanetWatch-netwerk overgenomen</h2><p>Allereerst, laten we eens kijken naar de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor ondervonden Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 7 mei nog steeds een uitstroom van $2860 aan fondsen; Ondertussen bedroeg de instroom van Fidelity Bitcoin spot ETF (FBTC) $4,1 miljoen en de instroom van ARK 21 Shares Bitcoin spot ETF (ARKB) $2,8 miljoen.</p>
<p>Grayscale’s spot Bitcoin ETF heeft 78 opeenvolgende dagen van fondsuitstroom beëindigd met opeenvolgende nettokapitaalinstromen in de afgelopen twee dagen, en de fondsuitstroom van vandaag heeft deze situatie beëindigd. Bloomberg ETF-analisten geloven dat “dit een kortetermijn tactische handel of een soort van gekoppelde handel kan zijn.”</p>
<p>Volgens een indiening bij de Amerikaanse Securities and Exchange Commission is het futures trust ETF dat in september vorig jaar door Arca, Inc. op de New York Stock Exchange werd ingediend, op 3 mei ingetrokken. Het is momenteel onduidelijk waarom het voorstel is ingetrokken. Arca, de New York Stock Exchange, weigerde commentaar te geven. Grayscale reageerde niet onmiddellijk op het verzoek om commentaar.</p>
<p>De SEC had eerder overwogen om Grayscale’s te overwegen <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> futures ETF, waarvan de meest recente in maart was. De SEC had echter eerder in oktober 2023 een reeks Ethereum futures ETF’s goedgekeurd, waaronder ProShares, VanEck en Bitwise.</p>
<p>In de afgelopen weken heeft de Amerikaanse Securities and Exchange Commission zijn beslissing over de Ethereum ETF spot uitgesteld, waaronder die van Grayscale. In de afgelopen maanden is de <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> de goedkeuring van dergelijke producten door de Amerikaanse Securities and Exchange Commission is verzwakt. Bloomberg ETF-analist Eric Balchunas heeft zijn schatting van de kans op goedkeuring van Ethereum ETF spot tegen het einde van mei verlaagd van ongeveer 70% naar 25%.</p>
<p>Het gedecentraliseerde fysieke infrastructuurnetwerk, ambient, richt zich op het verzamelen van omgevingsgegevens en heeft $2 miljoen opgehaald in financieringsronde voor startkapitaal. Luca Franchi, medeoprichter en CEO van ambient, verklaarde dat de financieringsactiviteiten in februari begonnen en in april eindigden.</p>
<p>Ambient is in januari van dit jaar opgericht en heeft vervolgens PlanetWatch Network in maart overgenomen. Franchi wees erop dat het project is gebaseerd op DePIN, met de nadruk op luchtkwaliteitsmonitoring, en heeft besloten over te stappen naar de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> blockchain.</p>
<p>PlanetWatch-netwerk heeft momenteel de token PLANETS op de <a href="/price/algorand-algo" rel="nofollow noopener noreferrer" target="_blank">Algorand</a> blockchain, maar Ambient is van plan om zijn nieuwe token te lanceren op Solana.</p>
<p>Franchi zei: ‘Het huidige netwerk wordt ondersteund door PANETS-tokens. In de komende weken zullen we een routekaart uitbrengen om nieuwe tokens op Solana te lanceren, evenals migratieprikkels en platformonderhoud, om de ambitie van Ambient te stimuleren.’</p>
<p>LayerZero - een interoperabiliteitsprotocol dat is ontworpen om ontwikkelaars in staat te stellen cross-chain applicaties te bouwen met modulaire beveiligingsparameters. LayerZero Labs is de belangrijkste bijdrager aan dit protocol.</p>
<p>LayerZero Labs heeft op 1 mei de initiële snapshot van mogelijke airdrops voltooid. Echter bevestigde medeoprichter Bryan Pellegrino op 6 mei dat medewerkers van LayerZero Labs niet in aanmerking zullen komen voor de aankomende airdrop en strikt verboden zullen zijn om tokens voor het project te ontvangen.</p>
<p>Avail, de <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> modulair blockchainproject, geplaatst op het X-platform, meldt dat het de tweede fase van Unification Drop Claim heeft ingezet, die zal doorgaan vanaf vandaag tot 16:00 UTC op 12 mei. Om de Avail-gemeenschap te belonen, zal de tweede fase beloningen introduceren voor meerdere groepen, waaronder beloningen voor meer Clash of Nodes-deelnemers en beloningen voor gebruikers van het <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> PoS Liquid Stake-protocol.</p>
<h2 id="h2-Markttrends20BTC20heeft20een20terugval20ervaren20Altcoins20zijn20over20het20algemeen20gedaald287869"><a name="Markttrends: BTC heeft een terugval ervaren, Altcoins zijn over het algemeen gedaald" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC heeft een terugval ervaren, Altcoins zijn over het algemeen gedaald</h2><p>De cryptomarkt presteerde vandaag slecht, waarbij BTC onder de $63.000 daalde. ETH daalde ook en brak onder de $ 3.000, terwijl andere Altcoins over het algemeen daalden. In termen van macro-economie is de Amerikaanse aandelenmarkt volatiel geweest en de agressieve opmerkingen van functionarissen van de Federal Reserve hebben de markt verder onder druk gezet, wat heeft geleid tot een daling van de cryptomarkt.</p>
<h3 id="h3-Markthoogtepunten598121"><a name="Markthoogtepunten:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markthoogtepunten:</h3><p>De prijsfluctuatie van Ern: Na de aankondiging van de lancering van een op kunstmatige intelligentie gebaseerde Layer2-oplossing is de prijs van Ern-tokens met meer dan 30% gestegen, maar de stijging nam vervolgens af. Deze technologische upgrade heeft de marktinteresse en investeringen in Ern aanzienlijk gestimuleerd. Een ander op <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> gebaseerd Layer2-protocol, MODE, kende een scherpe prijsdaling na de lancering op het handelsplatform. Dit kan te wijten zijn aan het overmatige aantal Layer2-oplossingen op de huidige markt, wat heeft geleid tot aandacht van investeerders en fondsdiversificatie.</p>
<p>Aanzienlijke stijging in TRB: Als sterke valuta steeg TRB (Tellor) eind 2023 tien keer, wat wijst op extreem sterke marktmanipulatiekenmerken. Vandaag steeg TRB met 20%, wat duidt op zijn activiteit tijdens marktvolatiliteit.</p>
<p>Ontwikkelingsdynamiek van het Solana-ecosysteem: Sanctum, het lanceringsproject van de tweede fase van de top DEX Jupiter van Solana, staat op het punt tokens uit te geven. Sanctum is een liquiditeitsstakingplatform dat op 10 mei een snapshot heeft aangekondigd, en gebruikers die SOL storten, ontvangen airdrop-punten. Deze dynamiek heeft meer deelname en activiteiten toegevoegd aan het Solana-ecosysteem.</p>
<p>Meerdere factoren, waaronder macro-economische onzekerheid en de beleidsverwachtingen van de Federal Reserve, beïnvloeden de huidige cryptomarkt. Beleggers moeten voorzichtig blijven tijdens deze periode, vooral voor valuta’s die vertrouwen op sterke marktmanipulatie en hoge volatiliteit. Beleggers moeten risico’s volledig beheren, hun beleggingsportefeuilles redelijk toewijzen en de markttrends en relevante nieuwsberichten nauwlettend in de gaten houden om verstandige beleggingsbeslissingen te nemen.</p>
<h2 id="h2-Macro20De20Amerikaanse20markt20blijft20stijgen20terwijl20de20Aziatische20markt20kalm20en20voorzichtig20blijft860373"><a name="Macro: De Amerikaanse markt blijft stijgen, terwijl de Aziatische markt kalm en voorzichtig blijft." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Amerikaanse markt blijft stijgen, terwijl de Aziatische markt kalm en voorzichtig blijft.</h2><p>Op 7 mei zette de Amerikaanse markt zijn opwaartse trend voort, waarbij de S&amp;P 500 hoger sloot voor de vierde opeenvolgende handelsdag, wat zijn beste winnende reeks sinds maart markeerde. De Dow Jones-index bevindt zich momenteel in zijn langste opwaartse trend sinds december 2023, en steeg voor de vijfde opeenvolgende handelsdag.</p>
<p>Specifiek steeg de Dow Jones-index met 0,08%, steeg de Standard&amp;Poor’s-index met 0,13% en daalde de Nasdaq-index licht met 0,1%. Onder grote bedrijven zijn aandelen die technologische aandelen vertegenwoordigen, zoals META, ALPAHBET en APPLE, allemaal gestegen.</p>
<p>De publicatie van gegevens over de werkgelegenheid buiten de landbouw en beter dan verwachte winstrapporten op vrijdag zullen helpen om de verwachtingen van beleggers - zorgen over hardnekkige inflatie en een sterke economie - te verlichten. De sterke economie heeft ook de rentetarieven hoog gehouden.</p>
<p>Over het algemeen is de informatie van de Federal Reserve en beleidsmakers in de afgelopen weken consistent, wat aangeeft dat renteverlagingen zullen komen. Toch zal de centrale bank voorzichtig blijven bij de uitvoering ervan. Beleggers bereiden zich voor om aandacht te besteden aan de producentenprijsindex (PPI) en consumentenprijsindex op 14 mei, evenals de consumentenprijsindex (CPI) die naar verwachting rond 15 mei zal worden vrijgegeven.</p>
<p>Op 8 mei bleef de Aziatische markt relatief kalm op het middelpunt van de week. De Hong Kong aandelenmarkt daalde op dinsdag, terwijl Aziatische en opkomende marktaandelenindices onveranderd bleven.</p>
<p>De MSCI Asia Pacific Stock Index daalde met 0,19%, blue chip aandelen in vasteland China daalden en de Hong Kong Hang Seng Index steeg met 0,52%. De Nikkei Index in Japan daalde met ongeveer 1% vanwege handelaren die winst namen na een stijging van 1,6% op de vorige handelsdag. De index, voornamelijk samengesteld uit technologie-aandelen, bezweek ook onder de druk van de verkoop van Amerikaanse chipaandelen op dinsdag.</p>
<p>Op het gebied van valuta is de Amerikaanse dollar nog steeds sterk ondanks het lage rendement van Amerikaanse staatsobligaties, omdat de markt de signalen van Amerikaanse beleidsmakers en de economische gegevens over de rentetrend van de Federal Reserve ueert. Ondanks de bewering van de Japanse autoriteiten dat monetaire interventie de yen zou ondersteunen, blijft de yen in het nadeel.</p>
<p>Met betrekking tot grondstoffen daalden de Brent ruwe olie futures met 32 cent, of 0,38%, tot $82,84 per vat. De West Texas Intermediate ruwe olie futures in de Verenigde Staten daalden met 28 cent, of 0,36%, tot $78,10 per vat.</p>
<p>De goudprijzen daalden met 0,16% tot ongeveer $2.310 per ounce.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>