RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBrYW4gc3RpamdlbiBuYWFyICQ1NksgYWxzIEJpdGNvaW4gU3BvdCBFVEYncyB3b3JkZW4gZ29lZGdla2V1cmQsIEdlbWluaSBlbiBEQ0cgd2VyZGVuIGFhbmdla2xhYWdkLCBWUyBiZW9vcmRlZWxkZSBtaWpuZW4gbWV0IENoaW5lc2UgYWNodGVyZ3JvbmQ=

2023-10-20, 04:36

<p><img src="https://gimg2.gateimg.com/image/article/16977803411020.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Gemini20en20DCG20werden20aangeklaagd20VS20beoordeelde20mijnen20met20een20Chinese20achtergrond814558"><a name="Crypto Dagelijks Overzicht: Gemini en DCG werden aangeklaagd; VS beoordeelde mijnen met een Chinese achtergrond" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Gemini en DCG werden aangeklaagd; VS beoordeelde mijnen met een Chinese achtergrond</h2><p>Volgens Bloomberg zijn Gemini Trust Co. en Digital Currency Group (DCG) aangeklaagd door de hoogste wetshandhavingsfunctionarissen van New York wegens vermeende oplichting van klanten voor $1,1 miljard, wat de juridische problemen verergert waarmee de twee bedrijven te maken hebben, die vorig jaar zwaar getroffen werden door de ineenstorting van de cryptomarkt.</p>
<p>De procureur-generaal van New York, Letitia James, heeft donderdag een rechtszaak aangespannen tegen Gemini, dat de cryptocurrency-uitwisseling exploiteert, en de Genesis Global Capital-divisie van DCG, waarin zij beweert dat zij nalatig waren in het bekendmaken van de risico’s van Gemini Earn, een cryptocurrency-uitleenprogramma, aan investeerders en probeerde stijgende verliezen te verbergen. Gemini rapporteerde valse informatie over het leningsrisico van haar joint venture met Genesis aan de klant en onthulde niet dat bijna 60% van haar leningen van derden ooit naar Alameda Research stroomden.</p>
<p>Gemini Earn beweert tot 8% rente te genereren voor Gemini-klanten door Genesis in staat te stellen zijn crypto-activa uit te lenen aan derden. Maar volgens de rechtszaak is er meer dan $1 miljard geïnvesteerd in hedgefonds Three Arrow Capital en heeft Genesis rond dezelfde tijd meer dan $100 miljoen verloren van een andere leningnemer, Babel Finance.</p>
<p>De staat New York heeft zijn wens geuit om Gemini, Genesis en DCG te verbieden om de financiële investeringsindustrie in New York binnen te komen, en streeft ernaar om de ‘onrechtmatige winsten’ van de twee bedrijven terug te vorderen om investeerders te compenseren.</p>
<p>Volgens een onderzoek van The Times heeft het ontdekt <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Mijnen in eigendom of beheerd door Chinese bedrijven in ten minste 12 staten in de Verenigde Staten, met een totaal energieverbruik equivalent aan het energieverbruik van 1,5 miljoen huishoudens. Veel mijnen zijn uitgerust met mijnbouwmachines geproduceerd door BitContinent.</p>
<p>Volgens de gegevens is het aantal apparatuur dat door <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> naar de Verenigde Staten wordt vervoerd sinds China in mei 2021 de Bitcoin-mijnbouw verbood vanwege zorgen over energieverbruik en economische instabiliteit, 15 keer het totaal van de afgelopen vijf jaar. In een recent rapport van het bedrijf staat dat het 90% van de wereldwijde markt voor Bitcoin-mijnbouwapparatuur beheerst. Hoewel er geen duidelijk bewijs is van een verband, verdenkt de VS nog steeds dat deze mijnen die in de VS zijn geopend, verband houden met de Chinese autoriteiten.</p>
<p>In een rapport dat door het Microsoft-team in augustus 2022 aan de Amerikaanse Commissie voor Buitenlandse Investeringen is ingediend, werd gesteld dat de Bitcoin-mijn naast het datacenter van het bedrijf in Wyoming Chinese mensen in staat zou kunnen stellen om ‘uitgebreide inlichtingenoperaties’ uit te voeren, zelfs als er geen directe tekenen van kwaadwillende activiteiten door de entiteit waren.</p>
<p>Volgens geografische informatie bevindt de mijn waarnaar Microsoft verwijst zich niet alleen naast het Microsoft Data Center dat het Pentagon ondersteunt, maar ook op slechts ongeveer een mijl afstand van de luchtmachtbasis die nucleaire intercontinentale ballistische raketten controleert. Uit een betwiste contractrechtszaak blijkt dat de Chinese mijnbouwmachinefabrikant BitContinent deelnemer is aan een mijnbouwlocatie in de buurt van de luchtmachtbasis.</p>
<p>Volgens een anonieme Amerikaanse functionaris vertelde de New York Times dat ze de activiteiten van mijnen in Wyoming al enkele maanden volgen en maatregelen hebben genomen om potentiële inlichtingenverzameling te voorkomen en te verminderen.</p>
<p>JPMorgan-analisten zeggen dat omdat de Amerikaanse SEC niet in beroep is gegaan tegen de recente gerechtelijke uitspraak van Grayscale, verwacht wordt dat de SEC binnen “een paar maanden” meerdere aanvragen voor spot Bitcoin ETF’s kan goedkeuren.</p>
<p>Analisten zeggen dat spot Bitcoin ETF’s hoogstwaarschijnlijk zullen worden goedgekeurd vóór 10 januari 2024, de laatste deadline voor Ark Invest- en 21Shares-aanvragen.</p>
<p>Matriexport, een Singaporees crypto financieel dienstenbedrijf onder Wu Jihan, verklaarde in een rapport dat als de spot Bitcoin ETF van BlackRock wordt goedgekeurd door de Amerikaanse Securities and Exchange Commission, de prijs van Bitcoin kan stijgen tot tussen $42.000 en $56.000. De analyse van Matrixport van 15000 geregistreerde beleggingsadviseurs in de Verenigde Staten voorspelt dat fondsen ter waarde van ongeveer $12 miljard tot $24 miljard kunnen <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> in dergelijke ETF’s.</p>
<h2 id="h2-Belangrijkste20trends20van20vandaag20in20tokens32266"><a name="Belangrijkste trends van vandaag in tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends van vandaag in tokens</h2><h3 id="h3-BTC392656"><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/1697780374BTC.png" alt=""><br>Deze week bereikte het hoogtepunt van BTC kortstondig $30.000 en bleef het boven het kritieke ondersteuningsniveau van $28.125. Op korte termijn ligt de weerstand op $29.500. Het medium-termijn belangrijkste doorbraakdoel is $33.085. Als het dit niveau niet doorbreekt tegen het einde van de maand, kan dit het einde van de rally van dit jaar signaleren. Het is raadzaam om de weerstandsniveaus in de gaten te houden.</p>
<p>Voor een conservatieve longpositiestrategie wordt aanbevolen om een longpositie in te nemen boven de $30.000 in lijn met de trend, met doelen op $30.888 en $33.085. Daarentegen moet u voor een conservatieve shortpositiestrategie een shortpositie innemen rond de $30.000 als een countertrend-handel, met een doel van $29.500.</p>
<h3 id="h3-ETH454608"><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/1697780392ETH.png" alt=""><br>Ondanks een aanzienlijk herstel van de algehele markt deze week, blijft het korte termijn- en algehele opwaartse momentum voor ETH zwak. Het doel van $1.631 is bereikt, maar het blijft schommelen rond het niveau van $1.570. Het neerwaartse doel blijft op $1.465, waardoor een langetermijn bearish strategie levensvatbaar blijft.</p>
<h3 id="h3-BAND34904"><a name="BAND" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BAND</h3><p><img src="https://gimg2.gateimg.com/image/article/1697780414BAND.png" alt=""><br>BAND maakt deel uit van het oracle- en DeFi-concept en is gedaald van zijn hoogste punt ooit van $23,28 naar $1,399. Het maakt momenteel een tweede opwaartse trend mee op korte termijn. Voor wie zich op de lange termijn wil positioneren, is er nog steeds aanzienlijk opwaarts potentieel. In de volgende bullmarkt zijn naast de vorige hoogte de belangrijkste doelen $44,77, $71,36 en $115,62.</p>
<h2 id="h2-Macro20Amerikaanse20obligatierendementen20schieten20omhoog20Powell20gaf20aan20dat20renteverhogingen20mogelijk20nog20steeds20mogelijk20zijn20in20december259170"><a name="Macro: Amerikaanse obligatierendementen schieten omhoog, Powell gaf aan dat renteverhogingen mogelijk nog steeds mogelijk zijn in december" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Amerikaanse obligatierendementen schieten omhoog, Powell gaf aan dat renteverhogingen mogelijk nog steeds mogelijk zijn in december</h2><p>Het rendement op de Amerikaanse schatkist steeg tijdens de sessie en het rendement op de Amerikaanse schatkist van 10 jaar benaderde kortstondig de 5%-grens. Na de toespraak van Powell daalde het en sloot het nog steeds rond de 4,99%. Het rendement op de Amerikaanse schatkist van 2 jaar daalde met 6 basispunten op dezelfde dag en sloot bijna op 5,16%. Het rendement op de Amerikaanse schatkist van 10 jaar steeg met bijna 70 basispunten binnen een maand, terwijl het omgekeerde bereik van het rendement op de Amerikaanse schatkist van 2 jaar zich vernauwde tot ongeveer 26 basispunten.</p>
<p>Spotgoud steeg tijdens de toespraak van Powell verder en sloot 1,35% hoger op $1.974,07 per ounce, waarmee het een nieuw hoogtepunt bereikte sinds het einde van juli; Spotzilver steeg met 0,8% en sloot op $23,03 per ounce.</p>
<p>De drie belangrijkste aandelenindexen van de Amerikaanse aandelenmarkt sloten gezamenlijk lager. Na het aflopen van Powell’s poging om verschillende flexibiliteit voor de Federal Reserve te behouden, bleven de drie belangrijkste aandelenindexen dalen, waarbij de Dow 0,75% lager sloot, de Nasdaq 0,96% lager sloot en de S&amp;P 500-index 0,86% lager sloot.</p>
<p>Voorzitter van de Federal Reserve, Powell, hield donderdagmiddag een toespraak voor de New York Economic Club. Volgens het Hong Kongse Wande News Agency verklaarde Powell, voorzitter van de Federal Reserve, dat de inflatie nog steeds te hoog is en de weg naar het bestrijden van inflatie hobbelig kan zijn en enige tijd kan duren. De Federal Reserve is vastbesloten om de inflatie duurzaam terug te brengen tot 2%.</p>
<p>Powell gelooft dat het bereiken van dit doel mogelijk een periode van onder de trend economische groei en verdere verzwakking van de arbeidsmarkt voorwaarden vereist. Hij sloot verdere renteverhogingen niet uit als de gegevens te goed waren, maar benadrukte ook dat stijgende risico’s en obligatiemarktrentes de financiële omstandigheden hebben verscherpt. Powell verklaarde ook dat de Federal Reserve voorzichtig handelt gezien de onzekerheid en risico’s, evenals de gemaakte vooruitgang. Daarnaast wees Powell erop dat een stijging van de obligatiemarktrentes kan betekenen dat er geen behoefte is aan verdere renteverhogingen.</p>
<p>De toespraak van Powell sluit nauw aan bij de toespraken van zijn collega’s van de afgelopen dagen, die zich bereid hebben verklaard de kortetermijnrente ongewijzigd te laten tijdens de volgende vergadering van 31 oktober tot 1 november. Dit komt deels omdat de stijging van de langetermijnrente in de afgelopen maand de economie kan vertragen, en als de leenkosten hoog blijven, staat dit eigenlijk gelijk aan het verhogen van de rentetarieven.</p>
<p>Federal Reserve woordvoerder Nick Timiraos heeft onlangs commentaar gegeven op de toespraak van Fed-voorzitter Powell. Powell gaf aan dat hij tevreden is met de daling van de inflatie deze zomer en dat de Fed waarschijnlijk de rente niet zal verhogen, tenzij er duidelijk bewijs is dat verhoogde economische activiteit de vooruitgang van de inflatie in gevaar zal brengen.</p>
<p>Op dit moment zijn er enkele macro-economische problemen in de Verenigde Staten, of verschillende tekenen die aangeven dat als de Federal Reserve volhardt, dit uiteindelijk zal leiden tot een reeks problemen, zoals de huidige hoogste hypotheekrente in de geschiedenis, waar iedereen huizen koopt en verkoopt, maar de prijzen zijn gestegen. Bijvoorbeeld, Musk klaagde dat de hoge rente resulteerde in slechte autoverkoopgegevens, enzovoort.</p>
<p>Op basis van deze factoren zal de Federal Reserve ook een alomvattende overweging maken van de renteverhogingen. Als er dit jaar geen renteverhoging is, zal de renteverlaging volgend jaar ook worden vervroegd. Anders zullen de leenkosten in de samenleving te hoog zijn, wat niet geschikt is voor economische ontwikkeling en zelfs kan leiden tot een grote recessie in de Amerikaanse economie.</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 beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan, mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>