RGFnZWxpamtzIG5pZXV3cyB8IEJpam5hIDMwSyBCVEMncyB3ZXJkZW4gb3ZlcmdlYnJhY2h0IG5hYXIgQ0VYIHZvb3JkYXQgR3JheXNjYWxlIGRlIHJlY2h0c3phYWsgd29uLCBkZSBrYW5zIGRhdCBCVEMgU3BvdCBFVEYncyB3b3JkZW4gZ29lZGdla2V1cmQgYmlubmVuIDIwMjMgaXMgaG9vZw==

2023-08-31, 04:40

<p><img src="https://gimg2.gateimg.com/image/article/16934566850831.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Bijna2030K20BTCs20werden20overgeboekt20naar20CEX20voordat20Grayscale20de20rechtszaak20won20en20de20kans20dat20Bitcoin20spot20ETFs20binnen20202320worden20goedgekeurd20is20hoog998770"><a name="Crypto Dagelijkse Samenvatting: Bijna 30K BTC’s werden overgeboekt naar CEX voordat Grayscale de rechtszaak won, en de kans dat Bitcoin spot ETF’s binnen 2023 worden goedgekeurd is hoog" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Bijna 30K BTC’s werden overgeboekt naar CEX voordat Grayscale de rechtszaak won, en de kans dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s binnen 2023 worden goedgekeurd is hoog</h2><p>Laten we eens kijken naar de voortgang met betrekking tot de overwinning van Grayscale.</p>
<p>Volgens de gegevens van Santiment werden bijna 30.000 BTC’s (ter waarde van ongeveer $822 miljoen) overgemaakt naar adressen die verband houden met gecentraliseerde handelsplatforms vóór de uitspraken van Grayscale en de SEC. De uitspraak leidde tot een stijging van 6% in de Bitcoin-prijzen, waardoor BTC steeg naar $28.000.</p>
<p>Santiment zei: “Voordat Grayscale de rechtszaak won, de voorziening van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het aantal handelsplatforms is aanzienlijk toegenomen. Het is duidelijk dat de betreffende afdelingen weten dat dit resultaat de marktwaarde van de cryptomarkt onvermijdelijk zal verhogen.</p>
<p>Voorheen verzamelden portefeuilles met 100.000 tot 10.000 BTC’s ongeveer $388 miljoen aan BTC’s op de dag voor het nieuws van de overwinning van Grayscale. Gegevens van het Santiment-monitoring laten zien dat walvis- en haai-adressen mogelijk eerder op de hoogte waren gesteld van de resultaten van de Grayscale- en SEC-rechtszaak. Op de dag voordat dit nieuws werd vrijgegeven, verzamelden portefeuilles met 10-10.000 BTC’s BTC’s ter waarde van $388,3 miljoen.</p>
<p>Echter, hoewel Grayscale de rechtszaak wint, is het onwaarschijnlijk dat dit voorkomt dat Bitcoin eindigt met een negatief maandelijks rendement in augustus. Aan het begin van deze maand lag de prijs van BTC nog boven de $29.000, maar het zweeft momenteel boven de $27.000. De prestaties van Bitcoin in augustus hebben onzekerheid gebracht over de trend in september. Recordlage volatiliteit, dalend handelsvolume en een flitscrash in de prijsklasse van $25.000 tijdens augustus.</p>
<p>James Butterfill, onderzoeksdirecteur bij CoinShares, zei dat de prijsdaling in augustus ‘de kwetsbaarheid van Bitcoin benadrukte bij grotere transacties, wat nog ernstiger is geworden in de huidige situatie van lage handelsvolumes.’</p>
<p>Butterfill voorspelt dat marktaarzeling in september kenmerkend zal zijn. Hij verwacht dat handelaren zullen twijfelen tussen opwinding over de mogelijke goedkeuring van ETF-aanvragen en twijfels over goedkeuring door de SEC. Hoewel de uitspraak van woensdag in het voordeel is van Grayscale, zei Butterfill: “Het is onwaarschijnlijk dat dit de goedkeuringsplanning van de SEC zal versnellen, aangezien er nog steeds mogelijkheid is tot hoger beroep.”</p>
<p>Bloomberg ETF-analist James Seyfart tweette: “We verwachten deze week een groot aantal vertraagde bestellingen te ontvangen. Wij zijn van mening dat de kans op goedkeuring kort na de uitspraak van de rechtbank (Bitcoin spot ETF’s) extreem laag is.” Hij is ook van mening dat Bitcoin spot ETF’s voor het einde van 2024 zullen worden gelanceerd, wat vrijwel zeker is.</p>
<p>Bloomberg-analist Eric Balchunas plaatste eerder vandaag: “Analyst James Seyfart en ik hebben de waarschijnlijkheid van de lancering van Bitcoin spot ETF’s dit jaar verhoogd naar 75% (met een waarschijnlijkheid van 95% tegen het einde van 2024).”</p>
<h2 id="h2-Belangrijkste20token20trends20van20vandaag700473"><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-BTC558396"><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/1693456740BTC 0831.png" alt=""></p>
<p>Ondanks de invloed van het nieuws van Grayscale deze week, resulteerde dit slechts in een kleine opleving. Gisteren bereikte het de neklijn op 27.283 Amerikaanse dollars en viel weer terug, wat aangeeft dat de algemene markt er nog steeds een bearish perspectief op heeft. Naar verwachting zal de maandafsluiting rond de 26.975 Amerikaanse dollars liggen.</p>
<h3 id="h3-CYBER588070"><a name="CYBER" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CYBER</h3><p><img src="https://gimg2.gateimg.com/image/article/1693456755CYBER 0831.png" alt=""></p>
<p>De strategie van vorige week omvatte opeenvolgende posities op respectievelijk $4.100, $3.933 en $3.783, gevolgd door een aanzienlijke marktprestatie. Met het doel van $17,79 zoals aangegeven door het patroon van het ‘zwaard uit de schede trekken’ en de snelle en agressieve opwaartse beweging door DWF-marktmakers, is het niet moeilijk voor te stellen dat er op korte termijn mogelijk een laatste golf van marktprestaties zou kunnen zijn.</p>
<p>We hebben gezegd dat het hebben van dergelijke nauwkeurige doelniveaus op de secundaire markt erop duidt dat market makers sterk geconcentreerd zijn in hun handel, net zoals ze opereren op de spotmarkt en de contractmarkt-oogst. CYBER is geen uitzondering.</p>
<p>Voor korte termijn longposities wordt geadviseerd om standvastig te blijven op het ondersteuningsniveau van $8.185, en een conservatieve aanpak zou zijn om te wachten op een doorbraak van de recente hoogte op $8.980 om extra posities in te nemen. Vier weerstandsniveaus zijn $10.479, $11.883, $13.019 en $14.152. Drie opwaartse doelen zijn $12.277, $15.62 en het piekdoel van $17.79.</p>
<h3 id="h3-DOGE984791"><a name="DOGE" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DOGE</h3><p><img src="https://gimg2.gateimg.com/image/article/1693456774DOGE 0831.png" alt=""></p>
<p>De algehele dagelijkse trend is al 835 dagen aanzienlijk dalend en er wordt een significante marktprestatie verwacht voor het einde van het jaar. Als het op $0,05099 blijft, worden sequentiële opwaartse doelen verwacht op $0,10799, $0,15879, $0,43360 en een nieuwe historische hoogte als er een onafhankelijke trend ontstaat.</p>
<h2 id="h2-Macro20Werkgelegenheid20en20GDPgegevens20onder20de20verwachtingen20de20Federal20Reserve20zal20dit20jaar20mogelijk20de20rente20niet20verhogen239834"><a name="Macro: Werkgelegenheid en GDP-gegevens onder de verwachtingen, de Federal Reserve zal dit jaar mogelijk de rente niet verhogen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Werkgelegenheid en GDP-gegevens onder de verwachtingen, de Federal Reserve zal dit jaar mogelijk de rente niet verhogen</h2><p>Spotgoud steeg drie opeenvolgende dagen en bereikte kortstondig de $1.950 tijdens de sessie, en sloot 0,26% hoger op $1.942,42 per ounce. Spotzilver bereikte kortstondig de $25 in intraday-handel, voor het eerst in meer dan een maand. Het herstelde echter zijn intraday-winsten en sloot 0,38% lager op $24,61 per ounce. De drie belangrijkste aandelenindices van de Amerikaanse aandelenmarkt sloten gedurende de dag hoger, met de DJIA 0,11% hoger, de Nasdaq 0,54% hoger en de S&amp;P 500-index 0,39% hoger.</p>
<p>Afgelopen nacht veroorzaakten twee belangrijke gegevens intense marktreacties: het aantal ADP-banen in de Verenigde Staten in juli lag ver onder de marktverwachtingen, in lijn met de onverwachte daling van het aantal vacatures dat de vorige dag werd aangekondigd, en de arbeidsmarkt koelt af;</p>
<p>Het bbp van de Verenigde Staten in het tweede kwartaal werd naar beneden bijgesteld tot 2,1%, lager dan de marktverwachting van 2,4%. De zwakkere dan verwachte economische gegevens van de VS hebben de verwachtingen van investeerders versterkt dat de Federal Reserve de renteverhogingen zal opschorten.</p>
<p>De Federal Reserve zegt vaak: “Neem beslissingen op basis van gegevens”, dus het bevindt zich momenteel in een fase van overreageren op gegevens, of ze nu goed, slecht, belangrijk of onbelangrijk zijn. Omdat de Federal Reserve verwijst naar een uitgebreide reeks gegevens, is het zeker niet een enkele gegevensmodule.</p>
<p>Na het vrijgeven van de gegevens over de werkgelegenheid in de particuliere sector en het herziene bruto binnenlands product (bbp) van het tweede kwartaal van de Verenigde Staten gisteravond, blijven handelaren in federale fondsenrentefutures hun verwachtingen verhogen dat de Federal Reserve dit jaar de rente niet meer zal verhogen.</p>
<p>Volgens de tool Fed Watch van de Chicago Mercantile Exchange (CME) is de kans dat de Federal Reserve in september inactief blijft 90,5%, hoger dan de 86% van een dag geleden. Handelaren verwachten dat de kans om in november en december stil te blijven respectievelijk 57% en 55,5% is, waarbij de federale fondsrente in het bereik van 5,25% tot 5,5% blijft.</p>
<p>De voormalige voorzitter van de Boston Fed verklaarde gisteren (woensdag) dat als de arbeidsmarkt en economische groei blijven vertragen op het huidige trage tempo, de Fed mogelijk een einde maakt aan zijn cyclus van renteverhogingen.</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 beleggingsadvies.<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 juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>