RGFnZWxpamtzIG5pZXV3cyB8IERlIGdvZWRrZXVyaW5nIHZhbiBCaXRjb2luIFNwb3QgRVRGJ3MgemFsICQxIGJpbGpvZW4gdG9ldm9lZ2VuIGFhbiBkZSBtYXJrdGthcGl0YWxpc2F0aWUgdmFuIGNyeXB0bydzLCBUZXNsYSBoZWVmdCBnZWVuIEJUQyB2ZXJrb2NodCBpbiBRMw==

2023-10-19, 04:09

<p><img src="https://gimg2.gateimg.com/image/article/16976939081019.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Fidelity20dient20de20nieuwste20versie20van20Bitcoin20spot20ETF20in20Tesla20heeft20geen20Bitcoin20verkocht20in20het203e20kwartaal758396"><a name="Crypto Dagelijkse Samenvatting: Fidelity dient de nieuwste versie van Bitcoin spot ETF in; Tesla heeft geen Bitcoin verkocht in het 3e kwartaal" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Fidelity dient de nieuwste versie van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF in; Tesla heeft geen Bitcoin verkocht in het 3e kwartaal</h2><p>Een openbaar regulerend document laat zien dat Fidelity een bijgewerkte versie van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF-prospectus naar de SEC, waarin details worden vermeld van bewaarregelingen, mechanismen met betrekking tot hard forks, bronnen voor waardering en prijsstelling, GAAP-naleving, risicodisclosure met betrekking tot regelgevingsonzekerheid, en de energieverbruikskenmerken van mining.</p>
<p>CryptoQuant, een data-analysebedrijf, schreef in een recent rapport dat als Bitcoin spot exchange-traded funds (ETF’s) worden goedgekeurd, Bitcoin een activum van $900 miljard zal worden en de hele cryptomarkt met $1 biljoen zal groeien.</p>
<p>CryptoQuant verklaarde dat als emittenten die een aanvraag indienen om Bitcoin ETF’s te noteren, 1% van hun beheerde activa (AUM) in deze ETF’s investeren, ongeveer $ 155 miljard de Bitcoin-markt kan betreden. Dit is goed voor bijna een derde van de huidige marktkapitalisatie van Bitcoin. Als deze situatie zich voordoet, wordt aangenomen dat de prijs van Bitcoin tussen $ 50.000 en $ 73.000 zal stijgen.</p>
<p>Volgens het model van CryptoQuant was de groei van de marktwaarde van Bitcoin historisch gezien 3-5 keer zijn gerealiseerd kapitaal tijdens eerdere bullmarkten. CryptoQuant voegde eraan toe dat dit aangeeft dat voor elke $1 aan nieuwe fondsen die de Bitcoin-markt betreden, de marktwaarde met $3-5 kan toenemen.</p>
<p>Fox-journalist Eleanor Terrett plaatste op het X-platform dat de SEC cryptocurrencies heeft opgenomen als een belangrijk aandachtspunt van haar herziening in 2024. De meeste cryptocurrency-bedrijven zijn echter niet geregistreerd bij de SEC en betalen daarom geen registratiekosten.</p>
<p>Terrett verklaarde verder: “Betekent dit dat SEC-voorzitter Gary Gensler prioriteit geeft aan de verwerking van cryptocurrencies met behulp van institutionele middelen en fondsen die betaald worden door geregistreerde bedrijven, waarvoor hij nog niet gemachtigd is om toezicht op te houden? Of verwacht de SEC dat er in 2024 meer cryptocurrency-bedrijven zich bij de instelling zullen registreren?” Volgens het laatste nieuws heeft SEC-voorzitter Gary Gensler verklaard dat de SEC nog steeds voorstellen voor Bitcoin spot ETF’s overweegt.</p>
<p>Volgens CoinDesk heeft Standard Chartered Bank plannen om BTC en ETH te hosten voor institutionele klanten in Dubai in Q1 2024. In de toekomst heeft Standard Chartered Bank ook plannen om een cryptocurrency settlement-netwerk te creëren.</p>
<p>Volgens Bloomberg verwacht Galaxy Digital-oprichter Mike Novogratz dat de SEC dit jaar uiteindelijk op de beurs verhandelde fondsen zal goedkeuren voor directe investeringen in Bitcoin. En er wordt gezegd dat de overwinning van Grayscale aanzienlijk is, en belangrijk positief nieuws zal de markt hoger drijven.</p>
<p>Volgens DL News is de houding van de inwoners van Hong Kong ten opzichte van crypto-activa verslechterd na het JPEX-incident. Een enquête van de School of Business Administration aan de Hong Kong University of Science and Technology toont aan dat 41% van de 2200 respondenten van 18 jaar en ouder momenteel niet bereid is om enige crypto-activa te bezitten. Dit resultaat vertegenwoordigt een significante stijging van 12 procentpunten ten opzichte van een vergelijkbare enquête onder 5700 mensen tussen april en mei.</p>
<p>Hoewel 84% van de respondenten beweert gehoord te hebben van virtuele activa, bezit slechts 27% crypto-activa of bezit ze momenteel. Bovendien is ook de wens om in de toekomst crypto-activa te bezitten afgenomen, waarbij slechts 20% van de mensen interesse toont, een daling van 5 procentpunten ten opzichte van de vorige enquête. Van degenen die bereid zijn te investeren in crypto-activa, is 80% van plan om crypto-activa ter waarde van HKD 50000 of minder te bezitten.</p>
<p>Volgens CoinGap heeft Tesla volgens het laatste financiële rapport van het derde kwartaal geen Bitcoin verkocht, wat het vijfde opeenvolgende kwartaal markeert zonder koop- of verkooptransacties. Op 30 september houdt Tesla ongeveer 9720 Bitcoins aan met een marktwaarde van ongeveer $275,6 miljoen. Tesla heeft Bitcoin niet genoemd in zijn financiële rapport van het derde kwartaal, wat aangeeft dat het bedrijf digitale valuta niet heeft omgezet in fiatvaluta. Actief Bitcoin verkopen kan van invloed zijn op de winstgevendheid en de kaspositie, wat zal worden opgenomen in het financiële rapport.</p>
<p>Sinds het tweede kwartaal van vorig jaar heeft Tesla geen Bitcoin meer gekocht of verkocht. In het tweede kwartaal van vorig jaar verkocht Tesla meer dan 30.000 Bitcoins voor $ 936 miljoen, goed voor ongeveer 75% van zijn Bitcoin-bezit. Het bedrijf kocht aanvankelijk begin 2021 Bitcoin ter waarde van $ 1,5 miljard.</p>
<p>Wat betreft gegevens is het marktaandeel van Bitcoin gestegen naar een nieuw hoogtepunt sinds april 2021, tijdelijk gerapporteerd op 49,31%; Het marktaandeel van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> wordt tijdelijk gerapporteerd op 16,72%; Het marktaandeel van USDT wordt tijdelijk gerapporteerd op 7,43%. De huidige totale marktkapitalisatie van cryptocurrencies over het hele netwerk is ongeveer $ 1,1298 biljoen, met een dagelijkse stijging van 0,7%.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20Vandaag110870"><a name="Belangrijkste Token Trends van Vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste Token Trends van Vandaag</h2><h3 id="h3-BTC875056"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1697693943BTC.png" alt=""><br>Het hoogtepunt van deze week bereikte kortstondig $30,000, en er werd geprobeerd om het sleutelondersteuningsniveau van $28,125 vast te houden. Korte termijn weerstand ligt op $29,500. Het middellangetermijn-doorbraakdoel is $33,085. Als dit niveau niet wordt overschreden, kan dit het einde markeren van de oplevingstrend van dit jaar. Het is raadzaam om de weerstandsniveaus te blijven volgen.</p>
<h3 id="h3-ETH531966"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1697693960ETH.png" alt=""><br>Deze week was er een aanzienlijk herstel op de markt, maar de korte termijn en algemene hersteltrends blijven zwak. Het doel voor het herstel op $1.631 is bereikt en het blijft schommelen onder het niveau van $1.570. Het neerwaartse doel blijft rond $1.465 liggen, waardoor een bearish langetermijnstrategie raadzaam is.</p>
<h3 id="h3-STARL266073"><a name="STARL" class="reference-link"></a><span class="header-link octicon octicon-link"></span>STARL</h3><p><img src="https://gimg2.gateimg.com/image/article/1697693982STARL.png" alt=""><br>Een eerder opvallend project tijdens de laatste bullmarkt, het steeg van een basisprijs van $0,00523 naar een piek van meer dan $0,05562, meer dan tien keer. Korte termijn verwachtingen suggereren dat de opwaartse beweging mogelijk compleet is en een terugtrekking naar het ondersteuningsniveau van $0,00321 wordt verwacht.</p>
<h2 id="h2-Macro20Goudprijzen20kunnen20de20200020overschrijden20de20Fed20neigt20naar20een20duifachtige20houding299486"><a name="Macro: Goudprijzen kunnen de $2.000 overschrijden, de Fed neigt naar een duifachtige houding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Goudprijzen kunnen de $2.000 overschrijden, de Fed neigt naar een duifachtige houding</h2><p>De Amerikaanse dollar, goud, Amerikaanse schatkist obligaties en ruwe olie stegen opnieuw tegelijkertijd, wat vergelijkbaar was met de situatie op vrijdag. Maar dit keer is het verschil dat de daling op de Amerikaanse aandelenmarkt veel groter is dan afgelopen vrijdag. Als er opnieuw een abnormale daling is zoals afgelopen nacht, zal het wereldwijde marktsentiment snel verslechteren.</p>
<p>Op dit moment heeft de goudprijs $1.950 bereikt en de mogelijkheid om op korte termijn de $2.000 te overschrijden is sterk toegenomen. Als de situatie in het Midden-Oosten verbetert, zal goud terugtrekken, maar de huidige markt verwacht dat de situatie verder zal escaleren. Ik heb het voorgevoel dat de marktimpact van het Palestijns-Israëlisch conflict veel groter zal zijn dan die van Rusland en Oekraïne, aangezien de situatie nog geen aanzienlijke verslechtering heeft ervaren en de markt al op deze manier heeft gereageerd.</p>
<p>Het rendement op de 10-jarige Amerikaanse staatslening bereikte het hoogste niveau sinds 2007 en sloot af op 4,9042%. Dit is een extra risicopunt voor de markt, aangezien de snelle stijging van de obligatierendementen de enthousiasme van de markt voor aandelen heeft verzwakt. Zodra het rendement op de 10-jarige Amerikaanse staatslening ‘5%’ bereikt, kan dit een verkooprally op de Amerikaanse aandelenmarkt veroorzaken, wat een punt is dat alle analisten van Wall Street nauwlettend in de gaten houden.</p>
<p>Ruwe olie steeg als gevolg van de mogelijke escalatie van het Israëlisch-Palestijnse conflict dat de levering zou kunnen verstoren. Na de oproep van Iran tot een olie-embargo tegen Israël bereikten de WTI-ruwe olieprijzen kortstondig de $90-grens en sloten 0,54% hoger op $88,14 per vat; Brent-ruwe olie naderde $93 in de handel en sloot 0,47% hoger op $91,3 per vat.</p>
<p>De drie belangrijkste Amerikaanse aandelenindices sloten collectief lager, waarbij de Dow Jones Industrial Average met 0,98% daalde, de Nasdaq met 1,62% daalde en de S&amp;P 500-index met 1,34% daalde. Nvidia daalde bijna 4% en viel deze week met 8%.</p>
<p>Federal Reserve-update: Federal Reserve-gouverneur Waller hintte op steun voor stilstand; Brown Book: Sinds september is de economische activiteit bijna onveranderd gebleven en zijn de algemene prijzen matig blijven stijgen; Williams: De rentetarieven moeten lange tijd hoog blijven om de inflatie te beteugelen; Huck is van mening dat de Federal Reserve de pauzeperiode voor renteverhogingen moet verlengen.</p>
<p>Het nieuwste onderzoek van de New York Fed toont aan dat door lagere rentetarieven en leningverlengingsplannen tijdens de pandemie, de basis van Amerikaanse consumenten stabieler is. Na verloop van tijd kunnen sommige gezinnen echter grotere druk ervaren, omdat de terugbetalingen van studieleningen worden hervat en de rentetarieven ook stijgen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</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 enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor 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>