RGFnZWxpamtzIG5pZXV3cyB8IEdCVEMgbmVnYXRpZXZlIHByZW1pZSBibGlqZnQgdmVya2xlaW5lbiwgYmVsZWdnZXJzIHppam4gYnVsbGlzaCBvcCBCVEMgU3BvdCBFVEYncywgZm9jdXMgb3AgQ1BJIHZhbmF2b25k

2023-07-12, 05:40

<p><img src="https://gimg2.gateimg.com/image/article/16891433850712.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Bitcoin20spot20ETFs20zijn20moeilijk20te20weerstaan20de20claimswebsite20van20FTX20is20online20en20FTT20is20met202420gestegen108530"><a name="Crypto Dagelijks Overzicht: Bitcoin spot ETF’s zijn moeilijk te weerstaan, de claims-website van FTX is online, en FTT is met 24% gestegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s zijn moeilijk te weerstaan, de claims-website van FTX is online, en FTT is met 24% gestegen</h2><p>Onlangs plaatste Robert Kiyosaki, auteur van het best verkochte boek ‘Rich Dad Poor Dad’, op social media dat ervan uitgaande dat de BRICS-landen volgende maand de lancering van door goud gedekte handelsvaluta aankondigen, dit de huidige waardering van de Amerikaanse dollar zou kunnen veranderen.</p>
<p>Gezien de aanstaande waardedaling van de Amerikaanse dollar, stelde Kiyosaki voor dat volgers goud en zilver kopen om zich in de komende maanden te beschermen tegen de stijgende inflatie. Daarnaast voorspelt Kiyosaki dat de Bitcoin-prijzen volgend jaar $120.000 zullen bereiken.</p>
<p>De prijs van Bitcoin heeft de afgelopen periode zijn hoogste niveau in 13 maanden bereikt, met een maximale stijging van 3,28%, waardoor het $31.500 bereikte. Dit komt voornamelijk doordat fondsbeheerders, waaronder BlackRock, ‘s werelds grootste vermogensbeheerder, van plan zijn om spot te lanceren. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Beursgenoteerde fondsen (ETF’s) genoteerd in de Verenigde Staten. NASDAQ heeft de aanvraag voor het noteren van BlackRock ETF’s opnieuw ingediend, nadat de Amerikaanse effectenregulator enkele zorgen had geuit over de oorspronkelijke aanvraag.</p>
<p>Voormalig voorzitter van de U.S. Securities and Exchange Commission (SEC), Jay Clayton, heeft echter zijn mening geuit over de Bitcoin spot ETF. Toen de SEC de Bitcoin futures ETF goedkeurde, geloofde de SEC dat de bescherming van de markt voor uiteindelijke investeerders voldoende was, maar destijds zag het geen dergelijke bescherming op de spotmarkt, dus maakte het een onderscheid. Ik geloof dat instellingen die momenteel hebben aangevraagd voor Bitcoin spot ETFs geloven dat deze verschillen nu zijn verdwenen en dat spotproducten nu minder weerstand en een hogere efficiëntie hebben voor investeerders. Het is moeilijk om weerstand te bieden tegen de goedkeuring van Bitcoin spot ETFs.</p>
<p>Komt FTX weer terug? Volgens The Block heeft FTX een klantclaimsportaal gelanceerd. Volgens de informatie op de website kunnen individuele klanten toegang krijgen tot hun accountinformatie en aanvragen indienen die zullen worden opgenomen in het faillissementsproces van hoofdstuk 11 van FTX. De website zal toegankelijk zijn voor klanten die accounts hebben bij FTX.com, FTX US, Blockfolio, FTX EU, FTX JP en Liquid.</p>
<p>Na de lancering van deze FTX claims-website kende FTT een kortstondige toename. Marktgegevens tonen aan dat de FTT op $1,72 stond, met een dagelijkse stijging van meer dan 24%. Momenteel is de FTX claims-portaalwebsite niet beschikbaar en de reden is nog niet geïdentificeerd.</p>
<p>Sinds BlackRock, een vermogensbeheermaatschappij, heeft aangevraagd voor de lancering van spot bitcoin ETF’s in de Verenigde Staten, is de negatieve premie van Grayscale Bitcoin Trust (GBTC) met meer dan $19 miljard ten opzichte van de intrinsieke waarde (NAV) blijven afnemen.</p>
<p>Volgens de gegevens van Ycharts is de negatieve premie van GBTC eind vorig jaar gestegen tot bijna 50% en zal deze voor het grootste deel van 2023 rond de 40% liggen. Na echter de indiening van documenten door BlackRock bij de Amerikaanse Securities and Exchange Commission (SEC) medio juni, begon de negatieve premie scherp te dalen en daalde vorige week tot 26%, het laagste niveau sinds mei 2022. Momenteel bedraagt de negatieve premie ongeveer 27%.</p>
<p>Het geeft aan dat de korting op het Grayscale Bitcoin Trust Fund aanzienlijk is afgenomen, wat erop wijst dat mensen meer verwachtingen hebben voor het omzetten van spot Bitcoin Exchange Traded Funds (ETF’s).</p>
<p>Wat betreft gegevens toont het laatste rapport van DappRadar aan dat in het tweede kwartaal van 2023 het totale bedrag aan vergrendelde waarde (TVL) van DeFi is afgenomen tot $77,6 miljard, een afname van 7,1% ten opzichte van de vorige maand. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> is nog steeds de leider op het gebied van DeFi, hoewel de TVL van DeFi op het Ethereum-netwerk licht is gedaald met 2% in vergelijking met het vorige kwartaal. Aan de andere kant heeft de Amerikaanse SEC begin juni een rechtszaak aangespannen tegen Binance en beweerde dat <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> (MATIC) behoorde tot effecten, wat een aanzienlijke impact had op de twee belangrijkste blockchains, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Ketting en veelhoek. De TVL van de <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain is met 19% gedaald, waardoor het de meest gecontracteerde blockchain is van alle statistieken; De TVL op de Polygon-keten is met ongeveer 8% gedaald, wat de aanzienlijke impact van Amerikaanse regelgevende instanties verder aantoont.</p>
<p>Het aantal gestorte ETH bereikte 23,9 miljoen, wat ongeveer 20% is van het totale aantal. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a>. Maar toen beleggers voorzichtig werden over regelgevingsrisico’s, vertraagde de instroom van fondsen na de aanvankelijke hausse. Sinds de upgrade in Shanghai is er een netto instroom van 4,5 miljoen ETH gestaked, wat heeft geleid tot een toename van de wachttijd voor de vestiging van nieuwe validators tot ongeveer anderhalve maand, en een vertraging van de snelheid van de instroom van fondsen in de afgelopen maand. Tom Wan, een analist bij 21Shares, een investeringsmaatschappij voor digitale activa, verklaarde in een rapport dat “de vertraging van het staken waarschijnlijk te wijten is aan regelgevend toezicht door CEX.</p>
<p>Volgens Dune-gegevens is het huidige aantal ERC-6551-accounts meer dan 2.000 en momenteel 2017. Er wordt gemeld dat ERC-6551 een slim contractaccount biedt voor elke ERC-721-token, waardoor ERC-721-tokens activa kunnen bezitten en kunnen interageren met applicaties zonder bestaande ERC-721 slimme contracten of infrastructuur te wijzigen.</p>
<h2 id="h2-Belangrijkste20trends20in20tokens20van20vandaag655565"><a name="Belangrijkste trends in tokens van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends in tokens van vandaag</h2><h3 id="h3-BTC97563"><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/1689143428BTC.png" alt=""><br>Het vieruursdiagram blijft convergentie onderzoeken, met meerdere onsuccesvolle korte terugtrekkingen. Het wacht op een nieuwe terugtrekking boven het convergentieniveau. Het opwaartse doel blijft onveranderd op $32.235 en $33.085. Het bovenste doel is $36.500 en $41.550.</p>
<h3 id="h3-ETH506924"><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/1689143455ETH.png" alt=""><br>Korte termijn stabiliteit rond het niveau van $1.857, met een geschatte voortdurende uitdaging van het niveau van $1,9K. Ochtendcorrectie naar $1.880 met aanhoudende volumecontractie en convergentie. Langetermijnstrategie wacht op een hertest van het niveau van $2.000 om de midterm trend te verschuiven van bearish naar bullish.</p>
<h3 id="h3-LTC115331"><a name="LTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1689143476LTC.png" alt=""><br>Het korte-termijnpotentieel van het hoofd-en-schouderspatroon moet worden gecontroleerd voor een mogelijke hertest van het niveau van $104,02. Als het terugtrekt, zal de stijgende trend blijven streven naar het niveau van $126,26, en een voortdurende handhaving kan leiden tot een test van het weerstandsniveau van $128,15.</p>
<h3 id="h3-BCH43864"><a name="BCH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BCH</h3><p><img src="https://gimg2.gateimg.com/image/article/1689143494BCH.png" alt=""><br>Uitbreken uit het symmetrische driehoekspatroon, het test het belangrijke weerstandsniveau op $269.08, bereikt de bovengrens van de convergentie in de ochtend. De streefdoelen van de bounce zijn $345 en $385. De korte termijn strategie hangt af van het convergentiepatroon om de richting te bepalen.</p>
<h2 id="h2-Macro20consumptie20en20kredietgroei20vertragen20kan20CPI20vanavond20het20marktvertrouwen20stimuleren505435"><a name="Macro: consumptie en kredietgroei vertragen, kan CPI vanavond het marktvertrouwen stimuleren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: consumptie en kredietgroei vertragen, kan CPI vanavond het marktvertrouwen stimuleren?</h2><p>De ‘strengste’ bankregulerende maatregel in de Verenigde Staten is van kracht geworden en legt strengere kapitaaleisen op aan een breder scala van banken. Vicevoorzitter van de Federal Reserve, Michael Barr, kondigde regelgevende hervormingen aan voor instellingen met een vermogen van $100 miljard of meer, waarbij strengere kapitaalnormen worden voorgesteld en banken worden verplicht extra kapitaal aan te houden dat kan worden gebruikt om eventuele verliezen op te vangen.</p>
<p>Bovendien is de groei van het consumentenkrediet in de Verenigde Staten in mei aanzienlijk vertraagd. Het niet-revolving consumentenkrediet (voornamelijk autoleningen en studieleningen) is voor het eerst sinds de impact van de COVID-19-pandemie gedaald.</p>
<p>Francois Villeroy de Galhau, lid van het bestuurscomité van de Europese Centrale Bank, gelooft dat de inflatie zal blijven dalen en tegen 2025 terug zal keren naar het niveau van 2%; We naderen het hoogtepunt van de rentetarieven en zodra we dit bereiken, zullen we het gedurende een bepaalde periode op dit niveau moeten handhaven.</p>
<p>De ZEW economische welvaartsindex voor de Eurozone in juli was -12,2, een nieuw dieptepunt sinds december vorig jaar, met een eerdere waarde van -10; De ZEW economische statusindex voor juli was -44,4, met een eerdere waarde van -41,9.</p>
<p>De werkloosheidsgraad volgens de ILO in het VK voor de drie maanden tot mei bedraagt 4%, wat een nieuw hoogtepunt is sinds januari 2022, met een verwachte 3,8%, in vergelijking met de vorige 3,8%; De werkloosheidsgraad steeg in juni naar 4%, ten opzichte van de vorige 3,9%. Het aantal fulltime werknemers in het VK is afgenomen, de gegevens van de arbeidsmarkt waren zwak en de activiteitsgraad blijft terugkeren naar normaal.</p>
<p>Over het algemeen toont de analyse van de wereldwijde macro-economische markt enkele trends en veranderingen, waaronder vertraging van de groei van consumentenkrediet, stijgende correlatie tussen aandelen en schulden, en lager dan verwachte wereldwijde private equity-activiteit. Laten we dus kijken of de belangrijke gegevens die vanavond worden vrijgegeven het marktvertrouwen kunnen versterken.</p>
<p>Vanavond om 20:30 uur zullen investeerders zich richten op de Amerikaanse CPI van juni, evenals de discussie over inflatie door Richmond Fed-voorzitter Thomas Barkin (die stemrecht heeft in 2024).</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 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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>