RGFnZWxpamtzIG5pZXV3cyB8IEdyYXlzY2FsZSBoZWVmdCBhYW5nZXZyYWFnZCBvbSB6aWpuIEV0aGVyZXVtLXRydXN0Zm9uZHMgb20gdGUgemV0dGVuIGluIGVlbiBTcG90IEVURjsgQml0Y29pbi1wb3J0ZWZldWlsbGVzIG1ldCAxMDAuMDAwLTEwLjAwMCBtdW50ZW4gaGViYmVuIHNpbmRzIDEgc2VwdGVtYmVyIGluIHRvdGFhbCAkIDE

2023-10-03, 06:08

<p><img src="https://gimg2.gateimg.com/image/article/16963132151003.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Express20Grayscale20heeft20een20aanvraag20ingediend20om20zijn20Ethereum20Trust20Fund20om20te20zetten20in20een20Spot20ETF20Bitcoinportefeuilles20met201000001000020munten20hebben20sinds20120september20in20totaal2011720miljard20opgebouwd20het20rendement20op20de2030jarige20Amerikaanse20staatsobligatie20is20gestegen20naar20481520Grayscale20Investments20heeft20een2019b4aanvraag20ingediend20om20zijn20520miljard202020Ethereum2020Private20Trust20ETHE20in20een20ETF673108"><a name="Crypto Daily Express: Grayscale heeft een aanvraag ingediend om zijn Ethereum Trust Fund om te zetten in een Spot ETF; Bitcoin-portefeuilles met 100.000-10.000 munten hebben sinds 1 september in totaal $1,17 miljard opgebouwd; het rendement op de 30-jarige Amerikaanse staatsobligatie is gestegen naar 4,815%. Grayscale Investments heeft een 19b-4-aanvraag ingediend om zijn $5 miljard   Ethereum  Private Trust, ETHE, in een ETF." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Express: Grayscale heeft een aanvraag ingediend om zijn <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Trust Fund om te zetten in een Spot ETF; Bitcoin-portefeuilles met 100.000-10.000 munten hebben sinds 1 september in totaal $1,17 miljard opgebouwd; het rendement op de 30-jarige Amerikaanse staatsobligatie is gestegen naar 4,815%. Grayscale Investments heeft een 19b-4-aanvraag ingediend om zijn $5 miljard <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Private Trust, ETHE, in een ETF.</h2><p>Volgens CoinShares kende digitale activa-investeringen vorige week een nettostroom van $21,2 miljoen, na een periode van zes weken van uitstroom. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> beleggingsproducten kenden deze week een netto instroom van $20,4 miljoen, Ethereum beleggingsproducten kenden een netto uitstroom van $1,5 miljoen, beleggingsproducten die <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> shorten kenden een netto uitstroom van $1,5 miljoen, en <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Beleggingsproducten zagen een nettostroom van $5,1 miljoen.</p>
<p>Het rendement op de Amerikaanse staatsobligatie op 30-jarige termijn steeg naar 4,815%, het hoogste niveau sinds 2010.</p>
<p>Volgens gegevens van The Block is de handelsvolume van CEX in september gedaald tot $311,92 miljard, het laagste niveau sinds november 2020.</p>
<p>Het derde kwartaal van 2023 meldde de ‘meest ernstige financiële verliezen’ in de cryptosector van het jaar, waarbij incident na incident plaatsvond die crypto-gebruikers bijna $700 miljoen kostten, volgens een kwartaalverslag van het blockchain-beveiligingsbedrijf CertiK. Specifiek wees CertiK in het rapport erop dat er in juli, augustus en september 2023 in totaal 184 beveiligingsincidenten hebben plaatsgevonden, resulterend in crypto-activaverliezen van meer dan $699 miljoen, wat het bedrag van $320 miljoen in het eerste kwartaal en $313 miljoen in het tweede kwartaal overtreft.</p>
<p>Dagen geleden organiseerde het International Financial Planning Standards Board (FPSB) een enquête over crypto-activa (Crypto Assets), waarbij financiële planners (CFPCM) uit 13 landen aanwezig waren. Ze analyseerden de huidige regelgeving van crypto en stelden richtingen voor voor de toekomstige regulering. In het bijzonder stelden ze voor dat wetgevers prioriteit geven aan de regulering van de volgende doelen bij het ontwerpen van het toezichtskader: 1. Classificeer crypto-producten als eenvoudige producten en complexe producten, 2. Marketing en verkoop van crypto-activa, 3. Social media-influencers (zoals KOL) of financiële influencers (Fin-fluencers).</p>
<p>Santiment’s gegevens tonen aan dat Bitcoin-portefeuilles die 100.000-10.000 munten bevatten sinds 1 september in totaal $1,17 miljard hebben verzameld.</p>
<p>Volgens DefiLlama-gegevens is de TVL van <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> gegroeid tot $339 miljoen, het hoogste niveau sinds het begin van het jaar. SOL wordt momenteel verhandeld op $24,1 en is in 24 uur tijd met 11% gestegen.</p>
<p>Vandaag heeft het Bitcoin-beveiligde deelprotocol Babylon het minimaal levensvatbare product (MVP) van zijn Bitcoin-stakingprotocol gedemonstreerd bij Cosmoverse in Istanbul, Turkije. Het doel van het product is om ongebruikte Bitcoin in te zetten om de beveiliging van proof-of-stake-ketens te verbeteren. Volgens gegevens van Glassnode ligt meer dan 66% van de Bitcoin-circulatie (ongeveer $329 miljard) stil. Eerder dit jaar bracht het Babylon-team het Bitcoin-timestampingprotocol uit, dat kan worden gebruikt door proof-of-stake (PoS)-netwerken om de externe beveiliging te verbeteren.</p>
<h2 id="h2-Macro20Het20rendement20op20de20Amerikaanse2030jarige20schatkist20steeg20naar20481520De20Fed20kan20de20rente20verder20verhogen20tegen20het20einde20van20het20jaar966638"><a name="Macro: Het rendement op de Amerikaanse 30-jarige schatkist steeg naar 4,815%; De Fed kan de rente verder verhogen tegen het einde van het jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Het rendement op de Amerikaanse 30-jarige schatkist steeg naar 4,815%; De Fed kan de rente verder verhogen tegen het einde van het jaar</h2><p>Een reeks havikachtige toespraken die dinsdag in de vroege ochtend werden gehouden door functionarissen van de Federal Reserve hadden een verkoelend effect op de cryptomarkt.</p>
<p>In een toespraak meldde Powell, de voorzitter van de Federal Reserve, dat het een consistente doelstelling van de Fed is om een sterke arbeidsmarkt te behouden en dat het handhaven van prijsstabiliteit een noodzakelijke stap is om dit doel te bereiken. In het latere stadium van de economische expansie zullen de laagste inkomensgroepen de meest duidelijke stijging in hun persoonlijk inkomen zien.</p>
<p>Tijdens de bankvergadering van maandag, vermeldde Fed Governor Bowman in een toespraak dat hij de renteverhoging van de Fed zal blijven goedkeuren als de inflatie niet op tijd kan worden teruggebracht tot 2%.</p>
<p>Een andere havik, Mester van de Fed, bevestigde duidelijk de mogelijkheid van renteverhoging van de Fed. Hij erkende de rol die het rentebeleid speelt bij het beheersen van de inflatie, maar gaf toe dat het beleid er nog steeds niet in slaagde de inflatie tot een bevredigend niveau te brengen. Deze situatie zal gronden bieden voor de Fed om dit jaar de rente verder te verhogen.</p>
<p>Hoewel er verschillende meningen zijn onder Fed-functionarissen over het al dan niet verhogen van de renteverhoging nog een keer dit jaar, is het een consensus onder hen dat een hoge rente gedurende een bepaalde periode zal blijven, totdat het 2% inflatiedoel is bereikt.</p>
<p>Vanwege het wijdverspreide pessimisme op de markt steeg de Amerikaanse dollarindex (DXY) naar 106,50 na een zijwaartse beweging. Op de markt van vandaag (3 oktober) steeg de nieuwste Amerikaanse dollarindex naar 107,09. Ondertussen steeg het rendement op Amerikaanse 30-jaars staatsobligaties naar 4,815%, het hoogste niveau sinds 2010.</p>
<p>Het algehele beeld van de cryptomarkt was ook ontmoedigend. Bijvoorbeeld, Bitcoin daalde snel nadat het gisteren steeg naar een maximum van $28.580 en bevindt zich nu dicht bij het startpunt van de stijging van gisteren.</p>
<p>Om de inflatie te bestrijden, heeft de Fed de rente 11 keer verhoogd sinds maart 2022, waarbij de rentevoet van bijna nul naar 5,25%-5,5% is gestegen. De ISM-productie-industrie heeft onlangs een onverwachte PMI getoond, wat een andere reden zal zijn voor de Fed om de rentevoet te blijven handhaven. Hoewel het hoge rentebeleid van de Fed een afnemend randeffect op de cryptomarkt vertoont, zullen we de ontwikkeling van de Amerikaanse economie blijven volgen en het effect van het rentebeleid op de wereldeconomie en de cryptomarkt onderzoeken om ons beter aan te passen aan de veranderingen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Peter L.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Sally Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het herdrukken van het artikel is toegestaan 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>