RGFnZWxpamtzIE5pZXV3cyB8IERlIHZvb3J6aXR0ZXIgdmFuIGRlIFNFQyB2ZXJrbGFhcmRlIGRhdCBCVEMgZ2VlbiBlZmZlY3QgaXMsIFRlbGVncmFtIHdlcmt0IHNhbWVuIG1ldCBUZW5jZW50IG9tIGVlbiDigIvigIsnU3VwZXIgRWNvc3lzdGVtIFBsYXRmb3JtJyB0ZSBjcmXDq3Jlbg==

2023-09-28, 04:38

<p><img src="https://gimg2.gateimg.com/image/article/16958815720928.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20voorzitter20van20de20SEC20verklaarde20dat20BTC20geen20effect20is20het20verlies20van20gestolen20fondsen20in20Q320overtrof20het20bedrag20in20de20eerste20helft20van20202340119"><a name="Crypto Dagelijkse Samenvatting: De voorzitter van de SEC verklaarde dat BTC geen effect is, het verlies van gestolen fondsen in Q3 overtrof het bedrag in de eerste helft van 2023." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De voorzitter van de SEC verklaarde dat BTC geen effect is, het verlies van gestolen fondsen in Q3 overtrof het bedrag in de eerste helft van 2023.</h2><p>Tijdens een hoorzitting gehouden door de Financial Services Committee van het Huis van Afgevaardigden van de Verenigde Staten, vroeg Patrick McHenry, voorzitter van het Financial Services Committee van het Huis van Afgevaardigden van de Verenigde Staten, aan Gary Gensler, voorzitter van de SEC: “Ik stelde je een vraag over <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> op de laatste vergadering. Vandaag wil ik een vraag stellen over <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>. Waarom denk je niet dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> een effect is? Denk je dat Bitcoin een effect is?</p>
<p>Gensler antwoordde: “Ik denk niet dat Bitcoin een effect is omdat het niet voldoet aan de Howey-test.” Gensler verklaarde ook: “Er zijn veel oplichters en dieven in de cryptocurrency-industrie. Dit schaadt de belangen van investeerders.”</p>
<p>Gensler zei ook dat crypto tokens op korte termijn geen valuta zullen worden.</p>
<p>Volgens Eric Balchunas, een senior ETF-analist bij Bloomberg, ‘hoopt de SEC de lancering van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s op futures te versnellen (aangezien ze hopen ze vrij te maken van hun werk nadat de overheid is gesloten), dus ze vereisen dat aanvragers hun documenten voor vrijdagmiddag bijwerken (dit is geen kleine taak, het moet binnen 48 uur worden ingeperkt, vooral voor onafhankelijke uitgevers), zodat ze maandag kunnen werken en dinsdag kunnen handelen.’</p>
<p>Blockchainbeveiligingsbureau Beosin heeft in samenwerking met SUSS NiFT en Footprint Analytics een wereldwijd Web3-beveiligingsrapport voor Q3 2023 uitgebracht, waarin wordt gesteld dat het totale verlies in de Web3-sector in Q3 $889,26 miljoen bedroeg als gevolg van hackeraanvallen, phishing scams en Rug Pull-incidenten. Het verliesbedrag in Q3 overtrof het totale verliesbedrag in de eerste helft van 2023 (respectievelijk ongeveer $330 miljoen in Q1 en $333 miljoen in Q2).</p>
<p>In totaal vonden er dit kwartaal 43 grote veiligheidsincidenten plaats, resulterend in verliezen van $5401.6 miljoen. Hiervan vonden 29 glen plaats in het DeFi-veld, wat ongeveer 67.4% vertegenwoordigt, en het projecttype met het hoogste verliesbedrag was het openbare blockchain. Deze 29 DeFi-aanvallen resulteerden in een totaal verlies van $98.23 miljoen, wat op de tweede plaats staat van alle projecttypes.</p>
<p>Onderverdeeld naar type aanval: 9 incidenten van privésleutellekken veroorzaakten een verlies van $223 miljoen; Het beveiligingsincident van het Mixin Network resulteerde in een verlies van $200 miljoen; 22 contractlekken resulteerden in een verlies van ongeveer $93,27 miljoen.</p>
<p>Vanuit het perspectief van kapitaal <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroming</a>, er is nog steeds $360 miljoen (67%) over bij hackeradressen. Slechts 10% van de gestolen fondsen werd deze kwartaal teruggevorderd. Het Ethereum-netwerk en Mixin samen waren goed voor 79% van het totale verlies.</p>
<p>Volgens TechCrunch werken de berichtenapp Telegram en TON Foundation samen met Tencent om Telegram te transformeren tot een ‘super applicatie ecosysteem platform’, vergelijkbaar met WeChat. Dit stelt derde partij ontwikkelaars en handelaren in staat om kleine programma’s te ontwikkelen en te communiceren met gebruikers, variërend van games tot restaurants. Ontwikkelaars kunnen Java gebruiken om oneindig flexibele interfaces te creëren die kunnen worden gelanceerd binnen Telegram of elke willekeurige website volledig kunnen vervangen.</p>
<p>Beïnvloed door dit nieuws doorbrak TON kortstondig 2,1 USDT, goed voor de 12e plaats in marktwaarde, met een huidige prijs van 2,17 USDT en een stijging van 2,6% in 24 uur.</p>
<h2 id="h2-Belangrijkste20token20trends20van20vandaag667366"><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-BTC596011"><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/1695881612BTC.png" alt=""><br>Zoals verwacht, kwam er gisteren een topnaaldpatroon naar voren, en nam het handelsvolume op korte termijn geleidelijk toe richting een belangrijke neerwaartse trendlijn. Korte termijn schommelingen zullen waarschijnlijk doorgaan rond het $26.510 niveau en worden verwacht aan te houden tot het einde van de maand voordat er een significante beweging plaatsvindt in oktober. De middellangetermijnstrategie toont aanhoudende zwakte in handelsvolume.</p>
<h3 id="h3-TRB537679"><a name="TRB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TRB</h3><p><img src="https://gimg2.gateimg.com/image/article/1695881639TRB.png" alt=""><br>In de afgelopen maand is TRB gestegen van een dieptepunt van $9,47 om het weerstandsniveau van $46,93 te testen. Vanochtend bleef het stijgen en bereikte ons initiële doel van $65,23. Op korte termijn is een terugval naar $52,95 mogelijk, terwijl het langetermijnperspectief de opwaartse trend en het niveau van $46,93 in stand moet houden.</p>
<h3 id="h3-MKR947763"><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/1695881660MKR.png" alt=""><br>Een langetermijnstructuur toont een groot bullish kop- en schouderspatroon, doorbrak de algehele neerwaartse trend eerder deze maand en bereikte het perfecte 0,786 weerstandsniveau op $1.541. Er wordt verwacht dat het zal terugtrekken naar het bereik van $1.422-$1.452. Het langetermijnperspectief blijft positief, met doelen op $1.588, $1.723, $1.832, $1.941 en $2.094.</p>
<h2 id="h2-Macro20Als20het20beleid20van20de20Fed20zorgt20voor20een20zachte20landing20zal20de20verwachting20van20renteverlagingen20de20markt20snel20doen20herstellen377341"><a name="Macro: Als het beleid van de Fed zorgt voor een zachte landing, zal de verwachting van renteverlagingen de markt snel doen herstellen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Als het beleid van de Fed zorgt voor een zachte landing, zal de verwachting van renteverlagingen de markt snel doen herstellen.</h2><p>Op woensdag bereikte de Amerikaanse dollar-index een nieuw hoogtepunt van 10 maanden, omdat de Amerikaanse economie meer momentum toonde dan andere landen en uiteindelijk sloot met een stijging van 0,49% op 106,71. Het rendement op Amerikaanse 10-jarige staatsobligaties steeg scherp in de Amerikaanse sessie en bereikte een nieuw hoogtepunt in 16 jaar en sloot op 4,613%, waardoor de aankoop van Amerikaanse dollars werd gestimuleerd. Niet-Amerikaanse valuta’s staan onder collectieve druk, waarbij de euro voor het eerst sinds januari onder de 1,05 daalde ten opzichte van de Amerikaanse dollar. De Japanse yen daalde met maar liefst 0,5% ten opzichte van de Amerikaanse dollar tot 149,77, het laagste niveau sinds medio oktober vorig jaar.</p>
<p>Spot goud daalde voor de derde opeenvolgende handelsdag en brak tijdens de sessie onder de $1.880 per ounce, wat de eerste keer is sinds 13 maart. Het bereikte een dieptepunt van $1.872,59 per ounce, een daling van meer dan $30 ten opzichte van het dagelijkse hoogtepunt, en sloot uiteindelijk 1,33% lager op $1.875,12 per ounce. Spot zilver fluctueerde en daalde uiteindelijk met 1,38% tot $22,55 per ounce.</p>
<p>Richt je vanavond om 12:30 (UTC) op de bekendmaking van de definitieve waarden van de jaarlijks geannualiseerde kwartaalrate van het Amerikaanse reële BBP, de kwartaalrate van de reële persoonlijke consumptie-uitgaven en de geannualiseerde kwartaalrate van de kern PCE-prijsindex, evenals het aantal eerste aanvragen voor werkloosheidsuitkeringen in de VS voor de week die eindigt op 23 september.</p>
<p>Om 13:00 (UTC) leverde de FOMC-stemmingscommissie van 2023 en de voorzitter van de Chicago Fed, Gullsby, een toespraak. De volgende ochtend om 1:00 uur ‘s morgens hield Federal Reserve-gouverneur Lisa Cook een toespraak. Om 4:00 uur ‘s morgens de volgende dag zal Federal Reserve-voorzitter Powell een conferentie bijwonen over de onderwijsindustrie en vragen beantwoorden van het publiek ter plaatse en online deelnemers.</p>
<p>Onlangs verklaarde AJ Oden, een wereldwijde beleggingsstrateeg bij JPMorgan Wealth Management, dat de S&amp;P 500-index volgend jaar een recordhoogte zal bereiken, omdat de Federal Reserve waarschijnlijk de rente niet langer zal verhogen.</p>
<p>Volgens zijn verklaring verwachten de strategen van de bank dat de S&amp;P 500-index tegen medio 2024 een nieuw hoogtepunt zal bereiken. Dit betekent dat er een stijging van minstens 12% vanaf het huidige niveau nodig is om het historische record dat in januari 2022 is neergezet, te doorbreken.</p>
<p>Dit is voornamelijk omdat JPMorgan Chase verwacht dat de Federal Reserve de renteverhogingen zal stoppen en binnenkort zal verschuiven naar renteverlagingen, wat de belangrijkste optimistische factor voor de aandelenmarkt zal vormen.</p>
<p>Oden wees erop dat nadat centrale bankgouverneurs het afgelopen jaar de rentetarieven aanzienlijk hebben verhoogd om de inflatie te verminderen, functionarissen van de Federal Reserve nu een optimistischere houding ten opzichte van de economie laten zien.</p>
<p>In een interview met CNBC op dinsdag verklaarde Oden dat de meest recente economische voorspellingssamenvatting (SEP) van de Federal Reserve aangeeft dat de voorkeursinflatie-indicator van de Fed, persoonlijke consumptie-uitgaveninflatie (PCE), naar verwachting zal dalen tot 2% tegen 2026.</p>
<p>Hij zei: ‘Als we terugkijken op de Federal Reserve-beleidsvergadering van vorige week en de SEP, lijkt een zachte landing erg belangrijk voor beleidsmakers. De SEP beschrijft inderdaad een ‘blonde meisje’ scenario.’</p>
<p>Volgens de CME FedWatch-tool verwacht de markt een kans van 44% dat de rentetarieven onder het huidige niveau zullen dalen tegen juni 2024. Later, wat betreft de voorspellingen van de aandelenmarkt, voegde Oden eraan toe: “Op een gegeven moment zal de Federal Reserve zich omdraaien en zal de markt vanaf dat moment herstellen.”</p>
<p>Oden verklaarde dat het herstel van Amerikaanse aandelen, veroorzaakt door toekomstige renteverlagingen, ook zal profiteren van de sterke Amerikaanse consumentenbestedingen. Ondanks aanzienlijke aanscherping van de financiële omstandigheden in het afgelopen jaar, blijft de consumentenbesteding veerkrachtig. Hij wees erop dat 88% van de aandelen in niet-essentiële consumentengoederen in de S&amp;P 500-index ‘zeer goed zullen presteren’.</p>
<p>Deze opvattingen zijn in strijd met pessimistische voorspellers op de aandelenmarkt. Zij stellen dat vanwege de mogelijkheid van een opflakkering van inflatie en het handhaven van restrictieve rentetarieven door de Federal Reserve, een economische recessie onvermijdelijk is.</p>
<p>Sinds Federal Reserve Chairman Powell waarschuwde tijdens de beleidsvergadering van de Fed in september dat de rentetarieven voor een langere periode hoog kunnen blijven, zijn de obligatierendementen omhooggeschoten en heeft de aandelenmarkt aanhoudend verkopen ervaren.</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 opvattingen 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 is toegestaan op voorwaarde dat Gate.io wordt genoemd. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>