RGFnZWxpamtzIG5pZXV3cyB8IEVlbiBuaWV1d2Uga3dldHNiYWFyaGVpZCBpbiBpT1MgMTYga2FuIGxlaWRlbiB0b3QgaGV0IGhhY2tlbiB2YW4gY3J5cHRvLWFwcGFyYXRlbjsgTm9vcmQtS29yZWFhbnNlIGhhY2tlcnMgaGViYmVuIG1lZXIgZGFuICQyMDAgbWlsam9lbiBhYW4gY3J5cHRvIGdlc3RvbGVuIGluIDIwMjM7IDcgdHJlbmR

2023-08-21, 03:44

<p><img src="https://gimg2.gateimg.com/image/article/16925965870821.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Digest20Een20nieuwe20kwetsbaarheid20in20iOS201620kan20ervoor20zorgen20dat20cryptoapparaten20worden20gehackt20SEC20kan20gelijktijdig20meerdere20Ethereum20futures20ETFs20goedkeuren283104"><a name="Crypto Dagelijkse Digest: Een nieuwe kwetsbaarheid in iOS 16 kan ervoor zorgen dat crypto-apparaten worden gehackt; SEC kan gelijktijdig meerdere Ethereum futures ETF’s goedkeuren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Digest: Een nieuwe kwetsbaarheid in iOS 16 kan ervoor zorgen dat crypto-apparaten worden gehackt; SEC kan gelijktijdig meerdere <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> futures ETF’s goedkeuren</h2><p>Het laatste nieuws is dat volgens de Chief Information Security Officer van SlowMist, 23pds, in een tweet, netwerkbeveiligingsonderzoekers een nieuwe kwetsbaarheid voor het voortdurend uitbuiten van technologie hebben ontdekt in iOS 16: zelfs als het Apple-apparaat van het slachtoffer offline is, kan de technologie worden gebruikt om stilletjes toegang te krijgen tot het apparaat. Deze kwetsbaarheid is echter alleen mogelijk op apparaten die zijn misbruikt of gejailbreakt.</p>
<p>De hacker laat het slachtoffer geloven dat de vliegtuigmodus van zijn apparaat goed werkt. In werkelijkheid heeft de hacker een valse kunstmatige vliegtuigmodus geïmplanteerd nadat hij het apparaat met succes had gebruikt. In deze modus wordt de gebruikersinterface bewerkt om de vliegmodus weer te geven <a href="/price/icon-icx" rel="nofollow noopener noreferrer" target="_blank">ICON</a> en verbreek alle verbindingen behalve de applicatie van de hacker met het internet.</p>
<p>SlowMIst herinnert beoefenaars van cryptocurrency eraan om voor het gemak geen jailbreak-apparaten te gebruiken.</p>
<p>Volgens ingewijden die door The Wall Street Journal zijn aangehaald, zou de Securities and Exchange Commission (SEC) meerdere kunnen goedkeuren <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> futures ETF-aanvragen tegelijkertijd. Sinds juli heeft de SEC aanvragen ontvangen van meerdere beleggingsmaatschappijen voor Ethereum Futures ETF’s, en deze bedrijven hebben hun aanvragen nog niet ingetrokken, wat afwijkt van de instructies die aan bedrijven zijn gegeven om hun aanvragen in 2021 in te trekken. Volgens ingewijden duidt dit erop dat regelgevende instanties de lancering van ETF’s op korte termijn niet zullen tegenhouden.</p>
<p>De gegevens tonen aan dat er op dit moment ten minste 16 Ethereum-gerelateerde ETF-aanvragen wachten op goedkeuring door de regelgevende instanties.</p>
<p>Een rapport dat op vrijdag is vrijgegeven door blockchain-intelligentiebedrijf TRM Labs toont aan dat hoewel dit jaar nog niet is afgelopen, hackers die verband houden met Noord-Korea meer dan $200 miljoen aan cryptocurrency hebben gestolen in 2023, wat meer dan 20% is van alle gestolen cryptocurrencies in 2023. In de afgelopen vijf jaar hebben cybercriminelen meer dan $2 miljard aan fondsen gestolen.</p>
<p>TRM Labs verklaarde dat Noord-Koreaanse hackers verschillende technologieën gebruiken om gestolen fondsen wit te wassen, voornamelijk door valutamixers te gebruiken na cross-chain transacties, en vervolgens snel uit te laten betalen via uitwisselingsrekeningen, die doorgaans lagere KYC- of antiwitwasnormen hebben. Na OFAC-sancties tegen Tornado Cash wordt meestal Sinbad gebruikt voor valutamixing.</p>
<p>Op 21 augustus toonde Token Unlocks-gegevens aan dat tokens voor zeven projecten deze week ontgrendeld zullen worden, waarbij AVAX ter waarde van meer dan $100 miljoen op zaterdag ontgrendeld wordt. INJ en LDO zullen ook tokens ter waarde van meer dan $10 miljoen tegelijk ontgrendelen.</p>
<p>Om 0:00 uur (UTC) op 21 augustus zal Injective 2,86 miljoen INJ ontgrendelen, ter waarde van ongeveer $22,02 miljoen, wat ongeveer 3,41% van de totale circulatie vertegenwoordigt;</p>
<p>Op 22 augustus om 0:00 uur (UTC) zal SPACE ID 18,49 miljoen ID’s ontgrendelen, ter waarde van ongeveer $3,72 miljoen, wat ongeveer 6,46% van het totale circulatievolume vertegenwoordigt;</p>
<p>Om 0:00 uur (UTC) op 24 augustus <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a> zal 274.000 1INCHs ontgrendelen, met een waarde van ongeveer $687.700, wat ongeveer 0,03% van het totale omloopvolume vertegenwoordigt;</p>
<p>Op 25 augustus om 0:00 uur (UTC) ontgrendelt Acala 4,66 miljoen ACA’s, ter waarde van ongeveer $ 225.000, goed voor 0,58% van het totale circulatievolume;</p>
<p>Om 5:51 uur (UTC) op 26 augustus, <a href="/price/lido-dao-ldo" rel="nofollow noopener noreferrer" target="_blank">Lido DAO</a> zal 8,5 miljoen LDO’s ontgrendelen, ter waarde van ongeveer $14,2 miljoen, wat ongeveer 0,97% van het totale omloopvolume vertegenwoordigt;</p>
<p>Om 0:00 uur (UTC) op 26 augustus, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a> zal 9,54 miljoen AVAXs ontgrendelen, ter waarde van ongeveer $103 miljoen, goed voor ongeveer 2,77% van de totale circulatie;</p>
<p>Om 14.00 uur (UTC) op 27 augustus zal Yield Guild Games 12,22 miljoen YGG’s ontgrendelen, ter waarde van ongeveer $2,87 miljoen, wat ongeveer 6,6% van de totale omloop vertegenwoordigt.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag727317"><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-BTC863579"><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/1692596626BTC.png" alt=""><br>Afgelopen weekend werd de tweede bodem gevormd rond $25.606,5 voor BTC, en er werd voorgesteld om een lichte positie in te nemen voor een korte termijn opleving op het niveau van $25.606. Vervolgens trok het op naar de middenasstructuur op $26.150. Deze week blijven we wachten op aanwijzingen. Het bullish weerstandsniveau om in de gaten te houden is $26.510, terwijl de bearish strategie overwogen moet worden als het onder het vorige dieptepunt van $25.150 daalt, met als doel $24.220.</p>
<h3 id="h3-ETH613037"><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/1692596650ETH.png" alt=""><br>Afgelopen weekend werd het tweede dieptepunt gevormd rond $1.631,2 voor ETH, en er werd voorgesteld om een lichte positie in te nemen voor een korte termijn herstel op het niveau van $1.631,2. Er is op korte termijn een duidelijk head and shoulders bodempatroon ontstaan. De aandacht is gericht op het doorbreken van het weerstandsniveau van $1.694. Als dit niet wordt doorbroken, moet er mogelijk opnieuw getest worden op de steun van $1.631. De belangrijke bodemlijn om vast te houden is de stijgende trendlijn.</p>
<h3 id="h3-SEI401286"><a name="SEI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEI</h3><p><img src="https://gimg2.gateimg.com/image/article/1692596669SEI.png" alt=""><br>Korte posities worden aanbevolen om te worden opgezet op $0.1668 voor SEI, met een doel van $0.1535. Op korte termijn moet er nog steeds aandacht worden besteed aan of het terugtrekt naar de cruciale ondersteuning op $0.1535. Als de neerwaartse trend aanhoudt, zijn de doelen achtereenvolgens $0.1433, $0.1362, $0.1202 en $0.1060.</p>
<h2 id="h2-Macro20Focus20op20de20jaarlijkse20bijeenkomst20van20mondiale20centrale20banken20met20de20nadruk20op20de20toespraak20van20Powell20op20vrijdag182043"><a name="Macro: Focus op de jaarlijkse bijeenkomst van mondiale centrale banken, met de nadruk op de toespraak van Powell op vrijdag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Focus op de jaarlijkse bijeenkomst van mondiale centrale banken, met de nadruk op de toespraak van Powell op vrijdag</h2><p>Deze week, die begint op 24 augustus, zal de Jackson Hole Annual Conference, ook wel bekend als de Global Central Bank Annual Conference, ongetwijfeld het jaarlijkse feest van wereldwijde centrale banken zijn. Centrale bankiers en belangrijke figuren uit verschillende landen zullen aanwezig zijn, waar u kunt leren over de huidige staat van de wereldeconomie, inzicht kunt krijgen in toekomstige beleidsrichtingen en financiële strategieën kunt bespreken, wat van groot belang is. De organisatoren van de Jackson Hole Annual Conference zijn sinds 1982 de Kansas Federal Reserve. De Jackson Hole Annual Conference wordt jaarlijks in augustus gehouden in Jackson Hole, Wyoming, Verenigde Staten en duurt telkens drie dagen.</p>
<p>De jaarlijkse Global Central Bank Annual Meeting van Jackson Hole 2023 zal plaatsvinden van 24 tot 26 augustus, waarbij centrale bankgouverneurs uit belangrijke landen hier bijeenkomen. Het thema van dit jaar is “Structurele veranderingen in de wereldeconomie.”</p>
<p>Jackson Hole komt vaak voor in nieuwsberichten en is de belangrijkste bijeenkomst van financiële professionals van het jaar, waardoor het een evenement wordt dat de markt beïnvloedt. Voor wereldwijde investeerders zal dit een grote gok zijn. Voor centrale banken is dit ook een competitie, aangezien wereldwijde centrale bankgouverneurs hun standpunten uiten, wat natuurlijk de aandacht trekt van wereldwijde investeerders.</p>
<p>De bijeenkomst is altijd een gelegenheid geweest voor de Federal Reserve om belangrijke signalen van monetair beleid over te brengen, bekend als de ‘barometer’ van beleidswendingen, die voortdurend het gezag en de zichtbaarheid van deze bijeenkomst vergroten. Tijdens de bijeenkomst in Jackson Hole vorig jaar gaf voorzitter Powell van de Federal Reserve een ongebruikelijk haviksachtig signaal af, waardoor de wereldwijde aandelenmarkten daalden en er een weddenschap werd geplaatst om de yen en euro te verkorten.</p>
<p>De bijeenkomst van deze jaarlijkse vergadering valt samen met de opleving van de Amerikaanse dollar en de stijging van de Amerikaanse obligatierendementen, wat de wisselkoersen en aandelenmarkten van verschillende landen bedreigt. Daarom is iedereen nieuwsgierig naar wat Fed-voorzitter Powell (en de People’s Bank of China is geen uitzondering) vrijdagavond zal zeggen. Als Powell doorgaat met het sturen van havikachtige signalen, zal de Amerikaanse dollar en de Amerikaanse obligatierendementen verder versterken, wat een bedreiging vormt voor de mondiale marktstabiliteit. Maar een hoger Amerikaans obligatierendement is precies wat de Federal Reserve graag ziet, aangezien de leenkosten op de obligatiemarkt stijgen en de economie zelf vertraagt, om opnieuw het inflatiedoel van 2% te bereiken. Of de Federal Reserve zal doorgaan met het verhogen van de rente, wordt verwacht te worden bepaald tijdens deze vergadering.</p>
<p>Het is belangrijk om deze jaarlijkse vergadering van de mondiale centrale bank deze week te volgen, omdat er veel informatie is om te begrijpen, analyseren en interpreteren, zodat we betere investeringsbeslissingen kunnen nemen.</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 is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>