RGFnZWxpamtzIG5pZXV3cyB8IE1hcmt0IGlzIHZvbGF0aWVsOyBCVEMgaGVlZnQgbm9nIHN0ZWVkcyB0ZSBtYWtlbiBtZXQgZW5vcm1lIHZlcmtvb3BkcnVrOyBWYW5FY2sgZW4gMjFTaGFyZXMgdmFuIHBsYW4gb20gU29sYW5hIEVURidzIHRlIGxhbmNlcmVuOyBCbGFzdCBsYW5jZWVyZGUgZGUgdHdlZWRlIGZhc2UgdmFuIGhldCBiZWx

2024-07-09, 03:34

<p><img src="https://gimg2.gateimg.com/image/article/17204959281_7.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20Duitse20overheid20heeft20Bitcoin20overgedragen20Mt20Goxterugbetalingen20beginnen20toenemende20BTCverkoopdruk20VanEck20en2021Shares20plannen20Solanagebaseerde20ETFs20te20lanceren20Blast20lanceerde20de20tweede20fase20van20het20beloningsprogramma668887"><a name="Crypto Dagelijkse Samenvatting: De Duitse overheid heeft Bitcoin overgedragen, Mt. Gox-terugbetalingen beginnen, toenemende BTC-verkoopdruk; VanEck en 21Shares plannen Solana-gebaseerde ETF’s te lanceren; Blast lanceerde de tweede fase van het beloningsprogramma." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De Duitse overheid heeft <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> overgedragen, Mt. Gox-terugbetalingen beginnen, toenemende BTC-verkoopdruk; VanEck en 21Shares plannen Solana-gebaseerde ETF’s te lanceren; Blast lanceerde de tweede fase van het beloningsprogramma.</h2><p>Laten we eerst de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor ontvingen Grayscale Bitcoin spot ETF’s (GBTC) op 8 juli een instroom van $25,1 miljoen aan fondsen. Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een instroom van $61,5 miljoen, Bitwise Bitcoin spot ETF (BITB) had een instroom van $11 miljoen, en ARK 21Shares Bitcoin spot ETF (ARKB) had een instroom van $8,4 miljoen.</p>
<p><strong>De Duitse regering heeft Bitcoin overgedragen en de terugbetalingen van Mt. Gox beginnen, waardoor de verkoopdruk op BTC toeneemt</strong></p>
<p>De Duitse overheid verkoopt opnieuw Bitcoin, waarbij voor $900 miljoen aan Bitcoin naar gecentraliseerde beurzen wordt overgeboekt, wat erop wijst dat de overheid van plan is de resterende $1,3 miljard aan Bitcoin-bezit te verkopen. Volgens Arkham Intelligence werden ongeveer 16.309 Bitcoins overgeboekt naar portefeuilles die als Duitse overheid-gerelateerd zijn gemarkeerd, en op 8 juli werden deze Bitcoins meerdere malen overgeboekt naar meerdere externe adressen. Dit is de maximale dagelijkse afwikkeling van Bitcoin.</p>
<p>Bovendien werden 700 Bitcoins (ter waarde van meer dan $38,5 miljoen) naar een portemonnee met de naam ‘139Po’ gestuurd, die eerder financiering had ontvangen van de Duitse regering. De prijs van Bitcoin daalde aanzienlijk na deze overdrachten, van een hoogtepunt van $58.200 naar $54.278, een daling van maximaal 6,75%.</p>
<p>De Duitse regering heeft meer dan de helft van haar verkoopacties voltooid. Sinds de start met de verkoop van digitale activa in juni, is haar bezit gedaald van 50.000 Bitcoins naar 23.788 Bitcoins, met een waarde van $1,3 miljard. Dit heeft een grootschalige liquidatie van de gehele cryptomarkt veroorzaakt, met in totaal $425 miljoen aan geliquideerde hefboomposities, waaronder $216 miljoen aan long liquidatie, volgens Coinglass-gegevens.</p>
<p>Ondertussen zijn crediteuren van de failliete cryptobeurs Mt. Gox begonnen met hun langverwachte terugbetalingsproces, dat zal worden terugbetaald in Bitcoin en Bitcoin Cash. Dit heeft de verkoopdruk op Bitcoin versterkt. De heer Kobayashi, de curator van het faillissement van Mt. Gox, verklaarde dat Bitcoin en <a href="/price/bitcoin-cash-bch" target="_blank" class="blog_inner_link">Bitcoin Cash</a> zijn begonnen om sommige crediteuren terug te betalen via verschillende aangewezen cryptotransacties.</p>
<p>Er zijn meldingen dat Bitstamp, de crypto-beurs, van plan is om snel zijn deel van de Bitcoin-terugbetalingen aan Mt. Gox-schuldeisers toe te wijzen, hoewel het tot twee maanden de tijd zal hebben om deze taak te voltooien na ontvangst van Bitcoin. Arkham Intelligence, een blockchain-analysebedrijf, verklaarde dat er eerder een kleine hoeveelheid Bitcoin uit de portemonnee die verband hield met Mt. Gox werd overgemaakt, waarvan $2,71 miljard werd overgemaakt uit de koude portemonnee van de beurs.</p>
<p><strong>VanEck en 21Shares zijn van plan om te lanceren <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>-gebaseerde ETF’s</strong></p>
<p>De Chicago Board of Options (Cboe) heeft officieel de Securities and Exchange Commission (SEC) verzocht om asset managers VanEck en 21Shares toe te staan <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> op basis van exchange-traded funds (ETF’s) op de markt te brengen.</p>
<p>Cboe heeft maandag twee 19b-4 documenten ingediend bij de SEC, waarin wordt verzocht deze producten te lanceren na het verkrijgen van goedkeuring van de regelgevende instantie. Zodra de SEC bevestigt dat de documenten zijn ontvangen, is er een periode van 240 dagen waarin regelgevende instanties beslissingen moeten nemen over deze producten, en Solana (SOL) zal deze ETF’s ondersteunen.</p>
<p>Rob Marrocco, Global Head of ETP Listing bij Cboe Global Markets, verklaarde in een verklaring: “Na succesvol de eerste batch van Amerikaanse spot Bitcoin ETF’s op onze beurs te hebben genoteerd en goedkeuring te hebben verkregen van de Amerikaanse Securities and Exchange Commission voor onze notering van spot” <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Volgens ETF-regels richten we ons momenteel op de groeiende interesse van investeerders in Solana - de op twee na meest actieve cryptocurrency na Bitcoin en Ethereum.</p>
<p>Cboe wordt de genoteerde beurs voor vijf spot <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s als deze producten worden goedgekeurd. Brancheanalisten voorspellen dat de SEC de Ethereum ETF al deze week zal goedkeuren, en veel uitgevers hebben herziene S-1 formulieren ingediend op vrijdag en vroeg op maandag.</p>
<p><strong>Blast lanceerde de tweede fase van het beloningsprogramma</strong></p>
<p>Op 8 juli kondigde Blast de lancering aan van de tweede fase van het beloningsprogramma, waarbij 10 miljard BLAST wordt toegewezen ter ondersteuning van de ontwikkeling van mobiele Dapps en gebruikers te stimuleren om deze Dapps te gebruiken via de Blast App. De beloning is 5 miljard BLAST voor zowel Blast Points als Blast Gold. Gebruikers verdienen punten via ETH, WETH, USDB en BLAST-balansen, terwijl Dapps Gold verdienen op basis van prestaties. De eerste Gold-toewijzing vindt plaats op 8 juli. Gebruikers die de Blast App installeren, kunnen Golden Tickets ontvangen, waardoor hun punten- en Gold-aanwervingssnelheid verbetert.</p>
<p>Op 9 juli kondigde Blast aan dat Fase 2 Gold Distributie 1 gelanceerd was. Bij de initiële Gold allocatie zal 10 miljoen Gold worden toegewezen aan Dapp, waarvan 9,5 miljoen Gold gereserveerd zal worden voor bestaande Dapp en 500.000 Gold gereserveerd zal worden voor nieuw gelanceerde Dapp. Voeg een categorie van ‘Voorspellende Markt’ toe met een gewicht van 4.</p>
<p>Bovendien zal er in augustus een nieuwe Big Bang-competitie worden gelanceerd, waarbij gouden beloningen, cash grants en gezamenlijke marketingkansen worden geboden.</p>
<h2 id="h2-Markttrends20De20marktbrede20volatiliteitsindex20toont20aan20dat20de20huidige20BTCprijs20geschikt20is20voor20reguliere20investeringen486912"><a name="Markttrends: De marktbrede volatiliteitsindex toont aan dat de huidige BTC-prijs geschikt is voor reguliere investeringen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De marktbrede volatiliteitsindex toont aan dat de huidige BTC-prijs geschikt is voor reguliere investeringen</h2><p>BTC consolideert rond $56.500 en vertoont een brede en volatiele trend. Gisteren had de spot ETF van Bitcoin een nettostroom van $107 miljoen, wat de aanhoudende interesse en investeringsenthousiasme in Bitcoin op de markt aantoont.</p>
<p>ETH vertoonde ook een brede volatiliteitstrend, waarbij het gisteren daalde tot ongeveer $2.820 en weer omhoog sprong boven $3.000. De ETH/BTC wisselkoers is versterkt. De markt verwacht dat de ETH-spot-ETF op 15 juli zal worden goedgekeurd, wat de prijs van Ethereum verder kan stimuleren.</p>
<p>Altcoins zijn fluctuerend, waarbij de Meme sector sterker presteert.</p>
<h3 id="h3-Marktindicatoren92578"><a name="Marktindicatoren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktindicatoren</h3><p>De AHR999-index: Vandaag staat de AHR999-index op 0,68, wat geschikt is voor reguliere investeringen en aangeeft dat de huidige BTC-markt een zekere investeringswaarde heeft.</p>
<p>Angst en hebzucht index: De huidige angst en hebzucht index staat op 37, en het marktsentiment is verbeterd in vergelijking met gisteren, maar het bevindt zich nog steeds in de angstzone.</p>
<h3 id="h3-Macroeconomie39720"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt schommelen, wat wijst op marktonzekerheid.</p>
<p>Monetair beleid: De verwachting van renteverlagingen in de Verenigde Staten neemt toe. De opmerkingen van de voorzitter van de Federal Reserve, Powell, over het monetair beleid op dinsdagavond en woensdag om 22.00 uur kunnen een significante invloed hebben op de markt.</p>
<h3 id="h3-Markt20Hotspots282209"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Meme sector: Meme munten zoals NOT, BILLT, BONK en PEPE zijn aanzienlijk hersteld, en de Meme sector heeft sterker gepresteerd op de herstelmarkt.</p>
<p>Ethereum-ecosysteem: Met de verwachting dat ETH-spot-ETF’s volgende week zullen worden goedgekeurd, zal ETH/BTC sterker worden. ENS, TIA, DYM, XAI en andere projecten zijn aanzienlijk hersteld, wat wijst op de voortdurende aandacht van de markt voor het Ethereum-ecosysteem. Er wordt verwacht dat TIA in oktober 120% van de huidige tokenomloop zal ontgrendelen, wat mogelijk een aanzienlijke impact op de markt kan hebben.</p>
<p>Point airdrop: De datawebsite Debank kondigde gisteren aan dat het de point xp zal airdroppen, en dat er in de toekomst mogelijk token airdrops zullen zijn. Debank is een on-chain datawebsite gemaakt door een Chinees team.</p>
<h3 id="h3-Samenvatting116627"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h3><p>De huidige markt wordt gekenmerkt door brede schommelingen, waarbij Bitcoin en Ethereum schommelen tussen belangrijke steun- en weerstandsniveaus. De Meme-sector en het Ethereum-ecosysteem hebben uitstekend gepresteerd, en het marktsentiment is verbeterd, maar voorzichtigheid is nog steeds geboden. Op macro-economisch vlak kan de verklaring van het monetaire beleid van de Federal Reserve een aanzienlijke invloed hebben op de markt en vereist nauwe aandacht. Beleggers kunnen redelijke beleggingsstrategieën ontwikkelen op basis van de AHR999-index en de angst- en hebzuchtindex, en markttrends.</p>
<h2 id="h2-Macro20De20SampP2050020en20Nasdaq20bereikten20historische20hoogtepunten20waarbij20beleggers20zich20richtten20op20inflatiedata20en20het20financile20rapportageseizoen708812"><a name="Macro: De S&amp;P 500 en Nasdaq bereikten historische hoogtepunten, waarbij beleggers zich richtten op inflatiedata en het financiële rapportageseizoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De S&amp;P 500 en Nasdaq bereikten historische hoogtepunten, waarbij beleggers zich richtten op inflatiedata en het financiële rapportageseizoen</h2><p>Op maandag 8 juli sloten de S&amp;P 500 en Nasdaq-indexen op historische hoogte. Beleggers richten zich op nieuwe inflatiedata, opmerkingen van voorzitter van de Federal Reserve Jerome Powell en het komende kwartaalverslagseizoen.</p>
<p>De drie belangrijkste indices zijn: de S&amp;P 500 index steeg met 0,10%, de Nasdaq index steeg met 0,28% en de Dow Jones index daalde met 0,08%.</p>
<p>Aandelen van chipbedrijven leidden de winsten, waarbij Nvidia bijna 2% steeg, Intel meer dan 6% steeg en AMD met 4% steeg, waardoor de Philadelphia Semiconductor Index met 1,9% steeg.</p>
<p>Handelaren zullen nauwlettend de consumentenprijsgegevens volgen die op donderdag worden vrijgegeven en de producentenprijsgegevens die op vrijdag worden vrijgegeven om de voortgang van de Federal Reserve bij het bestrijden van inflatie te ueren. Beleggers zijn bezorgd dat te lang wachten met renteverlagingen de arbeidsmarkt kan schaden en de economie in een recessie kan storten. Daarom is Powells tweejaarlijkse getuigenis voor de Senaat en het Huis van Afgevaardigden op dinsdag en woensdag cruciaal.</p>
<p>Citigroup, JPMorgan Chase en Wells Fargo Bank zullen het financiële rapportageseizoen van het tweede kwartaal op Wall Street op vrijdag aftrappen. De aandelenprijs van Citigroup steeg met 1,1%, terwijl de aandelenprijs van Wells Fargo met 1% daalde.</p>
<p>Op dinsdag 9 juli openden Aziatische aandelenmarkten hoger met Wall Street, omdat de markt hoopte dat Federal Reserve-voorzitter Jerome Powell later die dag dovish opmerkingen zou maken over het versoepelende vooruitzicht, terwijl de Amerikaanse dollar stabiel bleef nabij een vier weken laag.</p>
<p>De MSCI Asia Pacific aandelenindex steeg met 0,3%, net onder het hoogste punt in twee jaar. De Nikkei-index van Japan steeg met 1%, waarmee het een historisch hoogtepunt bereikte; Chinese blue-chip aandelen daalden met 0,85%; De Hang Seng-index in Hong Kong daalde met 0,57%.</p>
<p>De Amerikaanse dollar bleef stabiel op een vier weken laagte van 104,98 op de valutamarkt tegenover een mandje valuta’s. De zwaar beschadigde Japanse yen en Chinese yuan konden opgelucht ademhalen, waarbij de wisselkoers van yen / Amerikaanse dollar op 160,84 bleef. Vorige week daalde het naar een 38-jarig dieptepunt van 161,96; De offshore RMB / USD-wisselkoers zweefde op 7,2874, nadat deze vier opeenvolgende handelsdagen was gestegen en wegging van een laag van zeven en een half maanden.</p>
<p>De euro heeft wat verloren terrein herwonnen, wat heeft geleid tot aanzienlijke schommelingen op de Franse aandelenmarkt. Terwijl investeerders de schokkende verkiezingsresultaten van het Franse parlement verwerkten, vernauwde de risicopremie van Franse obligaties ten opzichte van Duitse obligaties.</p>
<p>Wat betreft grondstoffen, heeft de orkaan een belangrijk olieproductiecentrum in Texas, VS getroffen, maar de verliezen waren kleiner dan verwacht en de olieprijzen bleven bijna ongewijzigd.</p>
<p>De goudprijs steeg met 0,2% tot $2.363,31 per ounce en daalde met 1,4% ‘s nachts.</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 opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>