RGFnZWxpamtzIG5pZXV3cyB8IE1lZXIgZGFuIDkwJSB2YW4gZGUgQWx0Y29pbi1ob3VkZXJzIGxlZWQgdmVybGllemVuLCBIS01BIHB1YmxpY2VlcmRlIGVlbiByYXBwb3J0IG92ZXIgZGUgJ1Rva2VuaXNhdGllIHZhbiBIb25nIEtvbmcgT2JsaWdhdGllcycsIGRlIG9temV0IHZhbiBOdmlkaWEgb3ZlcnRyb2YgZGUgdmVyd2FjaHRpbmd

2023-08-25, 04:08

<p><img src="https://gimg2.gateimg.com/image/article/16929441090825.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20CentraalAfrikaanse20Republiek20heeft20de20Tokenization20Law20aangenomen20en20de20Hong20Kong20Monetary20Authority20heeft20een20rapport20uitgebracht20over20de20Tokenization20of20Hong20Kong20Bonds549857"><a name="Crypto Dagelijkse Samenvatting: De Centraal-Afrikaanse Republiek heeft de Tokenization Law aangenomen, en de Hong Kong Monetary Authority heeft een rapport uitgebracht over de “Tokenization of Hong Kong Bonds”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De Centraal-Afrikaanse Republiek heeft de Tokenization Law aangenomen, en de Hong Kong Monetary Authority heeft een rapport uitgebracht over de “Tokenization of Hong Kong Bonds”</h2><p>Het Sango-platform gebaseerd op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De side chain gelanceerd door de Centraal-Afrikaanse Republiek stelt dat het land de Tokenization Law heeft aangenomen, waarbij de tokenisatie van land en natuurlijke hulpbronnen wordt goedgekeurd. Lokale en internationale ondernemers zullen in staat zijn om onroerend goed, landbouw en natuurlijke hulpbronnen te integreren via de blockchain-integratie van het Sango-platform.</p>
<p>De Centraal-Afrikaanse Republiek lanceerde op 25 juli 2022 het Sango-platform op basis van de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> side chain en lanceerde de pre-sale van SANGO-tokens, die de inheemse cryptocurrency van het ecosysteem zijn. De totale voorraad SANGO is 21 miljard.</p>
<p>De Hong Kong Monetary Authority (HKMA) heeft een rapport uitgebracht over de tokenisatie van Hong Kong obligaties en kan van tijd tot tijd tokenized groene obligaties uitgeven. Het rapport geeft een gedetailleerde introductie van de ervaring van Hong Kong bij het uitgeven van tokenized groene obligaties voor de eerste keer, waarbij wordt gesteld dat bond tokenization nog in de beginfase verkeert en dat er meerdere uitdagingen moeten worden overwonnen om het breed geaccepteerd te maken. De bestaande juridische en regelgevende en moeten mogelijk ook worden aangepast om gelijke tred te houden en de adoptie van technologie te bevorderen. De Monetaire Autoriteit zal blijven samenwerken met de overheid en andere belanghebbenden om de resterende problemen aan te pakken, om het ecosysteem verder te versterken en de wijdverbreide adoptie van tokenisatie te ondersteunen.</p>
<p>Nvidia’s Q2-omzet overtrof de verwachtingen, waarbij AI-gerelateerde tokens over het algemeen stegen. Nvidia heeft zijn financieel rapport voor het tweede kwartaal aangekondigd, met een sterke vraag naar chips voor kunstmatige intelligentie, wat resulteerde in een tweedekwartaalwinst die aanzienlijk hoger was dan de verwachtingen van Wall Street, met een omzet van $13,5 miljard, een stijging van 88% ten opzichte van het eerste kwartaal. Het omzetcijfer van het bedrijf is meer dan $2 miljard hoger dan de voorspelling van analisten van $11,2 miljard.</p>
<p>Als alternatief hebben AI-gerelateerde cryptocurrencies zoals FET, RNDR en AGIX allemaal een maximale stijging van meer dan 4% ervaren in de afgelopen 24 uur, als gevolg van deze impact.</p>
<p>Wat gegevensverandering betreft, nadert de DeFi TVL van het hele netwerk zijn dieptepunt sinds februari 2021, momenteel ongeveer $ 38,18 miljard.</p>
<p>Meer dan 90% van de Altcoin-houders verkeren in een verliespositie. Volgens gegevens die zijn vrijgegeven door het versleutelde intelligentieplatform IntoTheBlock, verkeert meer dan 90% van de Altcoin-houders in een verliespositie, en de stemresultaten tonen aan dat DeFi-tokens beter presteren. De belangrijkste DeFi-tokens zijn <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Compound</a> (COMP), <a href="/price/0x-zrx" rel="nofollow noopener noreferrer" target="_blank">0x</a> Protocol (ZRX), <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> (UNI), AAVE, en Maker (MKR). Daarvan is MKR de token met de kleinste verandering in winstgevendheid voor investeerders.</p>
<p>Specifiek identificeert het MKR als het meest winstgevende bezit voor houders gedurende het grootste deel van het jaar. Slechts 52,36% van de MKR-houders bevindt zich in een verliespositie. Evenzo zijn UNI- en AAVE-investeerders in een verliespositie goed voor respectievelijk 71,93% en 76,35% van de houders.</p>
<p>Laten we ons nu richten op de NFT-markt.</p>
<p>Volgens Nansen-gegevens zijn de minimumprijzen van sommige blue-chip NFT-series in de afgelopen 30 dagen met meer dan 25% gedaald, waarbij de minimumprijzen van BAYC met 27% zijn gedaald, de minimumprijzen van DeGods met 55% zijn gedaald en de minimumprijzen van Azuki met 36% zijn gedaald. Ondertussen is de Nansen NFT-500 index dit jaar met 40% gedaald, terwijl de Blue Chip 10 index met 33% is gedaald.</p>
<p>Tijdens deze periode waren er echter ook enkele NFT-series die het goed deden, zoals de stijging van de prijzen van Milady-vloeren met 66%; De prijs van Sproto Gremlins-vloeren is met 262% omhooggeschoten.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20Vandaag696321"><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-BTC144129"><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/1692936379BTC 0825.png" alt=""><br>De dagelijkse grafiek toont een herstel in het handelsvolume dat het korte-termijn gemiddelde bereikt, gevolgd door een snelle daling naar het niveau van $26.000 USD. De secundaire marktstructuur neigt nog steeds naar een verkopersmarkt. Op korte termijn moet aandacht worden besteed aan de vraag of de ondersteuning van $25.606 USD standhoudt. Er wordt verwacht dat de handel van vandaag zich zal blijven schommelen binnen het bereik van $25.606 USD tot $26.975 USD.</p>
<h3 id="h3-ETH812738"><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/1692936393ETH 0825.png" alt=""><br>Na twee keer te zijn uitgebodemd binnen de opwaartse trend, vond er een herstel plaats richting de belangrijkste weerstand van $1.694 USD, gevolgd door vier pogingen om de drempel van $1.700 USD te doorbreken. De algehele markt behoudt nog steeds de centrale structuur rond $1.658 USD, wat wijst op een bearish trend. Het belangrijkste ondersteuningsniveau is verschoven naar $1.610 USD.</p>
<h3 id="h3-DOGE499995"><a name="DOGE" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DOGE</h3><p><img src="https://gimg2.gateimg.com/image/article/1692936404DOGE 0825.png" alt=""><br>De dagelijkse grafiek is al 835 dagen in een significante neerwaartse trend. Het einde van deze neerwaartse trend wordt verwacht rond 15 oktober 2023, wat mogelijk leidt tot een aanzienlijke trendverandering voordat het jaar eindigt. Met de basisprijs die stabiel blijft op $0.05099 USD, kunnen de potentiële onafhankelijke trends zich richten op $0.10799 USD, $0.15879 USD, $0.43360 USD en nieuwe historische hoogtepunten.</p>
<h2 id="h2-Macro20Sommigen20hebben20de20neiging20om20gematigd20te20zijn20en20de20rest20om20agressief20te20zijn20binnen20de20Federal20Reserve20focus20op20de20toespraak20van20Powell20vanavond717143"><a name="Macro: Sommigen hebben de neiging om gematigd te zijn en de rest om agressief te zijn binnen de Federal Reserve, focus op de toespraak van Powell vanavond" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Sommigen hebben de neiging om gematigd te zijn en de rest om agressief te zijn binnen de Federal Reserve, focus op de toespraak van Powell vanavond</h2><p>De drie belangrijkste Amerikaanse aandelenindices openden hoog en sloten laag, waarbij de Dow 1% lager sloot, de Nasdaq 1,87% lager sloot, en de S&amp;P 500-index 1,3% lager sloot. De Nasdaq China Golden Dragon Index sloot 0,66% lager. De Vietnamese fabrikant van elektrische voertuigen VinFast doorbrak de trend en sloot 32% hoger op een nieuw sluitingshoogtepunt, met een marktwaarde van $114 miljard. De Nvidia, die aanzienlijk hoger opende, schommelde lager gedurende de dag en eindigde uiteindelijk slechts 0,12% hoger.</p>
<p>Het aantal eerste aanvragen voor werkloosheidsuitkeringen in de Verenigde Staten voor de week die eindigde op 19 augustus bereikte 230.000, een dieptepunt van drie weken, lager dan de verwachte 240.000. De vorige waarde werd herzien van 240.000 naar 239.000, wat aangeeft dat de arbeidsmarkt nog steeds gespannen is. De Amerikaanse dollarindex herstelde sterk en eindigde 0,6% hoger op 104, wat de eerste keer sinds 8 juni was. Het rendement van Amerikaanse schatkistpapier steeg, het rendement van Amerikaanse 10-jarige schatkistpapier sloot op 4,245% en het rendement van tweejarige Amerikaanse schatkistpapier steeg opnieuw naar 5%.</p>
<p>Gisteravond was het nieuwsniveau behoorlijk levendig; sommige neigen naar duiven en de rest naar haviken, waardoor de markt in chaos achterblijft. Laten we eens kijken wat deze functionarissen hebben gezegd.</p>
<p>Het stemmende comité van de FOMC van dit jaar en de voorzitter van de Philadelphia Fed, Huck, is van mening dat de Federal Reserve dit jaar de rentetarieven ongewijzigd zal handhaven; Als de inflatie afneemt, kunnen de rentetarieven volgend jaar worden verlaagd. Huck geloofde dat de rentetarieven volgend jaar zouden moeten worden verlaagd, wat in zekere mate voldeed aan de verwachtingen van de markt maar al snel werd tegengehouden door andere functionarissen.</p>
<p>In 2025 verklaarden het FOMC-stemcomité en de voorzitter van de Boston Fed, Collins, dat de rentetarieven mogelijk zeer dicht bij hun hoogste punt liggen, maar dat de mogelijkheid van verdere renteverhogingen niet moet worden uitgesloten. Voormalig voorzitter van de St. Louis Fed, Brad, verklaarde dat het economisch herstel mogelijk opwaartse druk op de inflatie uitoefent en dat er onzekerheid bestaat bij het voorspellen van neutrale rentetarieven.</p>
<p>Er is nu een meningsverschil binnen de Federal Reserve, en we weten niet of we volgend jaar de rente zullen verlagen. Tenminste weten we dat het in september in feite onmogelijk is om de rente te verhogen, en dan kunnen we hooguit één keer dit jaar de rente verhogen.</p>
<p>De toespraak van Powell vanavond is cruciaal. De analyse en voorspellingskans zal voornamelijk havikachtig blijven, en vervolgens zullen we op basis van gegevens beslissen of we al dan niet de rente verhogen, enzovoort. We zullen afwachten.</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 beleggingssuggesties.<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 zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>