RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBIaWdoIEhvcml6b250YWwsIE1lbWUgZW4gQUkgemlqbiBzdGVyazsgSHVpcyB2YW4gQWZnZXZhYXJkaWdkZW4ga2V1cmRlIGRlIENyeXB0byBNYXJrZXQgU3RydWN0dXJlIEFjdCBnb2VkOyAnQ2VudHJhbGlzYXRpZXpvcmdlbicgbGVpZGRlbiB0b3QgZWVuIGRhbGluZyB2YW4gMzAlIGluIEFEQQ=

2024-05-23, 03:18

<p><img src="https://gimg2.gateimg.com/image/article/17164341871_15.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Het20Amerikaanse20Huis20van20Afgevaardigden20heeft20de20Crypto20Market20Structure20Act20goedgekeurd20Taiko20heeft20de20lancering20van20de20TKO20luchtdruppel20kwalificatie20vraag20pagina20aangekondigd20Cardanos20centralisatie20zorgen20leidden20tot20een20daling20van203020in20ADA20prijzen885031"><a name="Crypto Dagelijkse Samenvatting: Het Amerikaanse Huis van Afgevaardigden heeft de Crypto Market Structure Act goedgekeurd; Taiko heeft de lancering van de TKO luchtdruppel kwalificatie vraag pagina aangekondigd; Cardano’s “centralisatie zorgen” leidden tot een daling van 30% in ADA prijzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Het Amerikaanse Huis van Afgevaardigden heeft de <a href="/price" target="_blank" class="blog_inner_link">Crypto Market</a> Structure Act goedgekeurd; Taiko heeft de lancering van de TKO luchtdruppel kwalificatie vraag pagina aangekondigd; Cardano’s “centralisatie zorgen” leidden tot een daling van 30% in ADA prijzen</h2><p>Eerst gaan we eens kijken naar de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens Farside Investor-gegevens had Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 22 mei een uitstroom van $16,1 miljoen; Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een instroom van $74,6 miljoen, ARK 21Shares Bitcoin spot ETF (ARKB) een instroom van $3,5 miljoen.</p>
<p><strong>Het Amerikaanse Huis van Afgevaardigden heeft de Crypto Markt Structuurwet goedgekeurd.</strong><br>Op woensdag heeft het Amerikaanse Huis van Afgevaardigden met 279 stemmen voor en 136 stemmen tegen de door de Republikeinen geleide 21st Century Financial Innovation and Technology Act (ook bekend als FIT21) aangenomen. De goedkeuring van dit wetsvoorstel markeert de eerste stemming over uitgebreide crypto-wetgeving in het Huis van Afgevaardigden, waarbij 71 Democraten voor het wetsvoorstel stemden, waaronder voormalig voorzitter van het Huis van Californië Nancy Pelosi.</p>
<p>FIT21 heeft tot doel de hele crypto-industrie te reguleren en de Commodity Futures Trading Committee meer macht en financiering te geven om toezicht te houden op de crypto-spotmarkt en ‘digitale goederen’, met name Bitcoin. Het wetsvoorstel creëert ook een proces dat secundaire markthandel van digitale goederen mogelijk maakt die aanvankelijk zijn aangeboden als onderdeel van investeringscontracten. Daarnaast bevat het wetsvoorstel ook bepalingen met betrekking tot stablecoin en antiwitwaspraktijken. Hoewel het onwaarschijnlijk is dat FIT21 dit jaar in de Senaat wordt geïntroduceerd, kan het wetsvoorstel de basis leggen voor het volgende congres in januari volgend jaar.</p>
<p>Ron Hammond, directeur Government Relations bij de Blockchain Association, zei dat het standpunt van het Congres ten aanzien van cryptocurrencies aan het veranderen is. Hij gelooft dat FIT21 een ‘enorm keerpunt’ is. Hij zegt: ‘De connectie tussen crypto stemmers en de aankomende verkiezingen is onmiskenbaar, en de regering-Biden lijkt eindelijk te beseffen wat de potentiële gevolgen zijn van het handhaven van de status quo.’</p>
<p>Vóór de FIT21-stemming keurden de Senaat en het Huis van Afgevaardigden een maatregel goed om de werknemersverklaring van de Securities and Exchange Commission in te trekken, waarin bepaalde boekhoudnormen werden vastgesteld voor bedrijven die cryptocurrencies hosten. De resolutie heeft steun gekregen van sommige Democraten, waaronder de meerderheidsleider van de Senaat en de Democraat van de staat New York, Chuck Schumer. Het Witte Huis verklaarde echter dat president Joe Biden een veto zou uitspreken over het wetsvoorstel. Op woensdag verzette het Witte Huis zich tegen FIT21, maar “stond te popelen om met het Congres samen te werken” om een regelgevend kader voor digitale activa te ontwikkelen.</p>
<p><strong>Taiko kondigde de lancering aan van de TKO airdrop-kwalificatie-querypagina</strong><br>Taiko, een <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het L2-netwerk gebaseerd op zkRollup heeft vanochtend vroeg de lancering van de eerste fase van de TKO-luchtdrop op het X-platform aangekondigd en de pagina voor de luchtdrop-kwalificatie gelanceerd. In de eerste fase zal 5% van de initiële tokenvoorraad worden verstrekt en hebben gebruikers zeven dagen om hun kwalificaties te controleren. Na voltooiing van de controle wordt het verzamelingsvenster geopend en hebben in aanmerking komende gebruikers een maand om TKO te verzamelen.</p>
<p>De TKO-luchtdruppeltoepassing is nog niet gelanceerd. Raadpleeg de officiële release-informatie voor deelname aan de toepassing en wees voorzichtig met eventuele gerelateerde oplichting. Volgens het TKO-token-economische model is de totale voorraad 1 miljard munten. De specifieke toewijzing omvat:</p>
<p>DAO Teary accounts for 20%; Trailblazer airdrops account for 10%; The highest proportion of Genesis airdrops is 5%; Liquidity and market makers account for 5%; Investors account for 11.62%; Taiko Labs/core team accounts for 20%; Taiko Foundation reserves account for 16.88%; Taiko’s official Prover Bonds account for 1.5%, and so on.</p>
<p><strong><a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a>‘s ‘centralisatiezorgen’ leidden tot een daling van 30% in ADA-prijzen</strong><br>De prijs van ADA is gedaald nadat analisten de centralisatie van het Cardano-netwerk in twijfel trokken. Crypto-analist Justin Bons verklaarde dat het moederbedrijf van Caldano, Input Output Global (IOG), 5 van de 7 ‘Genesis keys’ op de blockchain controleert, die al in 2015 werden gebruikt om de initiële blokken van de Caldano blockchain te ondertekenen en vast te stellen.</p>
<p>De analist merkte op dat “Genesis Key zorgt voor naadloze codeveranderingen zonder harde vorken.” Hij voegde eraan toe: “Dit betekent dat IOG de keten kan stoppen, emissieschema’s kan wijzigen, beoordelingen kan uitvoeren, enzovoort, wat een ongekend niveau van gecentraliseerde controle over de L1-keten is.”</p>
<p>Vanaf 22 mei begon de prijs van ADA te dalen na het testen van de opwaartse trendlijn van de driehoek. Op dit moment zal de prijs blijven dalen naar de neerwaartse trendlijn van ongeveer $0,44, een daling van 6,5% vanaf het huidige prijsniveau. Tijdens deze periode van prijsaanpassing nam de voorraad ADA die werd vastgehouden op het adres van de gigantische walvis licht toe, wat erop wijst dat hij geen aandacht besteedde aan de waarschuwing van Boggs over de zogenaamde centralisatie van Caldano.</p>
<h2 id="h2-Markttrends20Korte20termijn20winstneming20op20de20markt20maar20de20langetermijntrend20blijft20onveranderd20positief674753"><a name="Markttrends: Korte termijn winstneming op de markt, maar de langetermijntrend blijft onveranderd positief" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Korte termijn winstneming op de markt, maar de langetermijntrend blijft onveranderd positief</h2><p>BTC: Bitcoin handelt zijwaarts op een hoog niveau en zakt tijdelijk onder de $70.000, mogelijk als gevolg van winstneming op korte termijn op de markt. Desalniettemin blijft de langetermijntrend van Bitcoin bullish, vooral in het licht van toenemende wereldwijde economische onzekerheid.</p>
<p>ETH spot ETF: Analisten van Bloomberg voorspellen dat de omvang ervan misschien slechts 10% van de BTC spot ETF zal bereiken. Deze voorspelling weerspiegelt een zwak marktvertrouwen in Ethereum, maar het kan ook een conservatieve schatting zijn. Zodra ETH spot ETF’s zijn goedgekeurd, kan de marktvraag aanzienlijk toenemen.</p>
<h3 id="h3-Macroeconomie252894"><a name="Macro-economie:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro-economie:</h3><p>Correctie van de Amerikaanse aandelenmarkt: de notulen van de Federal Reserve suggereren dat rentetarieven niet snel zullen worden verlaagd, wat een nadelige factor is voor de aandelenmarkt. De prestaties van technologie-leider Nvidia overtroffen echter de verwachtingen en bereikten historische hoogtepunten, wat aangeeft dat technologieaandelen mogelijk een lichtpuntje in de markt blijven.</p>
<p>Crypto-markt: Een terugval op de Amerikaanse aandelenmarkt kan op korte termijn druk uitoefenen op de cryptomarkt, maar op de lange termijn kunnen fondsen <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> in hoog risicovolle activa zoals cryptocurrencies op zoek naar hogere rendementen.</p>
<h3 id="h3-Markt20Hotspots734184"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>Meme concept munten:</strong><br>PEOPLE, MAGA, WIF, BOME, MANEKI: PEOPLE en MAGA hebben een sterke prestatie laten zien, gedreven door het concept van de Amerikaanse verkiezingen. De Meme over <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Het gezicht van Gate.io presteerde ook goed, vooral MANEKI, dat meer dan 30% herstelde van een lager punt. Met beide Amerikaanse presidentskandidaten die vriendelijk zijn voor Meme, kunnen deze Meme-munten blijven rekenen op marktaandacht.</p>
<p>Beleggingsstrategie: Op korte termijn kan aandacht worden besteed aan de volatiliteit van deze valuta’s, wat geschikt is voor beleggers met een hoog risicoprofiel. Op de lange termijn is het nodig om  te zijn op veranderingen in het marktsentiment.</p>
<p><strong>Andere populaire munten:</strong><br>EDU: Animoca Brands, de belangrijkste aandeelhouder, is van plan om eigen aandelen terug te kopen, wat rechtstreeks ten goede komt aan de valutaprijs. Het kan op korte termijn blijven stijgen.</p>
<p>BNX: Als een sterproject van het GameFi-concept is de stijging in deze ronde bijna 10 keer. Het moet worden opgemerkt dat zo’n grote stijging winstneming kan veroorzaken.</p>
<p>HOOK: Het wordt aanbevolen om aandacht te besteden aan de verdere ontwikkeling ervan en veranderingen in het marktsentiment.</p>
<p><strong>Layer2-netwerk Taiko:</strong><br>Aangekondigd de airdrop van 5% tokens, voornamelijk voor Taiko gebruikers en de LRC gemeenschap. Airdrop nieuws brengt meestal kortetermijn markthitte met zich mee, maar het is noodzakelijk om aandacht te besteden aan de marktreactie na de airdrop.</p>
<p><strong>AI-conceptmunten:</strong><br>LPT steeg sterk, maar andere AI-conceptvaluta’s wonnen niet significant. Dit kan te wijten zijn aan de sterke marktreactie op specifiek positief nieuws over LPT. Suggestie om aandacht te besteden aan de algehele ontwikkelingstrend van AI-concepten en te ueren of er andere groeikansen zijn.</p>
<p>De huidige markt zit vol met kansen, maar brengt ook risico’s met zich mee. Beleggers moeten flexibele aanpassingen maken op basis van hun risicotolerantie en marktdynamiek. Voor beleggers met een hoog risico wordt aanbevolen om zich te richten op Meme coins en GameFi concept coins, terwijl voor conservatieve beleggers wordt aanbevolen om een oogje te houden op langetermijnbeleggingskansen in BTC en ETH.</p>
<h2 id="h2-Macro20Notulen20van20de20Federal20Reservevergadering20vrijgegeven20algemene20daling20van20de20aandelenmarkt20Technologiebedrijven20vertegenwoordigd20door20NVIDIA20presteren20nog20steeds20goed397510"><a name="Macro: Notulen van de Federal Reserve-vergadering vrijgegeven, algemene daling van de aandelenmarkt; Technologiebedrijven vertegenwoordigd door NVIDIA presteren nog steeds goed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Notulen van de Federal Reserve-vergadering vrijgegeven, algemene daling van de aandelenmarkt; Technologiebedrijven vertegenwoordigd door NVIDIA presteren nog steeds goed</h2><p>Op 22 mei meldde Reuters dat de Amerikaanse aandelenmarkt woensdag lager sloot omdat beleggers de notulen van de recentste vergadering van de Federal Reserve verwerkten. Het in de halfgeleiderindustrie leidende NVIDIA presteerde opvallend goed en overtrof de verwachtingen, waarbij de aandelenkoers van het bedrijf met ongeveer 6% steeg na sluitingstijd. Dit nieuws heeft ook gezorgd voor stijgingen in de aandelenkoersen van andere chipfabrikanten.</p>
<p>Nadat het in 2023 bijna 240% gestegen was, is de aandelenkoers van Nvidia dit jaar met ongeveer 90% gestegen. Beleggers letten erop of de prestaties van Nvidia in het eerste kwartaal kunnen voldoen aan zeer hoge verwachtingen, en of de aanzienlijke stijging van aandelen die verband houden met kunstmatige intelligentie kan worden volgehouden.</p>
<p>Daling index: de Dow Jones-index daalde met 0,51%, de Standard &amp; Poor’s-index daalde met 0,27% en de Nasdaq-index daalde met 0,18%.</p>
<p>Volgens analisten die door Reuters zijn ondervraagd, zou de slotkoers van de S&amp;P 500-index dit jaar dicht bij het huidige niveau van 5302 punten kunnen liggen, maar ze waarschuwen dat de sterke prestatie van de index betekent dat er in de toekomst aanpassingen kunnen komen. Een deel van de reden waarom de aandelenmarkt deze maand naar een historisch hoogtepunt steeg, is te wijten aan het optimistische sentiment van kunstmatige intelligentie, een robuust financieel rapportageseizoen, en de hernieuwde hoop op een rentedaling door de Federal Reserve dit jaar.</p>
<p>Volgens de FedWatch-tool van CME verwacht de markt een kans van 59% dat de Federal Reserve de rente met ten minste 25 basispunten zal verlagen tijdens de vergadering in september, lager dan de 65,7% die de vorige handelsdag werd gezien.</p>
<p>Op de Aziatische markt sloten op 23 mei verschillende belangrijke aandelenmarktindices in Azië lager op donderdag, terwijl de markt de impact van beleidsmakers in grote economieën verwerkte die geneigd zijn om geduldige monetaire versoepelingsbeleid aan te nemen te midden van aanhoudende hoge inflatie.</p>
<p>De notulen van de laatste beleidsvergadering van de Federal Reserve zijn meer havikachtig geweest dan verwacht, met veel aandacht voor het Britse inflatierapport. De Bank van Nieuw-Zeeland is rustig gebleven over de inflatieproblemen in Nieuw-Zeeland, waardoor investeerders hun inzet op de snelheid en omvang van wereldwijde renteverlagingen hebben verminderd.</p>
<p>De MSCI Asia Pacific Stock Index daalde met 0,57%. De Australische S&amp;P/ASX 200 werd beïnvloed door de daling van sommige grondstofprijzen en behoorde tot de aandelen met de grootste daling, namelijk een daling van 0,8%. Na eerder deze week een hoogtepunt van meer dan negen maanden te hebben bereikt, nam de Hang Seng Index in Hong Kong winstnemingen en daalde met 1,5%. De Chinese blue-chip index is met 0,3% gedaald.</p>
<p>De Japanse Nikkei-index bereikte het laagste niveau in meer dan drie weken, waarbij de yen met 0,6% steeg. De laatste wisselkoers tussen de Japanse yen en de Amerikaanse dollar is 156,85.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen gedaald, waarbij Brent ruwe olie met 0,82% is gedaald tot $81,23 per vat en Amerikaanse ruwe olie lichtjes met 0,9% is gedaald tot $76,87 per vat.</p>
<p>De goudprijs daalde met 0,25% tot $2.372,28 per ounce, ver verwijderd van het historische hoogtepunt van $2.449,89 dat op maandag werd bereikt, aangezien het vooruitzicht van renteverhogingen op lange termijn in de Verenigde Staten een deel van de glans van goud heeft aangetast.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S. &amp; Icing</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 op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>