RGFnZWxpamtzIG5pZXV3cyB8IFNFSSB6YWcgZWVuIHByaWpzdmVyc2NoaWwgb3AgbWVlcmRlcmUgcGxhdGZvcm1zLCBBSS10b2tlbnMga3VubmVuIHdvcmRlbiBvbmRlcndvcnBlbiBhYW4gU0VDLXRvZXppY2h0LCBCQVNFIHZlcnNjaGVlbiBpbiBkZSBhZmdlbG9wZW4gbWFhbmQgbWVlciBkYW4gNTAwIGZyYXVkdWxldXplIHRva2Vucy4

2023-08-17, 03:39

<p><img src="https://gimg2.gateimg.com/image/article/16922508050817.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20SEI20Verschijnt20Meerdere20Platform20Prijsverschillen20AI20Tokens20Kunnen20SEC20Onderzoek20Ondergaan938141"><a name="Crypto Dagelijkse Samenvatting: SEI Verschijnt Meerdere Platform Prijsverschillen, AI Tokens Kunnen SEC Onderzoek Ondergaan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: SEI Verschijnt Meerdere Platform Prijsverschillen, AI Tokens Kunnen SEC Onderzoek Ondergaan</h2><p>Onlangs is het trending project SEI een veelbesproken onderwerp geworden op de markt.</p>
<p>Op 16 augustus bereikte SEI’s totale online handelsvolume in de afgelopen 24 uur volgens de gegevens van Coingecko $1,303 miljard, en staat daarmee op de vierde plaats na <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, en <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> (exclusief Stablecoins).</p>
<p>Daarnaast handelt de SEI op Coinbase momenteel op $0,87, een premie van meer dan 300% in vergelijking met andere handelsplatforms. Op het moment van de persverklaring bedroeg het SEI-transactievolume op Coinbase $34,51 miljoen.</p>
<p>Op dit moment is er nog steeds een prijsverschil in multi-platform SEI, houd alstublieft de marktfluctuaties in de gaten.</p>
<p>Op 16 augustus verklaarde SEC-voorzitter Gary Gensler dat hij begonnen was met aandacht te besteden aan kunstmatige intelligentie.</p>
<p>Gensler heeft een reeks tweets gepubliceerd waarin hij stelt dat kunstmatige intelligentie ‘de meest revolutionaire technologie van deze tijd’ is. Maar hij gaf ook aan dat ‘kwaadwillende actoren’ het kunnen gebruiken om invloed uit te oefenen op de kapitaalmarkt. De houding van de SEC ten opzichte van technologie is neutraal en richt zich meer op resultaten dan op de tools. Echter, effectenwetten kunnen worden beïnvloed, afhankelijk van hoe AI-technologie wordt gebruikt. Binnen onze huidige bevoegdheid zal de SEC zich richten op het voorkomen van micro- en macro-uitdagingen van kunstmatige intelligentie.</p>
<p>Na de lancering van ChatGPT in november 2022 maakten veel crypto bedrijven gebruik van de interesse van mensen in kunstmatige intelligentie tools, en blockchain technologie en kunstmatige intelligentie zijn samengevoegd tot een subset genaamd kunstmatige intelligentie (AI) cryptocurrency. De top zes AI tokens op basis van marktkapitalisatie zijn <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a>, Render, Objective, <a href="/price/oasis-network-rose" rel="nofollow noopener noreferrer" target="_blank">Oasis Network</a>, SingularityNET en <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a> De verklaring van Gensler impliceert dat AI-tokens mogelijk dubbele censuurrisico’s lopen.</p>
<p>Gisteren kondigden de Chicago Mercantile Exchange Group (CME Group) en cryptocurrency-referentie-index provider CF Benchmarks aan dat ze op 11 september twee Bitcoin- en Ethereum-referentiekoersen voor de Asia Pacific-regio zullen lanceren, namelijk CME CF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Reference Rate APAC (BRRAP) en CME CF Ether Polar Reference Rate APAC (ETHUSD_AP).</p>
<p>Deze twee wisselkoersen zullen een dagelijkse referentiewisselkoers bieden voor de Amerikaanse dollarprijzen van deze twee digitale activa, gepubliceerd om 16.00 uur Hongkong/Singapore tijd.</p>
<p>Het Base-keten is een broedplaats voor fraude geworden. Solidus Labs, een bedrijf dat blockchain-risicobewaking uitvoert, verklaarde dat van half juli tot augustus ontwikkelaars meer dan 500 frauduleuze tokens hebben ingezet op de Layer 2-blockchain BASE van Coinbase, zoals BASEPPE (BPEPE) en Baby Yoda (Yoda). Er zijn ongeveer 300 tokens waarmee hun makers munten onbeperkt kunnen slaan en nog eens 60 tokens die voorkomen dat kopers op beurzen doorverkopen. Deze frauduleuze tokens hebben ongeveer $3,7 miljoen aan handelsvolume gegenereerd op op Base gebaseerde gedecentraliseerde beurzen, waarbij fraudeurs ongeveer $2 miljoen hebben geprofiteerd.</p>
<p>Solidus verklaarde ook dat naast honderden oplichtingsmunten andere ‘frauduleuze hype en handel’ cryptomunten ook het Base-netwerk zijn binnengekomen. De maker van de Meme-token, Bald, promootte het zwaar op Twitter en verhoogde de prijs op LeetSwap, waardoor hij meer dan $5,2 miljoen aan inkomsten verdiende. Solidus herinnerde eraan: ‘De hype rond het Base-netwerk is geen uitzondering, dus wees voorzichtig met de tokens op dat netwerk.’</p>
<h2 id="h2-Belangrijkste20token20trends20van20vandaag869287"><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-BTC848796"><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/1692250848BTC.png" alt=""><br>De algehele bearish signalen zijn duidelijk. Er moeten conservatieve shortposities worden ingenomen op de support van $28,535 en worden aangehouden tot het doel van $26,636. Er kunnen recentelijk aanzienlijk negatieve nieuwsberichten in de markt zijn geweest, en als de prijs deze maand niet boven het niveau van $29,5K herstelt, zou de bullish trend voor het jaar kunnen eindigen.</p>
<h3 id="h3-ETH936525"><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/1692250880ETH.png" alt=""><br>Gisteren werd de conservatieve short-strategie voorgesteld om short-posities in te voeren als de prijs onder $1,815 daalt. Het doel blijft liggen op het lagere niveau van $1,755. Korte termijn winsten kunnen worden behaald door Fibonacci retracement niveaus te gebruiken vanuit de lagere posities, en winsten moeten worden genomen als er een rebound is op het bovenste weerstandsniveau. De verwachting is dat de prijs geleidelijk zal dalen en ondersteuningsniveaus zal testen.</p>
<h3 id="h3-SEI827655"><a name="SEI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEI</h3><p><img src="https://gimg2.gateimg.com/image/article/1692250900SEI.png" alt=""><br>De strategie van gisteren was gepositioneerd net onder de weerstand op $0,1970. Vervolgens begon de opwaartse beweging en bereikte de doelniveaus van $0,2222 en $0,2630. Voor de korte termijn wordt geadviseerd om te kijken en te wachten. Ondersteuningsniveaus bevinden zich op $0,1979, $0,1818 en $0,1668, waarbij aandacht wordt besteed aan het doorbreken van een bodem.</p>
<h2 id="h2-Macro20De20notulen20van20de20Federal20Reservevergadering20hebben20de20neiging20om20havikachtig20te20zijn20en20de20markt20daalt20als20reactie145348"><a name="Macro: De notulen van de Federal Reserve-vergadering hebben de neiging om havikachtig te zijn, en de markt daalt als reactie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De notulen van de Federal Reserve-vergadering hebben de neiging om havikachtig te zijn, en de markt daalt als reactie</h2><p>Om 18:00 uur (UTC) heeft de Federal Reserve de notulen van haar vergadering in juli vrijgegeven. Zoals de naam al doet vermoeden, zijn de notulen een verslag van de vergadering van juli (met belangrijke informatie die tijdens de vergadering is besproken), meestal drie weken na de vergadering vrijgegeven. De marktreactie die werd veroorzaakt door de vrijgave van de notulen van deze vergadering was zelfs intenser dan toen de Federal Reserve haar rentebesluit in juli aankondigde.</p>
<p>Na de publicatie van de notulen van de vergadering stond het belangrijkste 200-daags voortschrijdend gemiddelde van de Amerikaanse dollarkoers. De offshore RMB daalde kortstondig onder de 7.34, de goudprijs daalde onder de $1.900 en de Bitcoin daalde intraday onder de $29.000. Het rendement op Amerikaanse staatsobligaties met een looptijd van twee jaar steeg naar 5,00%, en het rendement op 10-jarige Amerikaanse staatsobligaties sloot op 4,258%, het hoogste sluitingsniveau sinds juni 2008. Tegelijkertijd daalden de drie belangrijkste Amerikaanse aandelenindices opnieuw over de hele linie, waarbij de Dow Jones-index met 0,5% daalde, de S&amp;P 500-index met 0,8% daalde en de Nasdaq-index met 1,1% daalde.</p>
<p>Dit zijn havikachtige notulen (de meest havikachtige sinds januari van dit jaar), en de verwachtingen van de markt voor de renteverlaging van de Federal Reserve volgend jaar zijn verder gedaald. Laten we eens kijken wat deze notulen voornamelijk zeggen tegen. <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Renderen</a> de markt is zo bang.</p>
<p>De meeste functionarissen van de Federal Reserve geloven dat inflatie een ‘aanzienlijk’ opwaarts risico loopt, wat hen ertoe kan aanzetten om dit jaar opnieuw de rente te verhogen (‘inflatie risico’ is een sleutelwoord geworden in de notulen van de vergadering). Deze risico’s omvatten sterkere economische groei en een omkering van recente verbeteringen in de toeleveringsketen of dalingen van grondstoffenprijzen, die voornamelijk hebben geholpen om de inflatie te vertragen.</p>
<ol>
<li><p>Onderzoekers binnen de Federal Reserve hebben hun voorspellingen van een economische recessie ingetrokken en voorspellen een lichte stijging van de werkloosheid (wat betekent dat de Federal Reserve nog steeds de voorwaarden heeft om de rente te verhogen).</p>
</li><li><p>Functionarissen geloven dat het beleid achterloopt en hoge onzekerheid met zich meebrengt (het is onduidelijk in hoeverre de huidige cumulatieve renteverhogingen de toekomstige inflatie zullen verminderen).</p>
</li><li><p>De notulen van de vergadering tonen aan dat interne verdeeldheid binnen de Federal Reserve is toegenomen, waardoor onzekerheid over het beleidsvooruitzicht is verergerd (wat doorgaans marktvolatiliteit veroorzaakt). Hoewel de beslissing om de rente in juli met 25 basispunten te verhogen unaniem werd goedgekeurd door 11 stemgerechtigde leden, ondersteunden twee van de zeven niet-stemgerechtigde leden dit jaar handhaving van de rentetarieven, en de solide consensus binnen de Federal Reserve begon te ontrafelen. Uit recente toespraken van functionarissen van de Federal Reserve zou het duidelijk moeten zijn dat één ambtenaar zojuist zijn steun heeft uitgesproken voor verdere renteverhogingen. Toch werden voordat de woorden konden worden gehoord, door een andere functionaris geen verdere renteverhogingen ondersteund.</p>
</li></ol>
<p>De wereldwijde markt is in een patroon van alles wat daalt terechtgekomen, met A-aandelen die overdag dalen en Amerikaanse aandelen die ‘s nachts blijven dalen. De VS leidde de cryptomarkt om door te blijven dalen alsof het een neerwaartse spiraal ingaat. De belangrijkste onzekerheid op de huidige markt komt nog steeds voort uit de opvattingen van de Federal Reserve over inflatie en de verwachtingen voor toekomstige renteverlagingen. Deze onzekerheden zullen leiden tot de vroege verwerking van de markt, daarom is de huidige markttrend ontstaan.</p>
<p>Nick Timiraos, een Wall Street Journal journalist die bekend staat als de ‘spreekbuis van de Federal Reserve’, schreef dat de meeste Fed-functionarissen vorige maand steun verlenen aan het verhogen van de rente. Toch geloven sommigen dat het risico van overmatige renteverhogingen toeneemt, waarbij de groeiende voorzichtigheid van functionarissen ten aanzien van verdere renteverhogingen wordt benadrukt.</p>
<p>Volgens de gegevens van CME’s ‘Federal Reserve Observation’ verwacht de markt een waarschijnlijkheid van 87,5% dat de Federal Reserve de rentetarieven ongewijzigd zal handhaven op 5,25% -5,50% in september, en een waarschijnlijkheid van 12,5% voor een renteverhoging van 25 basispunten naar het bereik van 5,50% -5,75%.</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 is toegestaan om het artikel te herpubliceren mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>