RGFnZWxpamtzIG5pZXV3cyB8ICQ5LDI1IG1pbGphcmQgQlRDLW9wdGllcyBzdGFhbiBvcCBoZXQgcHVudCB0ZSB2ZXJsb3BlbjsgRGUgU0VDIGthbiBzcG90IEV0aGVyZXVtIEVURidzIGdvZWRrZXVyZW47IEhldCBCVk0tdGVhbSBoZWVmdCBaSyBSb2xsdXBzLXNlcnZpY2UgZ2VsYW5jZWVyZCBvbSBCVEMgdWl0IHRlIGJyZWlkZW4=

2024-06-27, 03:51

<p><img src="https://gimg2.gateimg.com/image/article/17194601691_20.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest2092520miljard20BTCopties20staan20op20het20punt20af20te20lopen20en20stieren20kunnen20voor20een20crisis20komen20te20staan20De20SEC20kan20spot20Ethereum20ETFs20al20op20420juli20goedkeuren20Het20Bitcoin20Virtual20Machine20Team20lanceerde20ZK20Rollupsservice20om20Bitcoin20uit20te20breiden20Blastairdrops20gaven201720miljard20tokens20uit264526"><a name="Crypto Daily Digest: $9.25 miljard BTC-opties staan op het punt af te lopen en stieren kunnen voor een crisis komen te staan; De SEC kan spot Ethereum ETF’s al op 4 juli goedkeuren; Het Bitcoin Virtual Machine Team lanceerde ZK Rollups-service om Bitcoin uit te breiden; Blast-airdrops gaven 17 miljard tokens uit." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: $9.25 miljard BTC-opties staan op het punt af te lopen en stieren kunnen voor een crisis komen te staan; De SEC kan spot <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s al op 4 juli goedkeuren; Het <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Virtual Machine Team lanceerde ZK Rollups-service om Bitcoin uit te breiden; Blast-airdrops gaven 17 miljard tokens uit.</h2><p>Laten we eerst de handelsactiviteiten van onderzoeken. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor ontvingen op 26 juni Grayscale Bitcoin spot ETF’s (GBTC) een instroom van $4,3 miljoen aan fondsen; Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een instroom van $18,6 miljoen en ARK 21 Shares Bitcoin spot ETF (ARKB) kende een uitstroom van $4,9 miljoen. Volgens officiële gegevens van Grayscale had Grayscale GBTC op 26 juni 275.895,653 BTC’s in bezit, een daling van ongeveer 499,811 ten opzichte van de vorige handelsdag.</p>
<p><strong>Deze week verloopt $9,25 miljard aan BTC-opties en stieren kunnen een crisis tegemoet zien.</strong><br>De maandelijkse vervaldatum in juni is bijzonder cruciaal omdat het het einde van de eerste helft van 2024 markeert. Vanuit historisch perspectief is dit moment de op één na grootste vervaldatum in elke markt, inclusief de traditionele financiële sector. Nu is technologiegigant Nvidia, met een marktwaarde van $3 biljoen, met 12% gedaald sinds het bereiken van een historisch hoogtepunt op 20 juni, en beleggers zijn bijzonder bezorgd.</p>
<p>Deze week zullen de $9,25 miljard BTC-opties aflopen. Het is twee maanden geleden sinds het Bitcoin-halveringsevenement, en 57% van de bullish weddenschappen is gericht op $70.000 of hoger. Echter, de zwakke prestaties van de markt in de afgelopen twee weken hebben druk gelegd op de bulls. Als Bitcoin rond 61.500 dollar blijft op 28 juni, zullen BTC-opties geprijsd op 62.000 dollar en 64.000 dollar niet aflopen, en zullen put-opties geprijsd op 58.000 dollar en 60.000 dollar aflopen.</p>
<p>De huidige dynamiek op de financiële markt is vergelijkbaar met die van 2021, wat kan aangeven dat er een bearmarkt op komst is. Het signaal omvat de groeiende kloof tussen de S&amp;P 500-index en de evenwichtsgewogen indexen. De beschikbaarheid van call- en put-optiecontracten op 28 juni is afhankelijk van de afwikkelingsprijs. Voor Bitcoin’s long positie van $ 64.000 is nodig om verliezen te vermijden, en de longpositie moet dringend een ondersteuningsniveau van $ 60.000 handhaven vóór de vervaldatum op 28 juni.</p>
<p><strong>De SEC kan een plek goedkeuren <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF’s al vanaf 4 juli</strong><br>Industriële leidinggevenden en andere relevante bronnen hebben onthuld dat de Amerikaanse Securities and Exchange Commission (SEC) mogelijk al op 4 juli spot Ethereum ETF’s kan goedkeuren. Aangezien de onderhandelingen tussen vermogensbeheermaatschappijen en toezichthoudende instanties de laatste fase zijn ingegaan, zoeken acht vermogensbeheermaatschappijen, waaronder BlackRock en VanEck, goedkeuring van de SEC om deze fondsen te lanceren.</p>
<p>Bronnen wezen erop dat het aanpassen van de distributiedocumenten is gevorderd tot het alleen aanpakken van kleine problemen. Een advocaat die samenwerkte met een bepaald uitgevend bedrijf verklaarde ook dat dit alleen het ‘laatste polijsten’ is en goedkeuring niet langer dan één of twee weken kan duren. ETF-analist Eric Balchunas had eerder verwacht dat de goedkeuring al op 2 juli zou kunnen plaatsvinden.</p>
<p>Het fonds dat in januari werd gelanceerd om Bitcoin spotprijzen te volgen, is een van de meest succesvolle fondsen op de ETF-markt en heeft ongeveer $8 miljard aan activa aangetrokken. Aan het einde van juni was de omvang van deze negen producten bijna $38 miljard, maar het aandeelhouderschap van Grayscale Bitcoin Trust daalde tot $17,8 miljard en het bedrijf converteerde ook zijn $27 miljard Bitcoin Trust naar een ETF.</p>
<p>De SEC weigerde hierop commentaar te geven. SEC-voorzitter Gary Gensler verklaarde eerder deze maand in een interview met Reuters dat de lanceerdatum gedeeltelijk afhankelijk zal zijn van de snelheid van de reactie van de emittent op regulerende vragen.</p>
<p><strong>Het team van Bitcoin Virtual Machine heeft de ZK Rollups-service gelanceerd om Bitcoin uit te breiden</strong><br>Vorige week lanceerde BVM de zero-knowledge proof service BitZK, die de schaalbaarheid van Bitcoin verbetert door gebruikers in staat te stellen samenvattingen te maken en applicaties van Ethereum naar Bitcoin te migreren. De toename van dergelijke activiteiten heeft meerdere ontwikkelingsteams aangemoedigd om nieuwe manieren te verkennen om Bitcoin uit te breiden en ideeën van andere blockchain-projecten op te nemen.</p>
<p>De toegangsprijs van BVM tot zijn BitZK-service is $99 of meer per maand, en het heeft een groep vroege gebruikers verzameld, waaronder Bitcoin Layer2 RWA Chain, POWD3R Blockchain en Octopus Bridge. De maandelijkse vergoeding dekt de kosten van geheugen, CPU en opslag die verband houden met het draaien van de tweede laag van Bitcoin.</p>
<p>De Bitcoin Virtual Machine (BVM) werd gelanceerd in januari 2023, en volgens het whitepaper van het project: “BVM is een state machine vergelijkbaar met een Ethereum virtual machine die Bitcoin als datalaag gebruikt om consensus op handelsniveau te bereiken. Deze aanpak stelt BVM in staat om te fungeren als een universele state machine, gebruikmakend van de beveiliging en gegevensbeschikbaarheid van Bitcoin zonder extra netwerk- of consensusprotocollen.”</p>
<p>Dit protocol heeft als doel om het Bitcoin-netwerk zo universeel mogelijk te maken en is een van de verschillende schaalbaarheidsoplossingen voor Bitcoin. De vraag naar schaalbaarheidsoplossingen begon vorig jaar toen protocollen zoals Ordinals en Runes werden gelanceerd, wat leidde tot een toename van de vraag naar blockspace. Deze oplossingen begonnen aandacht te krijgen, wat resulteerde in stimulering van on-chain activiteiten in het Bitcoin-netwerk.</p>
<p>De schaalbaarheid van Bitcoin is altijd een uitdaging geweest, of het nu gaat om het vergroten van de blokgrootte of het ontwikkelen van schaalbare laag 2 oplossingen. Zero knowledge proof wordt gebruikt in de blockchainwereld om gegevens te comprimeren en is de basis geworden voor veel van de meest populaire rollups op Ethereum.</p>
<p><strong>Blast airdrops uitgegeven 17 miljard tokens</strong><br>Het Ethereum Layer 2 schaalbaarheidsnetwerk Blast heeft om 10.00 uur Eastern Time op woensdag 17 miljard BLAST-tokens verdeeld onder de vroege gebruikers van zijn netwerk.</p>
<p>Parsec Finance’s blockchain verkenningstool toont aan dat meer dan 35% van de airdropped BLASTs binnen de eerste paar uur na de lancering van de token geclaimd zijn.</p>
<h2 id="h2-Markttrends20Het20Layer2verhaal20wordt20geleidelijk20aan20verlaten20door20de20markt20de20ogen20zijn20gericht20op20de20inflatiegegevens20die20vrijdag20worden20vrijgegeven119330"><a name="Markttrends: Het Layer2-verhaal wordt geleidelijk aan verlaten door de markt, de ogen zijn gericht op de inflatiegegevens die vrijdag worden vrijgegeven." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Het Layer2-verhaal wordt geleidelijk aan verlaten door de markt, de ogen zijn gericht op de inflatiegegevens die vrijdag worden vrijgegeven.</h2><p>BTC: Bitcoin is na een stijging boven $62,000 gedaald en consolideert momenteel rond $61,000. Deze consolidatiefase geeft aan dat de markt op zoek is naar nieuwe richtingen en dat investeerders wachten op verdere marktsignalen.</p>
<p>ETH: <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum prijs</a> is licht gedaald tot ongeveer $3,380; echter blijft de ETH/BTC wisselkoers sterk.</p>
<p>Altcoins: Na de algemene stijging van gisteren, is de huidige stijging van Altcoins afgenomen. Deze situatie duidt meestal op het verwerken van de vroege winsten op de markt en er kan vraag zijn naar een korte termijn correctie.</p>
<h3 id="h3-Macroeconomie26071"><a name="Macroeconomie:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie:</h3><p>Amerikaanse aandelen: Blijven stijgen, wat wijst op het vertrouwen van investeerders in het economisch vooruitzicht. Maar tegelijkertijd stijgt ook de Amerikaanse dollarkoers. De markt maakt zich grote zorgen over de aankomende inflatie-indexgegevens die op vrijdag worden vrijgegeven en die een aanzienlijke invloed zullen hebben op het toekomstige monetaire beleid.</p>
<h3 id="h3-Markt20Hotspots707351"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Layer2 Project Blast: BLAST werd gisteravond gelanceerd op Gate en heeft momenteel een marktwaarde van $2,7 miljard. Het Blast punt airdrop model is niet gebruiksvriendelijk voor grote spelers en is nog niet gelanceerd op meer hoogwaardige handelsplatforms. De prijsprestatie van Blast geeft tot op zekere hoogte aan dat de markt het verhaal van Ethereum Layer2 links laat liggen, en investeerders op zoek kunnen zijn naar nieuwe groeipunten.</p>
<p>Lijst van stablecoin projecten: LISTA blijft stijgen, en brak vanochtend door de $0.8 heen. Deze week kondigde Lista het begin aan van een nieuwe mijnbouwronde, met LISTA/ <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> De jaarlijkse mijnbouwopbrengst van Lista is gestegen tot 245%. Gemeenschapsgebruikers schatten dat op basis van de mijnbouwopbrengst van Lista, de prijspiek van LISTA-tokens rond de $1,2 kan liggen.</p>
<p>KAS van de Pow-keten: KAS is gestegen en nadert een historisch hoogtepunt. De officiële aankondiging is dat Kaspa Chain zich in de toekomst zal richten op Meme coins. Na de halvering van BTC zijn veel BTC-miningbedrijven overgestapt op het mijnen van KAS met hun rekenkracht.</p>
<p>Meme-sectie: Trump en Biden zullen morgen om 21.00 uur Beijing-tijd hun presidentsdebat houden. Het concepttokens van de Amerikaanse verkiezingen, zoals MAGA en PEOPLE, zijn het waard om op te letten en kunnen door debatten korte-termijn prijsschommelingen ervaren.</p>
<p>Na een periode van aanpassing en consolidatie op de huidige markt, zouden investeerders nauwlettend de vrijgave van macro-economische gegevens en veranderingen in markttrends moeten volgen. Vooral in de Meme-sector zijn er bepaalde korte-termijn beleggingsmogelijkheden. Voor langetermijninvesteerders zal het observeren van de trends van BTC en ETH, evenals veranderingen in macro-economisch beleid, helpen bij het ontwikkelen van robuustere beleggingsstrategieën.</p>
<h2 id="h2-Macro20Handelen20in20volatiliteit20vr20de20publicatie20van20inflatiedata20met20Wall20Street20die20iets20hoger20sluit20Aziatische20aandelenmarkten20dalen20Japanse20yen20stort20in886924"><a name="Macro: Handelen in volatiliteit vóór de publicatie van inflatiedata, met Wall Street die iets hoger sluit; Aziatische aandelenmarkten dalen, Japanse yen stort in" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Handelen in volatiliteit vóór de publicatie van inflatiedata, met Wall Street die iets hoger sluit; Aziatische aandelenmarkten dalen, Japanse yen stort in</h2><p>Op 26 juni sloten de belangrijkste Amerikaanse aandelenindexen woensdag licht hoger na een volatiele handelsdag. Beleggers blijven voorzichtig tot het presidentiële debat in de VS en het langverwachte inflatierapport van de Federal Reserve worden vrijgegeven.</p>
<p>De prestaties van de index zijn als volgt: de Dow Jones-index steeg met 0,04%, de Standard &amp; Poor’s-index steeg met 0,16% en de Nasdaq-index steeg met 0,49%.</p>
<p>Chipfabrikant Nvidia steeg met 0,25% voor het sluiten, waardoor de vorige daling werd gladgestreken. Grote technologieaandelen zoals Apple, Amazon en Tesla boekten ook winst. Sommige analisten hebben echter bezorgdheid geuit over Nvidia, omdat ze geloven dat geopolitieke kwesties het bedrijf aanzienlijk kunnen beïnvloeden.</p>
<p>Er zullen deze week meerdere economische gegevens worden vrijgegeven, waarvan de prijsindex voor persoonlijke consumptie (PCE) op vrijdag bijzonder belangrijk is. Dit is de voorkeursinflatie-indicator voor de Federal Reserve om het monetair beleid te bepalen. Analisten geloven dat investeerders nog steeds afwachten op het presidentiële debat van morgen en de PCE-gegevens. Ondertussen hebben investeerders eerder deze week hun inzet verhoogd op niet-technologie-industrieën.</p>
<p>Als gevolg van bezorgdheid over inflatie daalden de Aziatische aandelenmarkten op donderdag 27 juni en stegen de obligatierendementen. De Nikkei-index in Japan daalde met 1% en de breedste aandelenindex van de MSCI Asia Pacific-regio daalde met 0,5%.</p>
<p>De Amerikaanse rente ondersteunde de Amerikaanse dollar op de valutamarkt, met een tweemaandelijkse hoogtepunt van 106,13 tegen een mandje valuta’s op woensdag. Als gevolg van hardnekkige inflatie en sterke economische gegevens zijn de verwachtingen van renteverlagingen in de Verenigde Staten onderdrukt, waarbij de Amerikaanse dollarkoers deze maand met 1,3% is gestegen en bijna 1,5% in het kwartaal. De Nieuw-Zeelandse dollar daalde verder met 0,1% op donderdag tot een dieptepunt van zes weken van $0,6069, terwijl het pond daalde tot een dieptepunt van zes weken van $1,2613. De Amerikaanse dollar bereikte een dieptepunt van zes weken ten opzichte van het pond en de New Yorkse dollar.</p>
<p>De wisselkoers van de Japanse yen ten opzichte van de Amerikaanse dollar is 160,7, iets lager dan het 38-jarig hoogtepunt dat op donderdag werd bereikt. Deze gespannen sentiment maakt risicovolle activa op de financiële markt bijzonder kwetsbaar.</p>
<p>De Japanse yen daalde woensdag tot een historisch dieptepunt van 171,79 ten opzichte van de euro, waarbij de yen tegenover de Amerikaanse dollar op 171,57 stond tijdens de Aziatische sessie, lager dan het niveau dat Japan in april en mei tot ingrijpen aanzette. Op donderdag verklaarde de Japanse minister van Financiën, Junichi Suzuki, dat hij geen commentaar zou geven op het wisselkoersniveau. Hij herhaalde de zorgen van de regering over de impact van de depreciatie van de yen op de economie en houdt de valutamarkt nauwlettend in de gaten.</p>
<p>De versnelling van de inflatie tot een zesmaandelijkse hoogte in mei beïnvloedde het rendement van de Australische staatsobligaties van drie jaar, die op woensdag met 18 basispunten sprongen. Het steeg op donderdag met 10 basispunten tot 4,21%, in navolging van de beweging van de verkoop van Amerikaanse schatkistpapier ‘s nachts.</p>
<p>Wat betreft grondstoffen daalden de futures voor Brent ruwe olie met 0,4% naar $84,92 per vat, een daling van 3% in dit kwartaal.</p>
<p>Vanwege de stijging van de opbrengst is de prijs van goud gedaald en wordt verhandeld voor $2.297 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 standpunten 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 zullen juridische stappen worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>