RGFnZWxpamtzIE5pZXV3cyB8IFRlc2xhIGhlZWZ0IEJUQy12ZWxkIHZlcndpamRlcmQsICdzIHdlcmVsZHMgZWVyc3RlIGJsb2NrY2hhaW4tc2F0ZWxsaWV0IGlzIHN1Y2Nlc3ZvbCBnZWxhbmNlZXJkLCBEQUkgaGVlZnQgQlVTRCBvdmVydHJvZmZlbiBlbiBpcyBkZSBvcCB0d2VlIG5hIGdyb290c3RlIHN0YWJsZWNvaW4gZ2V3b3JkZW4

2023-07-24, 03:35

<p><img src="https://gimg2.gateimg.com/image/article/16901782410724.jpg" alt=""></p>
<h2 id="h2-Cryptodagelijks20overzicht20s20werelds20eerste20visuele20blockchainsatelliet20in20een20baan20om20de20aarde20is20succesvol20gelanceerd20LTChalveringsevenement20telt20af20naar201020dagen20en20DAI20heeft20BUSD20overtroffen20en20is20nu20de20op20twee20na20grootste20stablecoin951181"><a name="Cryptodagelijks overzicht: ‘s werelds eerste visuele blockchain-satelliet in een baan om de aarde is succesvol gelanceerd, LTC-halveringsevenement telt af naar 10 dagen, en DAI heeft BUSD overtroffen en is nu de op twee na grootste stablecoin." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cryptodagelijks overzicht: ‘s werelds eerste visuele blockchain-satelliet in een baan om de aarde is succesvol gelanceerd, LTC-halveringsevenement telt af naar 10 dagen, en DAI heeft BUSD overtroffen en is nu de op twee na grootste stablecoin.</h2><p>Volgens Red Star News werd op 22 juli om 5:07 uur (UTC) met succes de ‘Tai’an’ (Star Times-16) satelliet in een baan om de aarde gebracht bij het Jiuquan Satellite Launch Center in China, met de zesde Ceres 1 draagraket. Dit is ‘s werelds eerste visuele blockchain-satelliet in een baan om de aarde, wat ook het voltooien van de 12e ruimtemissie van NationStar Aerospace markeert en het netwerkproces van de Star Age AI Satellite. <a href="/price/constellation-dag" rel="nofollow noopener noreferrer" target="_blank">Constellatie</a> zal gestaag worden gepromoot in 2023.</p>
<p>Er wordt begrepen dat de ‘Tai’an’ (Star Times-16) satelliet gebruik maakt van het ADASAT-30 lichtgewicht intelligente satellietplatform ontwikkeld door NationStar Aerospace, en configureert een hoogwaardige hyperspectrale remote sensing payload. Ondertussen is het voor het eerst uitgerust met de on-orbit blockchain ADAChain payload en satelliet scherm systeem, innovatief ontwikkeld door NationStar Aerospace, en zal het ‘s werelds eerste visuele blockchain on-orbit certificaatopslag en commerciële diensten implementeren, en een reeks van ruimte-computing content-toepassingen lanceren zoals het werelds eerste ruimte digitale leven sociale platform (Interstellar Immortal Passenger).</p>
<p>OpenSea in de NFT-markt heeft de lancering van Deals aangekondigd, een peer-to-peer NFT-ruilfunctie die handelaren helpt favorieten toe te voegen en rechtstreeks te communiceren met andere verzamelaars. Met Deals kunnen verzamelaars NFT’s met elkaar verhandelen, inclusief WETH, dat wordt ondersteund door het native NFT-protocol van OpenSea, Seaport.</p>
<p>OpenSea voegde eraan toe dat het doel van het product is om het NFT-uitwisselingsproces betrouwbaar te maken en te voorkomen dat gebruikers worden misleid door valse websites van derden of links tijdens transacties.</p>
<p>Volgens het betalingsinterface voor de aankoop van Tesla-auto’s, de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het veld in de broncode is verwijderd. Er wordt gemeld dat Tesla op 24 maart 2021 zijn steun heeft aangekondigd voor de betaling met <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> voor de aankoop van auto’s en deze steun op 13 mei van hetzelfde jaar heeft ingetrokken.</p>
<p>Gegevens tonen aan dat er nog ongeveer 10 dagen (5.868 blokken) te gaan zijn voor de <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> De blokbeloning van (LTC) wordt gehalveerd. De halvering wordt verwacht op 2 augustus en de blokbeloning tijdens de sessie wordt teruggebracht van 12,5 LTC naar 6,25 LTC.</p>
<p>Wie is momenteel de Gate.io Profeet Keizer: Raad de LTC-prijs &amp; Deel $25.000 LTC-prijzen zijn in volle gang. We verwelkomen iedereen om actief deel te nemen. <a href="https://www.gate.io/activities/guess-price/?ch=LTCprice_WB_20230720&amp;utm_campaign=TR_ECt0LFlE&amp;utm_content=&amp;utm_medium=CPM&amp;utm_source=CH_czI0EJaM&amp;utm_term=" target="_blank">Raad nu</a>!</p>
<p>Volgens CoinMarketCap-gegevens heeft de marktwaarde van de stablecoin DAI BUSD overtroffen en is het de op twee na grootste stablecoin geworden. Op het moment van schrijven bedroeg de marktwaarde van DAI $4,598 miljard, op de tweede plaats na . <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> ($83,8 miljard) en USDC ($26,8 miljard), terwijl de marktwaarde van BUSD $3,85 miljard bedroeg, wat op de vierde plaats staat qua marktwaarde van stablecoins.</p>
<p>Op 24 juli plaatste Worldcoin, een cryptocurrencybedrijf opgericht door Sam Altman, CEO van OpenAI, een foto op sociale media en schreef “Het is tijd. 24.7.23,” dit impliceerde dat er vandaag belangrijk nieuws zou worden vrijgegeven.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20Vandaag756469"><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-BTC551417"><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/1690178288BTC.png" alt=""><br>De markt bevindt zich momenteel in een consolidatiefase zonder duidelijke richting. Het is niet in staat geweest om boven de $30.480 USD uit te breken en blijft ondersteund boven de $29.500 USD. Maak gebruik van de strategie van hoog verkopen en laag kopen voor opportunistische instapmomenten. Als er een uitbraak plaatsvindt, zijn mogelijke doelen $36.000 USD en een top rond $40.500 USD. Als het onder de $26.500 USD daalt, neemt de mogelijkheid van een einde aan de opleving van dit jaar toe.</p>
<h3 id="h3-ETH837775"><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/1690178317ETH.png" alt=""><br>De korte termijn trend is onder de eerste belangrijke ondersteuning in de opgaande structuur gezakt. Een conservatieve benadering is om te wachten op een doorbraak boven $2.036 USD als een bullish signaal. Het medium-termijn doel is ingesteld op $2.358 USD, en het doorbreken van $2.036 USD zou een ommekeer naar een bullish standpunt aangeven.</p>
<h3 id="h3-LTC252931"><a name="LTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1690178338LTC.png" alt=""><br>Bewaak of LTC stabiel kan blijven boven $93,39 USD voor een mogelijke korte termijn positie. Het korte termijn vooruitzicht is een mix van bullish en bearish sentimenten.</p>
<h2 id="h2-Macro20De20inflatie20neemt20af20en20een20renteverhoging20van202520bp20is20een20consensus20geworden20Let20op20belangrijke20gegevens20deze20woensdag20en20donderdag161488"><a name="Macro: De inflatie neemt af en een renteverhoging van 25 bp is een consensus geworden; Let op belangrijke gegevens deze woensdag en donderdag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De inflatie neemt af en een renteverhoging van 25 bp is een consensus geworden; Let op belangrijke gegevens deze woensdag en donderdag</h2><p>Volgens de gegevens bereiden beleidsmakers van de Federal Reserve zich voor om de rentetarieven op woensdag naar het hoogste niveau in 22 jaar te verhogen, terwijl ze een verkrappingstrend handhaven en aangeven dat later dit jaar mogelijk verdere maatregelen worden genomen.</p>
<p>Het Federal Open Market Committee (FOMC) wordt verwacht de rente met een kwart procentpunt te verhogen naar 5,25% -5,5%, wat de 11e renteverhoging is in de afgelopen 16 maanden.</p>
<p>De renteverhoging in juli werd uitgevoerd na een pauze in juni, om het tempo van renteverhogingen te vertragen toen de rentetarieven een voldoende niveau bereikten om de inflatie in de loop van de tijd terug te brengen naar het streefcijfer van 2%.</p>
<p>Desalniettemin hopen Powell en andere beleidsmakers nog steeds een vastberaden houding te tonen en de mogelijkheid open te houden om de rente opnieuw te verhogen om een nieuwe prijsstijging te voorkomen.</p>
<p>James Knightley, hoofdeconoom internationale zaken van de Nederlandse Internationale Bank, zei: “De inflatie neemt af, maar het gaat niet snel genoeg voor de Federal Reserve; aangezien de arbeidsmarkt sterk blijft, zullen functionarissen geen risico’s nemen.”</p>
<p>Op woensdag 27 juli 2023 om 19 uur (UTC) heeft de Federal Reserve besloten de rente te verhogen. De markt verwacht of is overeengekomen dat deze renteverhoging 25 basispunten zal zijn.</p>
<p>Na de renteverhoging om 19:30 uur (UTC) op de 27e houdt Powell een persconferentie om 19:30 uur (UTC). Verwacht wordt dat veel van zijn toespraken gedeeltelijk door de markt zijn verwerkt, zoals een renteverhoging met 25 basispunten, maar hij zal nadrukkelijk benadrukken dat de economie nog steeds oververhit is en zal blijven beoordelen of en hoe vaak de rente in de toekomst moet worden verhoogd op basis van gegevens.</p>
<p>Donderdag (28 juli) is een drukke dag, met een renteverhoging om 19.00 uur (UTC) en gegevens over de werkloosheidsuitkering voor de week die om 13.30 uur (UTC) wordt vrijgegeven, met een vorige waarde van 22,8. Naast de werkloosheidsgegevens worden ook gegevens zoals het initiële jaarlijkse bbp-percentage voor het tweede kwartaal vrijgegeven.</p>
<p>Deze woensdag en donderdag zijn cruciale dagen, dus het is belangrijk om marktfluctuaties te monitoren.</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 beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het opnieuw plaatsen van het artikel is toegestaan, mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>