RGFnZWxpamtzIE5pZXV3cyB8IFR3aXR0ZXIgb250aHVsZGUgZWVuIG5pZXV3IFgtbG9nbywgV29ybGRjb2luIGxhbmNlZXJ0IG9mZmljaWVlbCBXTEQtdG9rZW5zLCBCbG9vbWJlcmcgdm9vcnNwZWx0IGRhdCBkZSBGZWQgcmVudGV2ZXJob2dpbmdlbiB6YWwgb3BzY2hvcnRlbiBuYSBqdWxp

2023-07-25, 04:14

<p><img src="https://gimg2.gateimg.com/image/article/16902640730725.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Twitter20nam20afscheid20van20het20tijdperk20van20de20Blue20Bird20Worldcoin20lanceerde20officieel20WLDtokens20en20BTC20HODLers20holdings20bereikten20een20historisch20hoogtepunt366198"><a name="Crypto Dagelijks Overzicht: Twitter nam afscheid van het tijdperk van de “Blue Bird”, Worldcoin lanceerde officieel WLD-tokens, en BTC HODLers’ holdings bereikten een historisch hoogtepunt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Twitter nam afscheid van het tijdperk van de “Blue Bird”, Worldcoin lanceerde officieel WLD-tokens, en BTC HODLers’ holdings bereikten een historisch hoogtepunt</h2><p>Volgens de officiële Twitter-accountpagina heeft het account zijn avatar gewijzigd naar het X-logo en is de account-ID ook ingesteld op ‘X’. Musk verklaarde dat het Twitter-merk geleidelijk afscheid zal nemen van het beeld van de ‘Blue Bird’ en het zal vervangen door het X-logo.</p>
<p>Musk heeft zijn persoonlijke Twitter-accountprofiel gewijzigd naar het “X” -logo. Musk tweette op 22 juli dat X.com is gekoppeld aan Twitter en vandaag een tijdelijk X-logo zal lanceren.</p>
<p>Met Elon Musk die gisteren plannen aankondigde om het iconische Blue Bird-logo van Twitter te rebranden en te vervangen door het X-logo, werden er ‘s nachts verschillende tokens gelanceerd die gemarkeerd waren met ‘X’ en een abnormale groei zagen.</p>
<p>Na een tweet van Musk hebben enkele speculatieve ontwikkelaars in het weekend nieuwe tokens uitgegeven, waarvan één token genaamd ‘AI-X’ (met hetzelfde logo als het ruimtevaarttechnologiebedrijf SpaceX van Musk) met een factor tien is gestegen, en het andere token genaamd ‘Deus X’ met 2600% is gestegen.</p>
<p>Professionele handelaren verklaarden dat dit <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> bestaat omdat mainstream valuta zoals BTC en ETH weinig volatiliteit ervaren, waardoor sommige marktdeelnemers inzetten op meme munten en cryptocurrencies met een lage marktkapitalisatie.</p>
<p>Gisteren heeft Worldcoin officieel de lancering van WLD-tokens aangekondigd, die zullen worden verdeeld onder meer dan 2 miljoen mensen wereldwijd. In de verklaring beloofde Worldcoin de registratie te versnellen door Orbs in te zetten in meer dan 35 steden in 20 landen wereldwijd.</p>
<p>Individuen die Orb-verificatie doorstaan, zullen aanvankelijk 25 WLD-tokens en toekomstige reguliere subsidies ontvangen. De exacte token-economie van het project wordt naar verwachting later op maandag aangekondigd. Vanwege regelgevingsonzekerheid zal WLD niet kunnen worden gebruikt in de Verenigde Staten.</p>
<p>Volgens de gegevens van de World App-pagina is de Genesis Grant-ronde geopend voor claim, met een openingsperiode van 24 juli tot 31 juli. Niet-geverifieerde iris-gebruikers kunnen nog steeds 25 WLD’s vooraf claimen, die 365 dagen worden bewaard. pre-claim gebruikers kunnen hun WLD-tokens overdragen na voltooiing van iris-verificatie. Op het moment van publicatie hebben 3703 gebruikers pre-claim voltooid, met een maximum van 1 miljoen claim-gebruikers; 3405 gebruikers hebben de claim voltooid.</p>
<p>Er wordt gemeld dat het project een van de meest controversiële projecten is in het crypto-veld. Het richt zich erop mensen persoonlijk te helpen hun referenties te verifiëren via de iris-scanbal om hun identiteit online te bewijzen. Meer dan 2 miljoen mensen (waarvan de meeste uit landen op het zuidelijk halfrond komen) hebben verificatie doorstaan en vandaag zullen ze allemaal hun rechtmatige aandeel in WLD-tokens ontvangen.</p>
<p>Volgens de token-economie vrijgegeven door Worldcoin wordt 75% toegewezen aan gemeenschappen, 9,8% aan teams, 13,5% aan TFH-investeerders en 1,7% aan TFH-reserves. De eerste omloop bedroeg 143 miljoen, inclusief 100 miljoen leningen aan market makers, en meer dan 43 miljoen WLD-tokens werden toegewezen vóór de release. Inflatie bedraagt 1,5% per jaar en wordt verwacht te beginnen over 15 jaar.</p>
<p>Uit het wekelijkse gegevensrapport van Glassnode blijkt dat langetermijnhouders van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> (d.w.z. portefeuilleadressen die al minstens 155 dagen <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> in bezit hebben) controleren nu driekwart van de circulerende voorraad van Bitcoin, met een recordhoogte in bezit.</p>
<p>Glassnode-gegevens tonen aan dat het saldo op deze portefeuilles deze maand met 62.882 BTC’s ($1,83 miljard) is gestegen, waardoor het een recordhoogte van 14,52 miljoen BTC’s heeft bereikt, die de piek van 14,48 miljoen BTC’s op 21 mei overtreft. Deze nieuwe hoogte betekent dat dergelijke houders 75% van de huidige voorraad van 19,437 miljoen Bitcoins hebben.</p>
<p>Glassnode tweette: “het geeft aan dat HODLing de voorkeur heeft bij volwassen investeerders als marktdynamiek.” Entiteiten met onvoldoende liquiditeit of online deelnemers met bijna geen historie van uitgaven beheersen de <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stromen</a> Het tempo van het overmaken van geld naar portefeuilles geeft aan dat de accumulatie van gebruikers op de markt doorgaat en de druk van verkopers blijft afnemen. Deze maand is het aantal Bitcoins in handen van deze illiquide entiteiten met meer dan 90.000 gestegen.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag139315"><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-BTC229456"><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/1690264117BTC.png" alt=""><br>Op korte termijn daalde de prijs onder de $29,5K USD met een verhoogd handelsvolume. De volgende ondersteuning om op te letten is op $28,535 USD, en er bestaat een mogelijkheid van een retracement in de grotere uptrend. Voor de bullish strategie is het raadzaam om de paarse trendlijn te monitoren; een doorbraak eronder zou het einde van de oplevingstrend van dit jaar kunnen signaleren. Het belangrijkste ondersteuningsniveau om vast te houden is $28,535 USD.</p>
<h3 id="h3-ETH48198"><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/1690264140ETH.png" alt=""><br>Op korte termijn is de trend onder de eerste ondersteuning van de opwaartse structuur gebroken en gisteren zag het een significante volumedaling onder de steun van $1.857 USD. De bearish strategie suggereert om te wachten op een rebound tot $1.857 USD om een short positie te initiëren met als doel $1.755 USD. De korte termijn trend is bearish-georiënteerd.</p>
<h3 id="h3-UNIBOT910236"><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/1690264158UNIBOT.png" alt=""><br>Op korte termijn kan het blijven dalen samen met de bredere markt. Let goed op de sterke ondersteuning op $103.03 USD. Als er een aanhoudende opwaartse beweging is, zijn de volgende doelen achtereenvolgens $213.18 USD, $289.19 USD en $336.16 USD.</p>
<h2 id="h2-Macro20Bloomberg20kijkt20vooruit20naar20de20wekelijkse20rentebeslissing20van20de20Fed20en20voorspelt20een20langdurige20pauze20in20renteverhogingen20na20juli605625"><a name="Macro: Bloomberg kijkt vooruit naar de wekelijkse rentebeslissing van de Fed en voorspelt een langdurige pauze in renteverhogingen na juli" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Bloomberg kijkt vooruit naar de wekelijkse rentebeslissing van de Fed en voorspelt een langdurige pauze in renteverhogingen na juli</h2><p>Bloomberg schreef een artikel waarin vooruit werd gekeken naar de rentevergadering van het Federal Reserve FOMC deze week. Hierin werd vermeld dat de Federal Reserve van plan is om de rente met 25 basispunten te verhogen tijdens de vergadering in juli.</p>
<p>Sinds de bijeenkomst in het midden van juni hebben gemengde economische gegevens mogelijk niet het interne debat binnen de Federal Reserve tot rust gebracht over of de renteverhoging in juli de laatste zou moeten zijn.</p>
<p>Daarom kan Powells toespraak tijdens de persconferentie zowel de duiven als de haviken aanspreken.</p>
<p>Hij kan erop wijzen dat het economisch perspectief helderder is geworden en het proces van dalende inflatie verder gevorderd is, wat betekent dat de weg naar een ‘zachte landing’ is verbreed.</p>
<p>Gezien de onzekerheid van de achterblijvende monetair beleid, zou hij kunnen suggereren dat de Federal Reserve een afwachtende houding kan aannemen tijdens de volgende vergadering, terwijl hij waarschuwt dat sommige FOMC-leden nog steeds een renteverhoging verwachten later dit jaar.</p>
<p>Bloomberg’s benchmarkscenario is dat de Federal Reserve de rentestabiliteit handhaaft nadat de rente in juli is verhoogd, en vervolgens vanaf het tweede kwartaal van 2024 de rente begint te verlagen.</p>
<p>Er zijn echter nog steeds enkele potentiële negatieve aanbodschokken die het inflatieproces kunnen omkeren en uiteindelijk de Federal Reserve kunnen aanzetten om de renteverhogingen tegen het einde van 2024 te hervatten. De belangrijkste risico’s zijn onder meer wijdverspreide arbeidsstakingen en wereldwijde voedselprijsstijgingen als gevolg van weersomstandigheden. ‘Op dit moment beschrijven we de rentetrajectorie als een ‘langdurige pauze in renteverhogingen’ na juli, met zeer weinig kans dat de Federal Reserve daarna de renteverhogingen hervat.’</p>
<p>In één woord, gezien het feit dat recente economische gegevens de mogelijkheid van een zachte landing vergroten, is het onwaarschijnlijk dat de FOMC significante maatregelen zal nemen om de situatie te veranderen. Powell zal een afwachtende houding aannemen en aangeven dat hij de rente in de vergadering van september niet zal verhogen - wij geloven dat deze ‘overslaan’ zal leiden tot een langdurige inactiviteit.</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 beleggingsadviezen.<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 in g van auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>