RGFnZWxpamtzIG5pZXV3cyB8IE11c2sgcmljaHR0ZSB6aWNoIG9wIGhldCBpbnRlZ3JlcmVuIHZhbiBkZSBmaW5hbmNpw6tsZSB3ZXJlbGQgZG9vciBUd2l0dGVyIHRlIGhlcm5vZW1lbiwgaGV0IFZLIGJlZ29uIG1ldCBoZXQgYmVvb3JkZWxlbiB2YW4gV29ybGRjb2luLCBkZSBKYXBhbnNlIHByZW1pZXIgc3RldW5kZSBXZWIz

2023-07-26, 03:53

<p><img src="https://gimg2.gateimg.com/image/article/16903516110727.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Musk20reageerde20dat20Twitter20zijn20naam20heeft20veranderd20om20de20financile20wereld20te20integreren20Het20Verenigd20Koninkrijk20is20begonnen20met20het20beoordelen20van20Worldcoin536147"><a name="Crypto Dagelijkse Samenvatting: Musk reageerde dat Twitter zijn naam heeft veranderd om de financiële wereld te integreren; Het Verenigd Koninkrijk is begonnen met het beoordelen van Worldcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Musk reageerde dat Twitter zijn naam heeft veranderd om de financiële wereld te integreren; Het Verenigd Koninkrijk is begonnen met het beoordelen van Worldcoin</h2><p>Musk reageerde op de hernoeming van Twitter door te schrijven dat Twitter werd overgenomen door X Corp, niet alleen om de vrijheid van meningsuiting te waarborgen, maar ook om alle toepassingen van X te bevorderen. Dit is niet zomaar een eenvoudige naamswijziging van het bedrijf, maar het (X Ecosysteem) doet hetzelfde.</p>
<p>De naam van Twitter was betekenisvol toen er vaak berichten werden verstuurd met slechts 140 tekens - zoals vogels die tjilpen - maar nu kun je bijna alles posten, inclusief enkele uren aan video’s.</p>
<p>In de komende maanden zal X zijn vermogen vergroten om uitgebreid te communiceren en gebruikers te beheren in de financiële wereld. De naam Twitter heeft geen betekenis in deze situatie, dus moeten we er afscheid van nemen.</p>
<p>OpenAI medeoprichter en Worldcoin oprichter Sam Altman verklaarde op zijn sociale media dat, net als andere ambitieuze projecten, Worldcoin al dan niet zal slagen, maar het proberen van dergelijke dingen is een manier om vooruitgang te boeken. Daarnaast verklaarde Sam Altman dat hij van plan is om binnen tien jaar een combinatie van Worldcoin en ChatGPT te zien.</p>
<p>Volgens Reuters heeft een woordvoerder van het kantoor van de informatiecommissaris, een Britse gegevensregulerende instantie, verklaard dat zij de lancering van het Worldcoin-project van de medeoprichter van OpenAI, Sam Altman, in het VK hebben opgemerkt en verdere onderzoeken zullen uitvoeren.</p>
<p>Ondertussen stelde ZachXBT, de ‘on-chain detective’, vragen bij Worldcoin in een artikel op sociale media, waarbij werd gesteld dat het projectteam heeft opgeschept over het aantal gebruikers, maar dat het mensen in ontwikkelingslanden heeft uitgebuit. Bovendien lijkt Worldcoin momenteel alleen de authenticatie van de authenticiteit van gebruikers op registratieniveau af te dwingen, wat resulteert in een zwarte markt voor accounts, in vergelijking met een vergoeding van slechts $1 per account op Telegram.</p>
<p>Volgens Coindesk heeft WorldCoin het percentage tokens dat wordt toegewezen aan interne medewerkers en investeerders verhoogd van 20% naar 25%. In eerdere projectvideo’s beweerde WorldCoin echter dat ‘WLD beter zou zijn dan BTC omdat BTC alleen in handen is van een paar rijke mensen’. ZachXBT zei dat bovenstaande problemen ervoor zorgden dat hij zich tegen het Worldcoin-project keerde, maar het WLD-verhaal kan veranderen door de prestaties van de token. Uiteindelijk geldt ‘prijsstijging = goed project, prijsdaling = dystopische nachtmerrie’.</p>
<p>Onlangs hield de Japanse premier Fumio Kishida een videotoespraak op het Tokyo International Forum over de ‘Next Stage of WebX Digital’, georganiseerd door Coinpost, waarin hij zei dat ‘Web3 deel uitmaakt van een nieuw soort kapitalisme’.</p>
<p>Web3 kan potentieel het traditionele raamwerk van het internet veranderen en sociale verandering teweegbrengen, en de overheid werkt aan het verbeteren van het milieu om <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> te bevorderen. Premier Kishida hoopte sterk dat grote Japanse bedrijven op deze conferentie een grootschalig project zouden aankondigen om een waardevolle economische zone in de Metaverse-ruimte aan de wereld te creëren, en hoopte dat de Web3-industrie weer aandacht en vitaliteit zou krijgen, en dat er meer nieuwe projecten zouden ontstaan.</p>
<p>Met de populariteit van Telegram-bots zijn sommige topgegevensplatforms ook begonnen met het volgen van dit voorbeeld, en Coinsecko heeft onlangs de Discord Bots-tokensectie toegevoegd. Er wordt gemeld dat de Discord Bots-tokensectie vijf soorten tokens heeft opgenomen: MEVFREE, COLLAB, TKB, ASAP en NOLO. De marktkapitalisatie van deze sectie bedraagt $9.860.749, met een handelsvolume van meer dan $1 miljoen in 24 uur.</p>
<h2 id="h2-Belangrijkste20token20trends20van20vandaag652687"><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-BTC662904"><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/1690350270BTC.png" alt=""><br>De huidige korte termijn markt is nog steeds onbeslist in zijn richting. Er is een mogelijkheid van een retracement in de algehele opwaartse trend. Als u een bullish strategie aanneemt, moet er nauwlettend worden gelet op de paarse lijn die de opwaartse trend vertegenwoordigt. Een doorbraak van deze trendlijn zou het einde van de opleving van dit jaar kunnen signaleren. Het volgende ondersteuningsniveau is $28,535 USD.</p>
<h3 id="h3-ETH105305"><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/1690350295ETH.png" alt=""><br>De korte termijn trend is opnieuw gedaald onder het ondersteuningsniveau van $1.857 USD. Een bearish strategie moet wachten op een rebound naar $1.857 USD voordat een short positie wordt overwogen met een doel van $1.755 USD. Als de middellange en langetermijnstructuur zich niet stabiliseert op $2.037 USD, blijft de algehele richting bearish.</p>
<h3 id="h3-UNIBOT592839"><a name="UNIBOT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>UNIBOT</h3><p><img src="https://gimg2.gateimg.com/image/article/1690350314UNIBO.png" alt=""><br>Een duidelijk omgekeerd hoofd en schouders patroon is ontstaan op de korte termijn uurlijkse grafiek, met sterke ondersteuning op $103.03 USD. Een doorbraakpositie kan worden overwogen, met de volgende mogelijke doelen op $213.18 USD, $289.19 USD en $336.16 USD.</p>
<h2 id="h2-Macro20Focus20op20een20renteverhoging20van202520basispunten20Het20wetsvoorstel20voor20cryptoregelgeving20in20de20VS20verloopt20soepel20wat20gunstig20is20voor20de20gezonde20ontwikkeling20van20de20cryptomarkt606392"><a name="Macro: Focus op een renteverhoging van 25 basispunten; Het wetsvoorstel voor crypto-regelgeving in de VS verloopt soepel, wat gunstig is voor de gezonde ontwikkeling van de cryptomarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Focus op een renteverhoging van 25 basispunten; Het wetsvoorstel voor crypto-regelgeving in de VS verloopt soepel, wat gunstig is voor de gezonde ontwikkeling van de cryptomarkt</h2><p>De Amerikaanse economische gegevens zijn nog steeds vol tegenstrijdigheden. Aan de ene kant steeg de index van het consumentenvertrouwen naar een hoogtepunt van twee jaar. Aan de andere kant bleef de productieactiviteit van de Richmond Federal Reserve in juli onderdrukt en werd de marktsentiment steeds gespannener. Hoewel de verwachting van een renteverhoging met 25 basispunten deze week is verwerkt, zal elke daaropvolgende begeleiding van Powell de markt aanwakkeren.</p>
<p>De Amerikaanse dollarindex daalde na 5 dagen van winsten en sloot 0,13% lager af op 101,27. Het rendement van Amerikaanse obligaties is in de hele markt gestegen, waarbij het korte-termijnrendement meer is gestegen dan het lange-termijnrendement. Het rendement op tweejarige Amerikaanse staatsleningen steeg kortstondig naar 4,91% en sloot bijna op 4,88%; Het rendement op tienjarige Amerikaanse staatsleningen steeg kortstondig naar 3,92% op die dag en sloot bijna op 3,88%.</p>
<p>Spot goud steeg op de vooravond van de belangrijke beslissing van de Federal Reserve en herstelde de $1.960-grens en sloot 0,51% hoger op $1.964,74 per ounce. De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk hoger, met de Dow Jones Index 0,08% hoger, de S&amp;P 500 Index 0,29% hoger en de Nasdaq 0,61% hoger.</p>
<p>Om 19.00 uur (UTC) op woensdag staat de Federal Reserve op het punt om een renteverhoging van 25 basispunten aan te kondigen, wat binnen de verwachtingen van de gehele macromarkt valt.</p>
<p>Echter heeft de markt ook verwachtingen van Powell’s toespraak, en er wordt algemeen aangenomen dat Powell’s toespraak meer havikachtig kan worden, waardoor de markt weer tot rust komt en niet op een hoog niveau blijft.</p>
<p>Kortom, de renteverhogingsresolutie om 19.00 uur (UTC) en de toespraak om 19.30 uur (UTC) liggen beide binnen de verwachtingen van handelaren.</p>
<p>The United States House of Representatives and Senate hebben een bipartisan protocol bereikt over het cryptocurrency wetsvoorstel, dat bedoeld is om te eisen dat het cryptocurrency handelsplatform zich registreert bij de Commodity Futures Trading Commission (CFTC) en een nieuw regelgevend kader creëert voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en de hele ‘alternatieve’ (niet-traditionele) industrie.</p>
<p>Het protocol is eindelijk gekomen. Uit het protocol blijkt dat beide partijen het CFTC-platform erkennen. In dit g geloven we dat er binnenkort een reeks regulerende wetten zal worden uitgevaardigd. De Verenigde Staten moeten de regelgevende wetten voor cryptocurrency inhalen, en landen over de hele wereld vaardigen regelgevende wetten uit, zoals Zuid-Korea, Japan, enzovoort. Als we wachten tot de Verenigde Staten eindelijk een wetsvoorstel aannemen, geloven we dat de crypto-industrie een andere wereld is en zich sneller zal ontwikkelen en evolueren.</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 mening 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 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>