RGFnZWxpamtzIE5pZXV3cyB8IEJpdGNvaW4gRVRGJ3MgYmxpanZlbiBuZXR0byBpbnN0cm9taW5nZW4gZ2VuZXJlcmVuOyBHb2xkbWFuIFNhY2hzIHZhbiBwbGFuIG9tIGRyaWUgZ2V0b2tlbmlzZWVyZGUgZm9uZHNlbiB0ZSBsYW5jZXJlbjsgSGV0IE1pbmlzdGVyaWUgdmFuIEVuZXJnaWUgc3RlbHQgZWVuIG5pZXV3ZSBlbnF1w6p0ZSB

2024-07-11, 03:44

<p><img src="https://gimg2.gateimg.com/image/article/17206692761_9.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Goldman20Sachs20van20plan20om20drie20getokeniseerde20fondsen20te20lanceren20Het20Ministerie20van20Energie20is20begonnen20met20het20opstellen20van20een20nieuwe20Bitcoinmijnwerkersenqute20Starknetstaking20Plan20gaat20live20op20het20mainnet20in20Q4695035"><a name="Crypto Dagelijkse Samenvatting: Goldman Sachs van plan om drie getokeniseerde fondsen te lanceren; Het Ministerie van Energie is begonnen met het opstellen van een nieuwe Bitcoin-mijnwerkersenquête; Starknet-staking Plan gaat live op het mainnet in Q4" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Goldman Sachs van plan om drie getokeniseerde fondsen te lanceren; Het Ministerie van Energie is begonnen met het opstellen van een nieuwe Bitcoin-mijnwerkersenquête; Starknet-staking Plan gaat live op het mainnet in Q4</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 Farside Investor data had Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 10 juli een fondsafvloeiing van $8,2 miljoen. Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een instroom van $57,8 miljoen, Bitwise Bitcoin spot ETF (BITB) een instroom van $4,7 miljoen, en ARK 21Shares Bitcoin spot ETF (ARKB) een instroom van $11,3 miljoen.</p>
<p><strong>Goldman Sachs is van plan om drie getokeniseerde fondsen te lanceren</strong></p>
<p>Goldman Sachs plant om tegen het einde van dit jaar drie tokenisatieprojecten te lanceren om de cryptosector te betreden. Volgens het tijdschrift Fortune heeft Matthew McDermott, Global Head of Digital Assets bij Goldman Sachs, gezegd dat een van deze fondsen zich zal richten op de Amerikaanse fondsenindustrie, de andere op de Europese schuldenmarkt, en het derde plan is om een tokenized asset markt te creëren.</p>
<p>In vergelijking met concurrenten zoals BlackRock, Franklin Templeton en Fidelity heeft Goldman Sachs ervoor gekozen om voornamelijk gebruik te maken van gelicentieerde netwerken in plaats van volledig gedecentraliseerde blockchain, voornamelijk vanwege regelgevingszorgen. Goldman Sachs begon al in 2021 samen te werken met gelicentieerde blockchain-netwerken en lanceerde crypto-derivatenhandelsproducten die worden afgewikkeld in contanten.</p>
<p>De CEO van BlackRock is van mening dat tokenisatie de ‘volgende generatie’ van de markt is en het door blockchain aangedreven financiële product van het bedrijf, BUIDL, heeft onlangs een marktwaarde van meer dan $500 miljoen gehad. Franklin Templeton heeft op blockchain gebaseerde inkomstenfondsen gelanceerd en gerelateerde BENJI-tokens op de markt gebracht. <a href="/price/stellar-xlm" rel="nofollow noopener noreferrer" target="_blank">Stellar</a> en <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, terwijl Fidelity International aandelen heeft getokeniseerd in geldmarktfondsen.</p>
<p>McDermott is al lange tijd een voorstander van digitale transformatie, vooral blockchain. Hij hielp bij het opzetten van de digitale activadivisie van Goldman Sachs in 2021 en leidde inspanningen om door cash afgewikkelde crypto-afgeleide handelsproducten te lanceren. Sharmin Mossavar Rahmani, Chief Investment Officer van Goldman Sachs Wealth Management, verklaarde echter in een interview met The Wall Street Journal in april dat ze geen enkele vraag van klanten naar cryptocurrency zag.</p>
<p><strong>Het Ministerie van Energie is begonnen met het opstellen van een nieuwe enquête voor Bitcoin miners</strong></p>
<p>Nadat het in een Texaanse rechtbank was aangeklaagd wegens pogingen om ‘dringende verzoeken om gegevensverzameling’ te verkrijgen, heeft het Amerikaanse Ministerie van Energie zijn inspanningen vernieuwd om een onderzoek uit te voeren gericht op het verkrijgen van informatie over het gebruik van energie voor crypto mining in de Amerikaanse werklastbewijs. Het Bureau voor Energie-informatie (EIA), de statistische afdeling van het Ministerie van Energie, hield woensdag zijn eerste openbare discussie in de hoop een beter enquêteplan te ontwerpen.</p>
<p>Steve Harvey van EIA wees er tijdens de discussie op dat EIA hoopt drie belangrijke kwesties aan te pakken voordat nieuwe onderzoeken worden ontworpen: ten eerste, welke specifieke factoren zijn het belangrijkst bij het energieverbruik van PoW cryptomining, zoals waargenomen door deelnemers uit de industrie of omstanders; Ten tweede, welke gegevens moet de instelling verzamelen; Ten derde, is er bestaande informatie die enquêtes kan vervangen of de kosten kan verlagen? Harvey wees er ook op dat tijdens het eerste terugroeponderzoek de EIA, na het ontwikkelen van een “ruwe” voorlopige schatting, ontdekte dat cryptomining goed was voor 0,6% tot 2,3% van het totale energieverbruik in de Verenigde Staten.</p>
<p>Na voltooiing moet het nieuwe onderzoek worden goedgekeurd door het Ministerie van Energie en zal worden opgenomen in het Federal Register, waarmee een openbare beoordelingsperiode van 60 dagen wordt gestart. Daarna zal de EIA opmerkingen opnemen, de enquêteresultaten opnieuw indienen en nog eens 30 dagen voor een openbare beoordeling bieden.</p>
<p>De meeste mensen zijn van mening dat de EIA-enquête een aanval is op de crypto-industrie, maar er zijn ook enkele insiders uit de industrie die de EIA-enquête steunen en zich zorgen maken over de impact van cryptocurrencies op het milieu. Lee Blacher, voorzitter van het Texas Blockchain Committee, suggereerde dat EIA een uitgebreider onderzoek zou moeten ontwerpen, rekening houdend met de opkomst van energie-intensieve industrieën zoals kunstmatige intelligentie en cloud computing. Sommige mensen, waaronder voormalig ambtenaar van het ministerie van Energie Tom Mepps, hebben erop gewezen dat Bitcoin-mijnbouw kan helpen de ontwikkeling van hernieuwbare energie te stimuleren en “load balancing”-overeenkomsten te sluiten met nutsbedrijven.</p>
<p><strong>Het Starknet Token-stakingprogramma wordt in het vierde kwartaal van 2024 gelanceerd op het mainnet</strong></p>
<p>Starknet zal naar verwachting in het vierde kwartaal van 2024 functionaliteit voor het inzetten van native tokens introduceren. Kernontwikkelaar StarkWare heeft het Starknet Improved Protocol (SNIP) ingediend om netwerkstaking te implementeren. Het SNIP-voorstel vermeldt het StarkWare Phase 1 stakingplan, dat een belangrijke stap is in het oprichten van een stakingsgemeenschap en -technologie, waardoor er nieuwe mogelijkheden ontstaan voor gebruikers en ontwikkelaars. De eerste fase van het stakingplan zal een toestemmingsloos on-chain stakingprotocol en stakingdelegatie aannemen.</p>
<p>Als het voorstel wordt goedgekeurd, kunnen gebruikers het toevertrouwen aan de stakers of zelf stakers worden, en de beloning zal evenredig zijn met het ingezette bedrag, op basis van de wijzigingen in de voorgestelde muntenproductiecurve die in februari is vrijgegeven. Voordat fondsen worden opgenomen, is er een vergrendelingsperiode van 21 dagen.</p>
<h2 id="h2-Markttrends20Bitcoin20spot20ETFs20blijven20nettostromen20hebben20en20de20markt20wacht20op20CPIgegevens20om20123020uur20UTC160698"><a name="Markttrends: Bitcoin spot ETF’s blijven nettostromen hebben en de markt wacht op CPI-gegevens om 12:30 uur (UTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Bitcoin spot ETF’s blijven nettostromen hebben en de markt wacht op CPI-gegevens om 12:30 uur (UTC)</h2><p><strong>BTC</strong><br>Na de stijging van BTC naar $59.000 is de prijs van BTC gedaald en consolideert momenteel rond $57.500. Het is vermeldenswaard dat Bitcoin spot ETF’s nog steeds grote nettostromen hebben, wat enige ondersteuning voor de markt kan bieden.</p>
<p><strong>ETH</strong><br>ETH heeft relatief sterk gepresteerd en consolideert momenteel rond de $3.100. De verwachtingen van de markt dat ETH ETF’s worden goedgekeurd, nemen geleidelijk toe, wat een belangrijke factor kan zijn die de kracht van Ethereum-prijzen stimuleert.</p>
<p><strong>Marktindicatoren</strong><br>De AHR999-index: Vandaag stond op 0,7, wat aangeeft dat de markt geschikt is voor reguliere investeringen.</p>
<p>Angst en hebzucht index: Op 29, wat aangeeft dat het marktsentiment nog steeds in een staat van angst verkeert. Volgens historische gegevens, wanneer het marktsentiment voortdurend angstig is, bevindt de markt zich vaak in het onderste bereik.</p>
<h3 id="h3-Macroeconomie177982"><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: stegen allemaal met meer dan 1%. Voorzitter van de Federal Reserve, Powell, verklaarde dat het onwaarschijnlijk is dat de rentetarieven tot zeer lage niveaus zullen dalen, wat een zekere invloed heeft gehad op de risicomarkt.</p>
<p>Amerikaanse CPI-inflatiegegevens: De markt wacht op de Amerikaanse CPI-inflatiegegevens voor juni die vanavond om 12:30 uur (UTC) worden vrijgegeven. Deze gegevens zullen een belangrijke factor zijn die van invloed is op het marktsentiment en de trends.</p>
<h3 id="h3-Markt20Hotspots27872"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>Ton Ecosysteem:</strong><br>Meme Project Dogs: kondigt een airdrop aan voor alle Telegram-gebruikers, met een dagelijkse toename van meer dan 1 miljoen abonnees op zijn abonnementskanaal. Dogs is een puur Meme-project dat momenteel geen game- of andere applicatiebonussen heeft. Het beeld is ontworpen op basis van de huisdierenhond van Telegram-oprichter Duroff.</p>
<p><strong>Meme Sector:</strong><br>PEIEPEI, RATS, MANEKI, PEW, MAGA en andere Meme munten zijn gestegen en vormen de belangrijkste trend in de markt. Meme projecten trekken vaak in korte tijd veel investeerders en aandacht vanwege hun hoge verspreiding en betrokkenheid van de gemeenschap.</p>
<p><strong>BTC Ecosysteem:</strong><br>STX, SATS en andere projecten hebben oververkochte rebounds meegemaakt. Onder hen zal SATS dienen als het Gas-token voor Layer2 uitgegeven door Unisat, met toevoeging van daadwerkelijke use cases, met een stijging van bijna 80% in 7 dagen.</p>
<h3 id="h3-Samenvatting354379"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h3><p>De huidige markt heeft enige kracht getoond, gedreven door Bitcoin en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, maar over het algemeen neigt het sentiment nog steeds naar angst. Op macro-economisch gebied zal de stijging van Amerikaanse aandelen en de aanstaande publicatie van Amerikaanse CPI-gegevens een aanzienlijke invloed hebben op de markt. Wat betreft markthotspots zijn het Ton Eco en Meme-projecten het middelpunt van de aandacht geworden. Beleggers moeten voorzichtig blijven in de huidige marktomgeving en zich richten op macro-economische gegevens en veranderingen in het marktsentiment, terwijl ze ook projecten met praktische toepassingen en sterke gemeenschapsondersteuning in de gaten houden.</p>
<h2 id="h2-Macro20Wereldwijde20aandelenmarkten20bereiken20nieuwe20hoogtepunten20vr20de20publicatie20van20inflatietesten622738"><a name="Macro: Wereldwijde aandelenmarkten bereiken nieuwe hoogtepunten vóór de publicatie van inflatietesten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wereldwijde aandelenmarkten bereiken nieuwe hoogtepunten vóór de publicatie van inflatietesten</h2><p>Op 10 juli sloten de Nasdaq en S&amp;P 500 index hoger, waarmee ze historische hoogtepunten bereikten, voornamelijk gedreven door de stijging van Nvidia en andere zwaargewicht Wall Street aandelen.</p>
<p>Dit is de zevende opeenvolgende keer dat de Nasdaq-index een nieuw hoogtepunt heeft bereikt, en de zesde opeenvolgende keer dat de S&amp;P 500-index een nieuw hoogtepunt heeft bereikt. De toespraak van de voorzitter van de Federal Reserve, Jerome Powell, heeft de marktverwachtingen voor een renteverlaging in september aangewakkerd, waarbij de S&amp;P 500-index voor het eerst door de 5.600 punten brak.</p>
<p>Specifiek stegen de drie belangrijkste indices: de S&amp;P 500 index steeg met 1,02%; De Nasdaq-index steeg met 1,18%; De Dow Jones-index steeg met 1,09%.</p>
<p>Technologieaandelen blijven sterk presteren, met Micron Technology die 4% stijgt, Nvidia 2,7% stijgt en Advanced Micro Devices 3,9% stijgt. Apple steeg met 1,9%, bereikte een historisch hoogtepunt met een beurswaarde van $3,6 biljoen.</p>
<p>De Amerikaanse inflatiegegevens die deze week worden vrijgegeven, omvatten het Consumentenprijsindexrapport van donderdag en het Producentenprijsindexrapport van vrijdag. Volgens waarnemingen van de Federal Reserve van de Chicago Mercantile Exchange wordt verwacht dat de waarschijnlijkheid van een renteverlaging van 25 basispunten door de Federal Reserve in september zal toenemen van 70% op dinsdag en 45% een maand geleden tot 74%.</p>
<p>Het kwartaalverslagseizoen van het tweede kwartaal gaat deze week van start, en grote banken zullen op vrijdag hun resultaten bekendmaken, wat zal testen of die ambitieuze grote beursgenoteerde bedrijven hun sterke momentum kunnen voortzetten en hun waardering kunnen rechtvaardigen.</p>
<p>Op 11 juli bereikte de aandelenmarkt een historisch hoogtepunt van Tokio tot New York, en handelaren wachten op Amerikaanse economische gegevens, die naar verwachting enige verlichting in inflatie zullen laten zien en de weg vrijmaken voor een renteverlaging in september.</p>
<p>Obligaties en de Amerikaanse dollar blijven stabiel, terwijl de wisselkoers van de yen/US dollar zwak blijft op 161, en nadert zijn laagste niveau in decennia.</p>
<p>De meest gebruikte aandelenindex van MSCI in de Asia Pacific regio, exclusief Japan, steeg met 1% en bereikte het hoogste niveau in twee jaar; De Nikkei Index van Japan steeg met 1% naar een historisch hoogtepunt van 42426 punten; De Taiwanese aandelenmarkt steeg met 1,25% en bereikte een historisch hoogtepunt; De Australische ASX 200 index steeg met 0,89% en staat dichtbij een historisch hoogtepunt.</p>
<p>De Chinese aandelenmarkt volgt de marktmomentum en het BBP-gegevens zullen op maandag worden vrijgegeven. De Hang Seng Index in Hong Kong steeg met 1%, terwijl de hoofdaandelen op het vasteland met 0,4% stegen. De wisselkoers van de Chinese yuan ten opzichte van de Amerikaanse dollar bleef stabiel op 7,2738, enigszins herstellend van het dieptepunt dat op woensdag werd bereikt.</p>
<p>Met betrekking tot grondstoffen zijn de olieprijzen licht gestegen, gedreven door sterke signalen van de Amerikaanse vraag naar benzine. Brent ruwe olie futures stegen met 35 cent, of 0,4%, naar $85,43 per vat. Amerikaanse ruwe olie futures stegen met 36 cent, of 0,5%, naar $82,47 per vat.</p>
<p>Goud steeg met 0,2% naar $2373 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 beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het herposten van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>