RGFnZWxpamtzIG5pZXV3cyB8IFNFQyBzdHVpdHRlIG9wIG9ic3Rha2VscyBiaWogd2VydmVuIHZhbiBjcnlwdG8tZXhwZXJ0czsgaGFuZGVsc3ZvbHVtZSB2YW4gTkZUJ3MgaGVyc3RlbGRlIGluIGFmZ2Vsb3BlbiA1IHdla2VuOyBCTkIta2V0ZW4gYmxpamZ0IGVlbiB6d2FhciBnZXRyb2ZmZW4gZ2ViaWVkIHZvb3IgaGFja2VyIGNyaW1

2023-11-07, 05:03

<p><img src="https://gimg2.gateimg.com/image/article/16993360831_7.png" alt=""></p>
<h2 id="h2-Crypto20dagelijks20overzicht20de20SEC20ondervond20obstakels20bij20het20werven20van20cryptoexperts20de20handelsvolume20van20NFTs20is20in20de20afgelopen20520weken20hersteld821683"><a name="Crypto dagelijks overzicht: de SEC ondervond obstakels bij het werven van crypto-experts, de handelsvolume van NFT’s is in de afgelopen 5 weken hersteld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto dagelijks overzicht: de SEC ondervond obstakels bij het werven van crypto-experts, de handelsvolume van NFT’s is in de afgelopen 5 weken hersteld</h2><p>Op 7 november, volgens The Block, had de Amerikaanse Securities and Exchange Commission (SEC) moeite met het werven van crypto-experts omdat deze kandidaten niet bereid waren hun digitale activa te verkopen voor werk.</p>
<p>Volgens het laatste rapport van het Office of the Inspector General of Regulatory Agencies hebben veel gekwalificeerde kandidaten crypto-activa in bezit en heeft het Ethiek Adviesbureau van de SEC vastgesteld dat dit hen zal beletten deel te nemen aan specifieke zaken die betrekking hebben op of te maken hebben met crypto-activa. SEC-functionarissen wezen erop dat dit verbod een negatieve invloed heeft gehad op het wervingswerk, aangezien kandidaten meestal niet bereid zijn om hun crypto-activa van de hand te doen om bij de SEC te komen.</p>
<p>Op het gebied van gegevens stelde het Nansen-rapport van 6 november dat de verkoop van NFT’s tot en met de week die eindigde op 6 november 68.342 ETH bereikte, ongeveer $129 miljoen. In de afgelopen vijf weken is de handelsvolume van NFT’s gestaag toegenomen, met een dieptepunt van 29.704 ETH, ongeveer $56 miljoen voor de week die eindigde op 9 oktober.</p>
<p>Het laatste rapport van Immunefi toont aan dat er van januari tot oktober 2023 292 incidenten waren, resulterend in verliezen van meer dan $1,41 miljard als gevolg van hacken en frauduleuze activiteiten. Alleen al in oktober 2023 bedroegen de verliezen ongeveer $22,2 miljoen, voornamelijk toe te schrijven aan hacker-aanvallen en fraude. De meest frequent aanglen blockchain-netwerken tijdens deze periode waren <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Keten en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, wat overeenkomt met 83,3% van het totale verlies van de doelketen.</p>
<p>Immunefi onthulde dat <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain het hoogste aantal enkele aanvalgebeurtenissen heeft meegemaakt, met een totaal van 11, wat overeenkomt met 45,8% van het totale verlies van de doelketen.</p>
<p>Aan de andere kant waren er 9 gebeurtenissen op de Ethereum-keten, goed voor 37,5% van de totale verliezen. In de Layer1 blockchain, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a> beleefde in oktober twee evenementen, goed voor 8,3%. <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> en <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> elk ervoer één incident, wat respectievelijk 4,2% vertegenwoordigt. Het hackincident blijft de belangrijkste oorzaak van financiële verliezen.</p>
<p>Bovendien was het DeFi-platform in oktober nog steeds het belangrijkste doelwit van aanvallen, goed voor 100% van de totale verliezen. Daarentegen zijn er geen significante kwetsbaarheden gemeld in het CeFi-platform.</p>
<p>Daarvan heeft Blur het grootste aandeel in de handelsvolume van NFT’s in de afgelopen 30 dagen. Volgens gegevens van NFTGo bedraagt het handelsvolume van Blur 161.433 ETH (ongeveer $305 miljoen). Ondertussen is de op één na grootste concurrent OpenSea, met een handelsvolume van 52.307 ETH (ongeveer $100 miljoen).</p>
<h2 id="h2-Belangrijkste20trends20van20vandaag20in20tokens232907"><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-BTC6391"><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/1699336121BTC.png" alt=""><br>Op korte termijn, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> heeft een piek bereikt van bijna $36.000 en men verwacht dat het deze week zal blijven schommelen en mogelijk terug zal zakken naar $32,8K. Het is raadzaam om de vier-uurs voortschrijdend gemiddelde in de gaten te houden voor steun. Voor de middellange tot lange termijn is het nog steeds haalbaar om een laag-positie strategie aan te houden en de dagelijkse trend te gebruiken als een verdedigingslinie, die al vijf jaar van kracht is.</p>
<h3 id="h3-ETH764078"><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/1699336141ETH.png" alt=""><br>Afgelopen weekend stabiliseerde <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> boven de $1.857 en doorbrak de algehele neerwaartse trend, wat een daling van zeven maanden beëindigde. Op korte termijn handhaaft het zijn positie rond de trendlijn en de ondersteuning van $1.857, en het zou te maken kunnen krijgen met een doorbraak van de bovenste trendlijn, wat een situatie van short squeeze zou kunnen creëren, maar over het algemeen blijft het licht bullish.</p>
<h3 id="h3-BNB872430"><a name="BNB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BNB</h3><p><img src="https://gimg2.gateimg.com/image/article/1699336162BNB.png" alt=""><a href="/how-to-buy/polymath-poly" rel="nofollow noopener noreferrer" target="_blank">koop Polymath</a> Positieve nieuwsontwikkelingen hebben Binance Coin (BNB) een boost gegeven, en de vieruursgrafiek heeft de belangrijke neklijn op $246,2 doorbroken. Op korte termijn wordt een terugtrekking verwacht, terwijl het middellangetermijnbeeld wijst op een bodemstructuur van een hoofd en schouders. Op de lange termijn blijft de spotmarkt gericht op drie niveaus: $1.000, $1.505 en $2.316.</p>
<h2 id="h2-Macro20Amerikaanse20obligatierendementen20zijn20sterk20gestegen20Guggenheim20voorspelt20een20renteverlaging20van2015020basispunten20volgend20jaar439081"><a name="Macro: Amerikaanse obligatierendementen zijn sterk gestegen, Guggenheim voorspelt een renteverlaging van 150 basispunten volgend jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Amerikaanse obligatierendementen zijn sterk gestegen, Guggenheim voorspelt een renteverlaging van 150 basispunten volgend jaar</h2><p>Op maandag, toen de markt zich richtte op toespraken van Federal Reserve-functionarissen zoals Powell, herstelde de Amerikaanse dollarindex zich en bereikte tijdens de sessie een nieuw dieptepunt sinds 20 september, om uiteindelijk met 0,209% te stijgen en te sluiten op 105,3.</p>
<p>Het rendement op Amerikaanse staatsobligaties herstelde collectief, waarbij het rendement op 10-jaars obligaties uiteindelijk sloot op 4,647%, na een dieptepunt van ruim een maand; Het rendement op 2-jaars Amerikaanse staatsobligaties, dat gevoeliger is voor het rentebeleid van de Federal Reserve, sloot op 4,941%, na een dieptepunt van twee maanden.</p>
<p>De spotprijs van goud schommelde en daalde, en zakte onder de $1.980 in de late handelssessie, en sloot uiteindelijk 0,53% lager op $1.978,04 per ons; De spotprijs van zilver sloot 0,46% lager op $23,03 per ons.</p>
<p>Internationale olieprijzen zijn horizontaal geconsolideerd, waarbij Saoedi-Arabië en Rusland de implementatie van beperkingen op de aanvoer tot het einde van het jaar bevestigen, wat steun biedt voor de olieprijzen. WTI-ruwe olie zweefde in de buurt van het laagste niveau in meer dan twee maanden en sloot uiteindelijk 0,05% hoger af op $80,86 per vat; Brent-ruwe olie sloot 0,04% hoger af op $85,18 per vat.</p>
<p>De drie belangrijkste Amerikaanse aandelenindexen openden hoog en sloten laag, waarbij de Dow Jones Industrial Average 0,1% steeg, de S&amp;P 500 Index 0,18% steeg, de Nasdaq 0,3% steeg, Tesla (TSLA.O) 0,3% lager afsloot, en voor het eerst in de sessie met meer dan 2,5% steeg. Apple (AAPL.O) en NVDA (NVDA.O) stegen allebei meer dan 1,5%.</p>
<p>De indicatoren van de New York Fed suggereren dat de druk op de wereldwijde toeleveringsketen is gedaald tot een historisch laag niveau; De enquête van de Federal Reserve toont aan dat de Amerikaanse kredietvoorwaarden blijven aanscherpen, maar het tempo vertraagt in het derde kwartaal en de vraag naar leningen neemt over het algemeen af.</p>
<p>Minneapolis Fed-voorzitter Kashkari gelooft niet dat de cyclus van renteverhogingen voorbij is. Federal Reserve-gouverneur Lisa Cook: de recente stijging van de lange-termijn rentetarieven in de Verenigde Staten wordt mogelijk niet gedreven door de verwachtingen van beleggers voor verdere renteverhogingen. Naarmate de Federal Reserve haar beleid ten aanzien van de financiële omgeving aanscherpt, houdt zij nauwlettend toezicht op de kwetsbaarheid van niet-bancaire financiële instellingen.</p>
<p>Voorzitter van de Federal Reserve, Jerome Powell, verklaarde vorige week dat de recente scherpe stijging van de Amerikaanse obligatierendementen kan helpen bij het bestrijden van de inflatie, wat aangeeft dat de Amerikaanse obligatiemarkt mogelijk wat werk verricht voor de Federal Reserve.</p>
<p>Het probleem is dat de opmerkingen van Powell blijkbaar een vervolg hebben gekregen <a href="/how-to-buy/polymath-poly" rel="nofollow noopener noreferrer" target="_blank">koop Polymath</a> een opleving op de aandelenmarkt, evenals een aanzienlijke daling van de lange termijn Amerikaanse schatkistrendementen, die de benchmark zijn voor de leenkosten voor bedrijven.</p>
<p>Met andere woorden, de obligatiemarkt heeft zojuist laten zien hoe snel financiële omstandigheden kunnen versoepelen.</p>
<p>De opmerkingen van Powell bevestigen in zekere zin dat de Federal Reserve de rente mogelijk niet verder zal verhogen en dat de rendementen op langlopende schatkistobligaties zullen dalen na de recente scherpe stijging. Twee dagen na zijn toespraak daalde het rendement op de 30-jarige schatkistobligatie afgelopen vrijdag het meest in een week sinds maart 2020. Tegelijkertijd noteerden het rendement op een 10-jarige schatkistobligatie en het rendement op een tweejarige schatkistobligatie, die gevoelig zijn voor het rentebeleid, de grootste wekelijkse daling sinds maart en augustus september.</p>
<p>Deze ontwikkelingen geven aan dat overmatig vertrouwen op financiële markten om een deel van het werk van de Fed te voltooien, vooral als een manier om toekomstige renteverhogingen te vermijden, nadelen heeft.</p>
<p>Guggenheim Investments is van mening dat beleggers de pijnlijke lessen van de obligatiemarkt moeten negeren en voorbereid moeten zijn op de verschuiving van de Federal Reserve naar renteverlagingen.</p>
<p>Het bedrijf verwacht dat de Federal Reserve de beleidsrente in toekomstige vergaderingen op een 22-jarig hoogtepunt van 5,25% tot 5,5% zal handhaven en gelooft dat een economische recessie zich kan voordoen in de eerste helft van 2024.</p>
<p>In een op maandag uitgebrachte podcast verklaarde de Amerikaanse econoom Matt Bush van Guggenheim dat deze vooruitzichten de Federal Reserve mogelijk ‘dwingen om snel over te schakelen naar renteverlagingen, waarbij de rente volgend jaar met ongeveer 150 basispunten en nog meer in 2025 wordt verlaagd.’</p>
<p>Econoom Bush zei: “We geloven dat in het kader van een economische recessie (hoewel een milde), de Federal Reserve de federale fondsrente onder de 3% zal verlagen en de vermindering van haar balans zal opschorten.”</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 beleggingssuggestie.<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 actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>