RGFnZWxpamtzIG5pZXV3cyB8IFNsb3dNaXN0IGhlcmlubmVydCBjcnlwdG9nZWJydWlrZXJzIGVyYWFuIGh1biBiZXN0dXJpbmdzc3lzdGVtZW4gdGUgdXBncmFkZW47IEJpdGNvaW4gRVRGUyB3b3JkZW4gdmVyd2FjaHQgaW4gZGUgdG9la29tc3QgendhYXIgZ2XDr252ZXN0ZWVyZCB0ZSB3b3JkZW4=

2023-10-02, 05:36

<p><img src="https://gimg2.gateimg.com/image/article/16962248631002.jpg" alt=""></p>
<p>Crypto Daily Express: Slow Mist herinnert gebruikers eraan om hun besturingssysteem bij te werken; 7 tokens worden deze week ontgrendeld</p>
<p>23pds, de Chief Information Security Officer van SlowMist, plaatste op het X-platform een bericht waarin hij cryptocurrency-gebruikers vroeg om hun besturingsen zo snel mogelijk te upgraden, of het nu gaat om iOS, Chrome-browsers, Android enzovoort, om mogelijke beveiligingslekken aan te pakken.</p>
<p>Onlangs heeft het Google Threat Analysis Team een aanvalsketen onthuld die misbruik kan maken van iPhone kwetsbaarheden in het wild. Specifiek gaat het om een man-in-the-middle (MITM) aanval die de kwetsbaarheden aanvalt via de Safari-browser, of het gaat rechtstreeks om Android MITM die aanvallen verstuurt naar een eenmalige <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> om de initiële renderercode van Chrome te verkrijgen en vervolgens de aanval te starten. De aanval is vakkundig georganiseerd en kan veel schade aanrichten, daarom dringt het team er bij gebruikers op aan om tijdig hardware besturingsen te upgraden om potentiële risico’s te voorkomen.</p>
<p>Anthony Scaramucci, oprichter van Skybridge Capital, heeft zijn optimistische kijk gegeven op het vooruitzicht van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> op de Messari Mainnet Conference. Hij benadrukte dat een <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF in de toekomst een onmisbaar product zal zijn van elk Wall Street-bedrijf, en de handel in Bitcoin ETF zal deel uitmaken van de diensten van die bedrijven. Hij voorspelde: ‘BTC zal in de komende 10 tot 20 jaar een grote bullish run doormaken.’ Hij geloofde dat de jonge generatie de kracht zou hebben om ‘BTC tot een mainstream asset te maken.’, net zoals zijn generatie de drijvende kracht werd achter het ‘mainstream maken van het internet.’</p>
<p>Anthony waarschuwde echter ook voor het bestaan van veel tegenwind in de macro-omgeving, waaronder stijgende rentetarieven, een op wetshandhaving gerichte voorzitter van de Securities and Exchange Commission (SEC) en de negatieve stemming rond de acceptatie van cryptocurrency. Ondanks dit alles blijft hij optimistisch over de toekomst van Bitcoin en zegt: “Naarmate de sociale rijkdom groeit, zullen digitale activa (hoogstwaarschijnlijk Bitcoin) andere activa vervangen om deel uit te maken van de activaportefeuille van mensen.” Als langdurige BTC-supporter herhaalde hij zijn mening dat “Bitcoin beter is dan goud”.</p>
<p>Volgens de Hong Kong Police Force is het station op de hoogte gesteld van in totaal 769 romantische oplichtingszaken tussen januari en juli van dit jaar, waarvan de meeste georganiseerd werden door criminele bendes in Zuidoost-Azië die slachtoffers misleidden om te investeren in cryptomunten na het valse opzetten van romantische relaties met hen. De verliezen van de slachtoffers bedroegen HK$407,8 miljoen (ongeveer US$52 miljoen), en het aantal gemelde romantische oplichtingszaken van dit jaar zal waarschijnlijk het dubbele zijn van dat van 2021. In 2021 werden in totaal 642 romantische oplichtingszaken gemeld, driemaal het aantal van 2020 (181 glen).</p>
<p>Volgens Token Unlocks zullen van 25 september tot 1 oktober 7 tokens worden vrijgegeven, waaronder ACA, GAL, YGG, AGIX, EUL, OP en 1INCH.</p>
<p>Om 8:00 op 25 september zal Acala 4,66 miljoen ACAs (met een waarde van ongeveer $220.000) ontgrendelen, wat overeenkomt met 0,58% van de circulerende voorraad;</p>
<p>Om 20:00 uur op 27 september zal Galxe 586.700 GAL (ter waarde van ongeveer $770.000) vergrendelen, wat overeenkomt met 1,26% van het circulerende aanbod;</p>
<p>Op 27 september om 22:00 uur zal Yield Guild Games 12,42 miljoen YGG (ter waarde van ongeveer $2,56 miljoen) ontgrendelen, wat overeenkomt met 6,71% van de circulerende voorraad;</p>
<p>Om 8:00 op 28 september zal SingularityNET 9,69 miljoen AGIX (ongeveer ter waarde van $1,72 miljoen) ontgrendelen, wat overeenkomt met 0,79% van de circulerende voorraad;</p>
<p>Op 28 september om 8:14 zal Euler 153.020 EUL ontgrendelen (met een geschatte waarde van $410.000), goed voor 0,82% van het circulerende aanbod;</p>
<p>Om 12:00 op 30 september, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> zal 24,16 miljoen OP ontgrendelen (ongeveer gewaardeerd op $30,92 miljoen), wat overeenkomt met 3,03% van de omloopvoorraad;</p>
<p>Op 1 oktober om 16:00 uur <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a> zal 15.000 <a href="/price/1inch-1inch" target="_blank" class="blog_inner_link">1INCH</a> ontgrendelen (met een geschatte waarde van $3.880).</p>
<h2 id="h2-Macro20De20Amerikaanse20overheidssluiting20zal20vertraging20veroorzaken20bij20het20vrijgeven20van20economische20gegevens20Powell20zal20deze20vrijdag20een20toespraak20houden385173"><a name="Macro: De Amerikaanse overheidssluiting zal vertraging veroorzaken bij het vrijgeven van economische gegevens; Powell zal deze vrijdag een toespraak houden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Amerikaanse overheidssluiting zal vertraging veroorzaken bij het vrijgeven van economische gegevens; Powell zal deze vrijdag een toespraak houden</h2><p>Een nieuwe week is begonnen. Laten we eerst eens kijken welke grote evenementen er deze week gepland staan:</p>
<p>Om 20:30 uur aanstaande vrijdag (29 september) zal de Federal Reserve haar meest bezorgde economische gegevens vrijgeven (Alle gegevens hieronder zijn geldig om 20:30 die dag): Het jaarlijkse tarief van de Amerikaanse kern-PCE-prijsindex in augustus (vorige waarde: 4,20%; marktverwachting: 3,90%); Het maandelijkse tarief van de Amerikaanse kern-PCE-prijsindex in augustus (vorige waarde: 0,20%; marktverwachting: 0,20%); De aanhoudende stijging van energieprijzen kan leiden tot een algemene stijging van de PCE-prijs. De algemene verwachting is dat de PCE-prijsindex in augustus op jaarbasis met 3,5% zal stijgen, 3,3% meer dan voorheen. Verwacht wordt dat de kern-PCE-prijsindex op maandbasis een groei van 0,2% zal handhaven. Maar het herstel van energieprijzen is niet het enige punt van zorg voor de Fed. De zeer actieve consumptiemarkt geeft de beleidsmakers nog een reden om de rente verder te verhogen.</p>
<p>Vanwege de sterke arbeidsmarkt wordt verwacht dat de persoonlijke inkomensgegevens zullen stijgen, met het potentieel om met 0,5% te groeien, ten opzichte van de vorige 0,2%. Echter, met het einde van de zomervakantie, zal de uitgaven naar verwachting afnemen, waardoor de gegevens van 0,8% naar 0,4% zullen dalen. Als ofwel persoonlijke uitgaven of kern-PCE-gegevens op onconventionele wijze stijgen, zal dit een reden zijn voor de FED om de rente te verhogen, wat op zijn beurt de rendementen van staatsobligaties en de dollar verder zal opdrijven.</p>
<p>Op deze vrijdag (29 september) om 04:00 uur zal voorzitter van de Federal Reserve Powell een toespraak houden. Powell’s toespraak volgt nauw op de aankondiging van de Fed van een renteverhoging vorige week, wat heeft geleid tot heftige schommelingen op de wereldwijde markten. In de toespraak wordt verwacht dat Powell zijn standpunt over de puntgrafiek zal uiten en de reden zal uitleggen waarom zijn collega’s geloven dat de rentetarieven langdurig hoog zullen blijven.</p>
<p>Laten we tot slot eens kijken naar de voortgang van de onderhandelingen tussen de twee partijen over de veelbesproken uitgavenwetten. Volgens de voorspellingsgegevens is de kans dat de Amerikaanse overheid opnieuw met een shutdown te maken krijgt net zo hoog als 50%. En de mogelijkheid zal werkelijkheid worden als het Congres geen overeenstemming kan bereiken vóór middernacht op 30 september. In dat g zal niet alleen de normale gang van zaken op de financiële markten verstoord worden, maar zullen ook een reeks belangrijke economische gegevens niet op tijd beschikbaar zijn, waaronder het aantal niet-agrarische banen in september, PPI en CPI, en het BBP van het derde kwartaal van de VS. Het ontbreken van die gegevens zal extra uitdagingen opleveren voor het werk van de Fed.</p>
<p>Het is moeilijk om de duur van de sluiting van de overheid te schatten, die afhangt van wanneer de afwijking in het Congres kan worden opgelost, dat bestaat uit de door de Democraten gecontroleerde Senaat en het door de Republikeinen geleide Huis van Afgevaardigden. In een recent rapport verwacht Goldman Sachs dat de stopzetting twee tot drie weken zal duren en dat het een tweewekelijks iets is. Volgens Moody zal de overheid echter gedurende het hele vierde kwartaal verlamd blijven, waarmee de vorige shutdown van 35 dagen wordt overtroffen om een nieuw record te vestigen. Als dit het g is, zal het BBP in het vierde kwartaal met 1,2% dalen.</p>
<p>Hier is een samenvatting van de mogelijke reden voor de sluiting van de Amerikaanse regering, evenals de impact van de sluiting.</p>
<ol>
<li><p>De Amerikaanse overheid is gesloten omdat het Congres er niet in slaagt een akkoord te bereiken over de begroting voor het komende begrotingsjaar.</p>
</li><li><p>Er zijn gemengde reacties op de sluiting van de Amerikaanse regering. Voorstanders beschouwen het als een kracht om het Congres te dwingen een meer conservatieve begroting aan te nemen. Daarentegen geloven tegenstanders dat de actie schadelijk is, omdat het de normale werking van administratieve diensten verstoort en veel Amerikanen financiële problemen bezorgt.</p>
</li></ol>
<p>3、De sluiting van de Amerikaanse overheid kan een negatieve impact hebben op de aandelenmarkt, aangezien investeerders mogelijk zullen terughoudend zijn, in verband met mogelijke onderbrekingen van diensten of verzwakking van het consumptievermogen doordat veel werknemers met verlof zijn tijdens de sluiting.</p>
<ol>
<li>Het is moeilijk te voorspellen hoe lang de regeringssluiting zal duren, wat eigenlijk afhankelijk is van wanneer het congres een akkoord kan bereiken over een begroting.</li></ol>
<div class="blog-details-info"><br><div>Auteur:<strong>Peter L.</strong>, Gate.io onderzoeker<br><div>Vertaler: Sally Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggesties.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>