RGFnZWxpamtzIG5pZXV3cyB8IE11c2sgdmVya2xhYXJ0IGRhdCBYIG5vb2l0IGNyeXB0b2N1cnJlbmN5IHphbCBsYW5jZXJlbiwgVnlwZXIgQ29tcGlsZXIga3dldHNiYWFyaGVpZCB2YW4gRXRoZXJldW0gb3BnZWxvc3QsIEFQVCBlbiBJTVgtdG9rZW5zIHdvcmRlbiBkZXplIHdlZWsgaW4gZ3JvdGUgaG9ldmVlbGhlZGVuIHZyaWpnZWd

2023-08-07, 04:20

<p><img src="https://gimg2.gateimg.com/image/article/16913880130807.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Musk20stelt20dat20X20nooit20cryptocurrency20zal20lanceren20APT20en20IMXtokens20zullen20deze20week20in20grote20hoeveelheden20worden20ontgrendeld805744"><a name="Crypto Daily Digest: Musk stelt dat X nooit cryptocurrency zal lanceren, APT- en IMX-tokens zullen deze week in grote hoeveelheden worden ontgrendeld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Musk stelt dat X nooit cryptocurrency zal lanceren, APT- en IMX-tokens zullen deze week in grote hoeveelheden worden ontgrendeld</h2><p>Op zaterdag reageerde Musk op <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> grafisch ontwerper DogeDesigner zal nooit crypto tokens lanceren.</p>
<p>Maar al toen Musk Twitter voor het eerst overnam, speculeerden sommigen dat hij cryptocurrency op Twitter zou introduceren. Want volgens een rapport in april 2023 zal Twitter gebruikers toestaan om aandelen en cryptocurrencies op het platform te verhandelen als onderdeel van een samenwerking met sociale investeringsmaatschappij eToro.</p>
<p>De visie van Musk is om Twitter uit te bouwen tot een door kunstmatige intelligentie aangedreven wereldwijd platform dat alle velden bestrijkt. Musk verklaarde dat dit plan zal beginnen met het ondersteunen van fiat-valuta’s en, indien nodig, cryptocurrencies voor een bepaalde periode in de toekomst zal integreren. Dit betekent duidelijk dat Musk’s visie voor een toekomstige wereld die wordt aangedreven door kunstmatige intelligentie potentiële use-cases voor cryptocurrency omvat.</p>
<p>In feite heeft Musk eerder verklaard dat het huidige banksysteem niet ‘real-time en inefficiënt’ is en niet past bij de digitaal verbonden wereld van vandaag. Musk noemde cryptocurrency als de oplossing voor dit probleem.</p>
<p>Tegenwoordig beweert Musk dat X nooit crypto tokens zal lanceren, en het is onzeker of het een valse schijn zal zijn of andere middelen om zijn visie op cryptocurrency te bereiken.</p>
<p>Op 6 augustus, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> compiler Vyper heeft een analyseverslag uitgebracht over het kwetsbaarheidsincident van afgelopen week: Vóór 30 juli werden meerdere Curve-liquiditeitspools geëxploiteerd vanwege mogelijke kwetsbaarheden in de Vyper-compiler. Hoewel de fouten zijn geïdentificeerd en verholpen, waren ze destijds niet op de hoogte van de impact op het protocol dat kwetsbare compilers gebruikte en werden ze niet expliciet op de hoogte gesteld. De kwetsbaarheid zelf is een onjuist geïmplementeerde re-entry-beveiliging en de getroffen Vype-versies zijn v0.2.15, v0.2.16 en v0.3.0.</p>
<p>De kwetsbaarheid is verholpen en getest in v0.3.1, en v0.3.1 en nieuwere versies zijn veilig. In de toekomst zullen maatregelen worden genomen om de juistheid van slimme contracten gecompileerd met Vyper te verbeteren. Een daarvan is het verbeteren van de compiler-testen, inclusief het vergroten van de dekking, het vergelijken van de compileroutput met taalspecificaties en het gebruik van formele verificatietools (FV) voor de verificatie van compiler-bytecode. De tweede is het bieden van tools voor ontwikkelaars om op een gemakkelijkere manier verschillende methoden te gebruiken om hun code te testen, inclusief testen op broncode- en bytecode-niveau. De derde is het versterken van het gebruik van het Vyper-protocol voor strengere bidirectionele feedback.</p>
<p>Volgens Token Unlocks-gegevens worden tokens voor de top 5 projecten deze week ontgrendeld, waarbij APT en IMX aanzienlijke ontgrendelingen ervaren. Hieronder vallen:</p>
<p>Om 0:00 uur (UTC) op 7 augustus ontgrendelde Nym 45,63 miljoen NYM’s (ongeveer $8,68 miljoen), wat overeenkomt met 9,52% van de circulerende voorraad;</p>
<p>Om 0:00 uur (UTC) op 7 augustus ontgrendelde Hashflow 3,23 miljoen HFT’s (ongeveer $1,15 miljoen), wat overeenkomt met 1,84% van de circulerende voorraad;</p>
<p>Op 9 augustus om 0:00 uur (UTC) <a href="/price/moonbeam-glmr" rel="nofollow noopener noreferrer" target="_blank">Moonbeam</a> zal 3,04 miljoen GLMRs (ongeveer $700.000) ontgrendelen, goed voor 0,44% van de omloopvoorraad;</p>
<p>Op 12 augustus om 0:00 uur (UTC) <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> zal 4,54 miljoen APT’s ontgrendelen (ongeveer $30,58 miljoen), wat overeenkomt met 2,07% van de circulerende voorraad;</p>
<p>Om 10:00 uur (UTC) op 12 augustus, <a href="/price/immutablex-imx" rel="nofollow noopener noreferrer" target="_blank">ImmutableX</a> zal 18,08 miljoen IMX’s ontgrendelen (ongeveer $13,51 miljoen), wat overeenkomt met 1,67% van de circulerende voorraad.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag490203"><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-BTC667204"><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/1691388052BTC.png" alt=""><br>Deze week komt tot een convergerend einde, waarbij we blijven wachten op een gekozen richting. Risicovolle long instapstrategie: $28.550 USD; Risicovolle short instapstrategie: $27.950 USD met een voortdurende kijk naar het niveau van $26,5K USD.</p>
<h3 id="h3-KAS586530"><a name="KAS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>KAS</h3><p><img src="https://gimg2.gateimg.com/image/article/1691388068KAS.png" alt=""><br>De vermelde instapprijs van vorige week was $0,4250 USD en deze week blijft nieuwe historische hoogtepunten bereiken, waarbij kortstondig $0,05217 USD wordt bereikt en een winst van 22,68% wordt behaald. Zodra de consolidatie is voltooid, is een aanhoudende push richting $0,065379 USD, $0,10483 USD en het belangrijkste doel van $0,14428 USD mogelijk.</p>
<h3 id="h3-WLD700211"><a name="WLD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WLD</h3><p><img src="https://gimg2.gateimg.com/image/article/1691388085WLD.png" alt=""><br>Een bullish “W” patroon is gevormd sinds de introductie van de munt. Als je optimistisch bent over de WLD fundamentals, let dan op een blijvende doorbraak boven de vorige hoogtepunt van $2,55 USD, met daaropvolgende doelen op $2,584 USD, $2,785 USD en $2,925 USD. Stel een stop-loss in op het vorige dieptepunt van $1,845 USD.</p>
<h2 id="h2-Macro20Begin20met20speculeren20over20renteverhogingen20focus20op20de20Amerikaanse20CPIgegevens20van20donderdag505181"><a name="Macro: Begin met speculeren over renteverhogingen, focus op de Amerikaanse CPI-gegevens van donderdag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Begin met speculeren over renteverhogingen, focus op de Amerikaanse CPI-gegevens van donderdag</h2><p>Tot nu toe heeft de Amerikaanse aandelenmarkt de verwachtingen van investeerders voor 2023 overtroffen.</p>
<p>Oorspronkelijk dachten mensen dat de renteverhogingscyclus de aandelenmarkt niet zou verbeteren tot het einde van het jaar. Toch is de S&amp;P 500-index dit jaar met 18% gestegen, slechts 6% verwijderd van het historische hoogtepunt van 4796 punten dat in januari 2022 werd bereikt.</p>
<p>De markt is nu bijna onbeschermd, en omdat bulls te zelfgenoegzaam zijn om bescherming te kopen, is neerwaartse hedging de goedkoopste periode in de geschiedenis geworden, waarbij veel mensen op alles wedden.</p>
<p>Na enkele maanden van rust is deze week de S&amp;P 500 en de Nasdaq-index gedaald naar het grootste wekelijkse verlies sinds de bankencrisis in maart, wat een waarschuwingssignaal is voor de markt. Sommige voorspellers waarschuwen dat inflatie mogelijk meer verrassingen met zich meebrengt wanneer de recente rally op de aandelenmarkt tekenen van schuim vertoont.</p>
<p>Marko Kolanovic, een strateeg bij JPMorgan Chase, verklaarde dat de speculatie van kunstmatige intelligentie een aandelenschuim creëert, dat het risico loopt te barsten. ‘S Werelds grootste vermogensbeheerder, Blackstone, heeft gewaarschuwd dat de “achtbaaninflatie” een periode van volatiliteit ingaat, wat slecht nieuws is voor aandelen. Goed economisch nieuws, zoals een daling van de inflatie, hoeft niet per se goed nieuws te zijn voor de markt. Rosenberg Research wees erop dat het industriële gemiddelde van de Dow Jones onlangs 13 opeenvolgende dagen is gestegen, de langste sinds 1987.</p>
<p>De laatste keer dat de Dow Jones Industrial Average steeg met 28% in 13 dagen, daalde het vervolgens met 19% in oktober van dat jaar. Een reden om echter te overwegen om Amerikaanse aandelen te ondersteunen, is dat de economische recessie voor onbepaalde tijd is uitgesteld. Het ‘verborgen stimuleringspakket’ van $1 biljoen heeft financiering geleverd voor Biden Economics, en zelfs Fitch heeft dit nu ontdekt, wat heeft geleid tot een verlaging van de Amerikaanse rating.</p>
<p>De niet-agrarische werkgelegenheid in de Verenigde Staten is na de aanpassing van het kwartaal in juli met 187.000 mensen gestegen, de kleinste stijging sinds december 2020 en lager dan verwacht voor de tweede opeenvolgende maand. Het werkloosheidspercentage in de Verenigde Staten daalde verder naar 3,5% in juli, slechts iets hoger dan het dieptepunt van 3,4% eerder dit jaar, meer dan een halve eeuw geleden. Na de publicatie van de gegevens verminderden handelaren hun weddenschappen op verdere renteverhogingen door de Federal Reserve.</p>
<p>Federal Reserve-gouverneur Bowman verklaarde dat de Federal Reserve de rente mogelijk verder moet verhogen om de prijsstabiliteit volledig te herstellen. Bowman verklaarde dat zij de beslissing steunt om de rente te verhogen tijdens de Federal Reserve-vergadering van vorige maand. Hoewel latere gepubliceerde gegevens een vertraging in prijsgroei lieten zien, zei Bowman dat zij meer bewijs van aanhoudende deflatie zou willen zien. Daarnaast bekritiseerde zij ook het kapitaalvoorstel van de bank.</p>
<p>Deze week is er een belangrijk tijdstip. Om 12:30 (UTC) op donderdagavond werd de kwartaal CPI-jaarlijkse rente voor eind juli aangekondigd, met een vorige waarde van 3% en een voorspelling van 3,3%. Deze gegevens worden alleen gebruikt als referentie voor de Federal Reserve om te beslissen of ze de rente willen verhogen. Momenteel is de waarschijnlijkheid van een renteverhoging in september zeer laag in de macro-marktprognose, dus moeten we letten op elke macrogegevens die van invloed zijn op de beslissing om de rente te verhogen.</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 visie 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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>