RGFnZWxpamtzIG5pZXV3cyB8IEVlbiBCbGF1d2UgV2FsdmlzIGRpZSBhbCBtZWVyIGRhbiAzIGphYXIgaW5hY3RpZWYgaXMsIGhlZWZ0IDUwMDAgQlRDIG92ZXJnZWRyYWdlbi4gRGl0IGdlYmV1cmRlIGJpbm5lbiAyMDAgZGFnZW4gbmEgZGUgQlRDLWhhbHZlcmluZy4gQ1lCRVIgemFsIGVlbiBncm9vdHNjaGFsaWdlIG9udGdyZW5kZWx

2023-10-09, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/16968336761009.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20Amerikaanse20overheid20probeert20Bitcoin20te20controleren20en20720tokens20staan20deze20week20voor20ontgrendeling304633"><a name="Crypto Dagelijkse Samenvatting: De Amerikaanse overheid probeert Bitcoin te controleren, en 7 tokens staan deze week voor ontgrendeling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De Amerikaanse overheid probeert <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> te controleren, en 7 tokens staan deze week voor ontgrendeling</h2><p>Onlangs waarschuwde Sam Altman, CEO van OpenAI, op de blog van Joe Rogan dat de Amerikaanse overheid een ‘oorlog’ voert tegen cryptocurrencies en hoopt deze te ‘controleren’. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a>.</p>
<p>Sam Altman zei: “Ik maak me erg zorgen over hoever nationaal toezicht (implicerend nationale controle over valuta) kan gaan. Ik ben teleurgesteld in de recente acties van de Amerikaanse regering, maar ik geloof dat we niet mogen opgeven in de strijd tegen cryptocurrencies. We zullen ‘Bitcoin en cryptocurrency’ controleren. Ik denk dat het idee van een wereldwijde valuta die niet door een overheid wordt gecontroleerd, een zeer logische en belangrijke stap is op de technologische boom. Bitcoin ‘zal waarschijnlijk de meest levensvatbare valuta’ worden.</p>
<p>Op-chain analyseplatform Santiment tweette dat sinds 7 september meer dan 10.000 Bitcoins zijn afgevloeid van CEX, wat de grootste maandelijkse uitstroom van dit jaar markeert. Tegelijkertijd is het aantal unieke adressen van Bitcoin gedaald tot het laagste punt in bijna zes weken.</p>
<p>On-chain data toont aan dat een blauwe walvisadres dat al meer dan 3 jaar slapend is geweest, werd geactiveerd op de ochtend van 8 oktober, en alle 5000 BTC’s (ongeveer $140 miljoen) op het adres werden meerdere malen overgeboekt naar twee nieuwe adressen. Het adres ontving deze 5000 Bitcoins aanvankelijk in juni 2020.</p>
<p>Volgens de relevante gemeenschapsinformatie op het socialemediaplatform van de werkplek wordt vermoed dat werknemers van Bitmainland hebben gemeld dat Bitmainland achterstallig salaris heeft vanwege contant geld <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stromen</a> problemen en de eindejaarsbonus van 2022 is nog niet uitgekeerd. In september kan de helft van het basissalaris van alle medewerkers worden ingehouden, en alle prestatiegerichte lonen kunnen worden ingehouden.</p>
<p>Volgens het relevante blockchain-mediarapport hebben meerdere interne medewerkers van BitContinent bevestigd dat BitContinent op 3 oktober een bericht heeft uitgegeven dat de operationele cashflow van het bedrijf in september nog niet positief is geworden, vooral de voortgang van sommige mijnen (verwijzend naar de intrede van mijnbouwmachines in mijnen) voldoet ernstig niet aan de normen. EMT heeft besloten om de betaling van gedeeltelijk loon voor alle werknemers in september tijdelijk op te schorten en zal deze uitbetalen volgens de situatie na de vakantie op 7 oktober. Bitmainland hield onlangs een conferentie in Hong Kong en bracht de nieuwste S21-miningmachine uit.</p>
<p>Bitcoinblockhalf-gegevens tonen aan dat de huidige blokhoogte ongeveer 200 dagen verwijderd is van de tijd van de Bitcoin-halvering, en de halveringstijd wordt verwacht op 25 april 2024. Op dat moment zal de beloning voor elk blok worden verlaagd van 6,25 BTC naar 3,125 BTC.</p>
<p>Bovendien laat de gegevens van Token Unlocks zien dat er deze week (9 oktober tot 15 oktober) 6 crypto-projecten zullen zijn die tokens ontgrendelen, met een totale waarde van ongeveer $35 miljoen. Onder hen:</p>
<p><a href="/price/moonbeam-glmr" rel="nofollow noopener noreferrer" target="_blank">Moonbeam</a> (GLMR) zal 9,68 miljoen tokens ontgrendelen (ongeveer $2,05 miljoen) om 0:00 uur (UTC) op 11 oktober, wat overeenkomt met 1,29% van de circulerende voorraad;</p>
<p><a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a>(1 INCH) zal naar verwachting ongeveer 210.000 tokens (ongeveer $55.000) ontgrendelen om 12:00 uur (UTC) op 11 oktober, wat overeenkomt met 0,02% van de circulerende voorraad;</p>
<p><a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> (APT) ontgrendelt 4,54 miljoen tokens (ongeveer $ 23,63 miljoen) om 0:00 uur (UTC) op 12 oktober, goed voor 1,9% van het circulerende aanbod;</p>
<p>Euler (EUL) zal ongeveer 150.000 tokens (ongeveer $390.000) ontgrendelen om 09:10 op 12 oktober, wat overeenkomt met ongeveer 1% van de omloopvoorraad;</p>
<p>Sweat Economy (SWEAT) zal ongeveer 227 miljoen tokens (ongeveer $2,32 miljoen) ontgrendelen om 8:00 uur op 13 oktober, wat overeenkomt met 2,95% van de circulerende voorraad;</p>
<p>CyberConnect (CYBER) zal 1,26 miljoen tokens (ongeveer $6,23 miljoen) vergrendelen om 8:00 op 15 oktober, goed voor 11,43% van de circulerende voorraad.</p>
<p>Bovendien vergrendelde X2Y2 (X2Y2) op 8 oktober om 23:48 uur (UTC) 12,5 miljoen tokens (ongeveer $ 220000), goed voor 4,05% van het circulerende aanbod.</p>
<h2 id="h2-Belangrijkste20trends20van20vandaag20in20tokens778948"><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-BTC37414"><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/1696833715BTC.png" alt=""><br>Zoals vermeld in de live-uitzending van vorige week, heeft de algehele structuur een bullish head and shoulders patroon gevormd, en de belangrijke ondersteuning op $25.200 veerde snel terug. De markt bevindt zich momenteel in een driehoekig consolidatiepatroon, waarbij de korte termijn ondersteuning boven $28.125 wordt gehouden. Een conservatieve strategie voor de korte termijn zou zijn om te zoeken naar een doorbraak boven $28.500 met een potentieel doel op het weerstandsniveau van $30.203.</p>
<h3 id="h3-MKR868628"><a name="MKR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MKR</h3><p><img src="https://gimg2.gateimg.com/image/article/1696833733MKR.png" alt=""><br>Op de lange termijn vormt MKR een groot bullish head and shoulders patroon. De dagelijkse grafiek raakte nauwkeurig het eerste doel op $1.588 voordat er een significante terugval was naar de $1.370 ondersteuning. Het wordt aanbevolen om het niveau van $1.370 nauwlettend in de gaten te houden. Op middellange tot lange termijn zijn de doelen ingesteld op $1.723, $1.832, $1.940, $2.096, en het uiteindelijke doel van $2.294.</p>
<h3 id="h3-LOOM293397"><a name="LOOM" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LOOM</h3><p><img src="https://gimg2.gateimg.com/image/article/1696833749LOOM.png" alt=""><br>De dagelijkse grafiek van LOOM heeft de laatste golf gevormd in een vijfgolf opwaartse trend en heeft het doel van $0.19874 bereikt. Op korte termijn blijft het ondersteuningsniveau van $0.17969 en is een grotere correctie mogelijk. Als er een correctie optreedt, let dan op de belangrijkste ondersteuningsniveaus van $0.14387 en $0.12742. Aan de andere kant, als de correctie eindigt en de opwaartse trend zich voortzet, let dan op de weerstandsniveaus van $0.23838 en $0.29862, gevolgd door $0.33537.</p>
<h2 id="h2-Macro20Nonfarm20payrolls20die20de20verwachtingen20overtreffen20stijgende20verwachtingen20voor20renteverhogingen20focus20op20de20Amerikaanse20CPIgegevens20van20donderdag305744"><a name="Macro: Non-farm payrolls die de verwachtingen overtreffen, stijgende verwachtingen voor renteverhogingen, focus op de Amerikaanse CPI-gegevens van donderdag." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Non-farm payrolls die de verwachtingen overtreffen, stijgende verwachtingen voor renteverhogingen, focus op de Amerikaanse CPI-gegevens van donderdag.</h2><p>De afgelopen week zijn de sterk stijgende Amerikaanse obligatierendementen een zwaard geworden dat boven de wereldmarkt hangt, waarbij de rendementen op 10- en 30-jarige Amerikaanse obligaties stabiliseren nadat ze respectievelijk 4,9% en 5,1% hebben bereikt, wat het hoogste niveau is sinds 2007. Volgens analisten wordt dit voornamelijk beïnvloed door het optimistische economische vooruitzicht in de Verenigde Staten, de vasthoudende houding van de Federal Reserve en de verslechterende financiële moeilijkheden in de Verenigde Staten. Op vrijdag overtrof het aantal nieuwe banen buiten de landbouw de verwachtingen, waardoor de kans op een nieuwe renteverhoging door de Federal Reserve binnen het jaar verder toenam.</p>
<p>De nieuwe week na de vakantie is officieel begonnen. Vandaag zullen we ons richten op enkele belangrijke tijdstippen van deze week:</p>
<p>Om 13:30 uur (UTC) op maandag 2023 hield de FOMC-stemmingscommissie en de voorzitter van de Dallas Fed, Logan, een toespraak over het economisch perspectief en het monetaire beleid van de VS.</p>
<p>Om 13:30 uur (UTC) op dinsdag 2024 hield het FOMC Voting Committee en de voorzitter van de Atlanta Fed, Bostick, een toespraak over het perspectief voor de Amerikaanse economie.</p>
<p>Om 12:30 uur (UTC) op woensdag werd de jaarlijkse PPI-gegevens voor september in de Verenigde Staten vrijgegeven, met een vorige waarde van 1.6%.</p>
<p>Om 19:00 uur (UTC) op dinsdag hield het FOMOC Stemcomité 2023 en Minneapolis Fed-voorzitter Kashkari een toespraak.</p>
<p>Op donderdag om 12:30 uur (UTC) werd de kwartaal CPI-gegevens voor september in de Verenigde Staten vrijgegeven, met een vorige waarde van 3.7% en een voorspelling van 3.6%.</p>
<p>Om 18:00 uur (UTC) op woensdag zal de Federal Reserve de notulen vrijgeven van zijn monetair beleidsvergadering in september.</p>
<p>Op vrijdag om 13:00 uur (UTC) hield het FOMC-stemmingscomité en de voorzitter van de Philadelphia Fed, Huck, een toespraak over het economisch vooruitzicht voor 2023.</p>
<p>Het is duidelijk dat we ons deze week zullen richten op de tijdslijn van donderdag. Donderdag kan worden gebruikt om potentiële markttrends te analyseren en te beoordelen op basis van CPI en vergadernotulen, of als een andere katalysator dienen om marktverwachtingen voor renteverhogingen te veranderen.</p>
<p>De markt zal ook meer te weten komen over het evenwicht tussen economische groei en inflatie onder de functionarissen van de Federal Reserve uit de aankomende notulen van de vergadering in september, en het intensieve toesprakenschema van bijna 10 beleidsmakers zal ook meer aanwijzingen geven. Daarnaast zal het winstseizoen van het derde kwartaal voor Amerikaanse aandelen officieel van start gaan.</p>
<p>Wanneer het conflict in het Midden-Oosten aan de gang is, zijn er momenteel geen tekenen van verlichting van de situatie. Als het doorgaat, zal het een zekere invloed hebben op de financiële markt en de vraag naar een veilige haven op de markt vergroten. Momenteel heeft goud dergelijke momentum getoond, en het zal ook invloed hebben op de ruwe olie markt. We zullen blijven opletten.</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 beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt alle rechten 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>