RGFnZWxpamtzIG5pZXV3cyB8IE1hcmt0IGlzIHZhbmRhYWcgZ2VkYWFsZDsgRVUgQW50aS13aXR3YXN3ZXRnZXZpbmcgc3RlbHQgZWlzZW4gYWFuIGRlIGNyeXB0b21hcmt0OyBTdGFya25ldCBGb3VuZGF0aW9uIGhlZWZ0IFNUUksgQWlyZHJvcHMgb3BuaWV1dyB1aXRnZWdldmVu

2024-04-25, 04:30

<p><img src="https://gimg2.gateimg.com/image/article/171401934325.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20EU20Antiwitwasrichtlijn20legt20eisen20op20aan20de20cryptomarkt20Starknet20Foundation20geeft20STRK20airdrops20opnieuw20uit20Het20nieuwe20Amerikaanse20wetsvoorstel20kan20de20invloed20van20stablecoins20verzwakken482243"><a name="Crypto Dagelijkse Samenvatting: De EU Antiwitwasrichtlijn legt eisen op aan de cryptomarkt; Starknet Foundation geeft STRK airdrops opnieuw uit; Het nieuwe Amerikaanse wetsvoorstel kan de invloed van stablecoins verzwakken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De EU Antiwitwasrichtlijn legt eisen op aan de cryptomarkt; Starknet Foundation geeft STRK airdrops opnieuw uit; Het nieuwe Amerikaanse wetsvoorstel kan de invloed van stablecoins verzwakken</h2><p>Laten we eerst de handelsactiviteit van onderzoeken. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens Farside Investor-gegevens gingen op 24 april de fondsen van Grayscale Bitcoin-spot-ETF (GBTC) door met <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> aanzienlijk gestegen tot 130,4 miljoen Amerikaanse dollars. Ondertussen bedroeg de instroom van Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) 5,6 miljoen dollar, en de instroom van ARK 21 Shares Bitcoin spot ETF (ARKB) bedroeg 4,2 miljoen dollar.</p>
<p>Het Europees Parlement heeft een nieuwe verordening aangenomen waarin crypto-bedrijven worden verplicht om due diligence uit te voeren om witwaspraktijken tegen te gaan. Deze wet vereist dat crypto-activabeheerbedrijven klantidentiteitscontroles versterken en verdachte activiteiten melden aan autoriteiten. Deze maatregel heeft gevolgen voor crypto-dienstverleners, waaronder gecentraliseerde crypto-uitwisselingen en sommige gokdiensten.</p>
<p>Zoals eerder gemeld, zal de nieuwe wet van invloed zijn <a href="/price/optimism-op" target="_blank" class="blog_inner_link">op crypto</a> serviceproviders (CASPs), zoals gecentraliseerde crypto-uitwisselingen, en vele andere instellingen, waaronder gokdiensten.</p>
<p>Patrick Hansen, EU-directeur strategie en beleid van Circle, verklaarde dat de stemming werd verwacht en dat het pakketplan over drie jaar officieel zal worden goedgekeurd door de Europese Raad en zal worden uitgevoerd.</p>
<p>De Starknet Foundation heeft aangekondigd in een artikel dat is gepubliceerd op het X-platform dat ze STRK-luchtdruppels opnieuw zullen uitvoeren voor drie soorten gebruikers. Het omvat specifiek:<br>Collectieve stakers: In eerste instantie was het plan van de Starknet Foundation om STRK te verspreiden naar in aanmerking komende collectieve stakers via het stakingprotocol dat door gebruikers wordt gebruikt. Hoewel veel stakingprotocollen deze taak niet kunnen voltooien, omvatten de momenteel ondersteunde overeenkomsten of entiteiten Lido, <a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Rocket Pool</a>, etc.</p>
<p>StarkEx-gebruikers die ten onrechte werden geïdentificeerd als VeVeVe-gebruikers (ten onrechte geïdentificeerd als gebruikers van een spel genaamd ‘VeVeVe’ dat draait op het Immutable-platform): Immutable-gebruikers die in de update-lijst ontvangen door de stichting van Immutable worden geïdentificeerd als niet-VeVeVe-gebruikers, zullen vanaf vandaag in staat zijn om STRK te claimen via het portaal.</p>
<p>Gebruikers van VeVeVe: De stichting voert voortdurende besprekingen met VeVeVe over tokenallocatie om te bepalen hoe STRK toegewezen moet worden.</p>
<p>Als hoeksteen van de cryptomarkt hebben stablecoins zoals USDT altijd veel aandacht gekregen. Onlangs hebben de Amerikaanse senatoren Cynthia Lumis en Kirsten Gillibrand een nieuw wetsvoorstel voor stablecoins voorgesteld om de werking ervan in de Verenigde Staten te reguleren, wat mogelijk invloed kan hebben op hun status.</p>
<p>Gegevens tonen aan dat <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>(USDT) heeft een marktwaarde van $110 miljard, waardoor het de op twee na grootste cryptocurrency is, terwijl USDC van Circle op de tweede plaats staat met een marktwaarde van $34 miljard. Beide stablecoins zijn gekoppeld aan de Amerikaanse dollar.</p>
<p>Standard &amp; Poor’s Global Ratings wees in een rapport op woensdag erop dat de duidelijkheid van het Amerikaanse regelgevingskader traditionele financiële instellingen kan aanmoedigen om de markt voor stablecoins te betreden en mogelijk de dominante positie van <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> (USDT) op de markt te verzwakken.</p>
<p>Het rapport vermeldt dat niet-Amerikaanse entiteiten USDT uitgeven en daarom geen betalingsstabiele munt zijn die is toegestaan ​​door het voorgestelde wetsvoorstel. Dit betekent dat Amerikaanse entiteiten geen USDT kunnen aanhouden of verhandelen, wat de vraag naar USDT’s kan verminderen en de uitgifte van stabiele munten in de Verenigde Staten kan stimuleren. De handelsactiviteiten van USDT bevinden zich voornamelijk in opkomende markten buiten de Verenigde Staten en worden gedreven door particuliere beleggers en geldovermakingen. Met de introductie van het genoemde wetsvoorstel kan de situatie van stabiele munten veranderen.</p>
<p>Analist Andrew O’Neill wees erop: ‘De nieuwe regelgeving kan instellingen zonder bankvergunning beperken in het uitgeven van maximaal $10 miljard aan stablecoins, waardoor banken een concurrentievoordeel krijgen’.</p>
<h2 id="h2-Markttrends20De20markt20daalt20over20het20algemeen20en20Meta20staat20na20de20handelsuren201820lager126976"><a name="Markttrends: De markt daalt over het algemeen en Meta staat na de handelsuren 18% lager" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt daalt over het algemeen en Meta staat na de handelsuren 18% lager</h2><p>Na twee dagen van volatiliteit is de crypto-markt gedaald, waarbij BTC onder de $64.000 is gezakt en valse munten over het algemeen zijn gedaald. Met betrekking tot macro-economie vertoonde de Amerikaanse aandelenmarkt ook volatiliteit, vooral nadat Meta zijn financiële rapport voor het eerste kwartaal had vrijgegeven. Vanwege een aanzienlijke toename van de AI-uitgaven daalde de aandelenkoers met 18% in de handel na de markt.</p>
<h3 id="h3-Markt20Hotspots434718"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>De fanmuntensector heeft uitstekend gepresteerd: fanmunten zoals PORTO en LAZIO hebben het goed gedaan te midden van een algemene marktdaling, mede door de enthousiaste deelname aan het Europees Kampioenschap. Fan tokens presteren doorgaans goed tijdens grote sportevenementen omdat deze evenementen de aandacht en handelsactiviteiten van gerelateerde tokens vergroten.</p>
<p>Vorderingen op het gebied van AI+DePin: io.net kondigt aan dat het zijn gebruikers zal airdroppen, en Whales voorspelt dat zijn on-chain gecentraliseerde voorspellingsmarkt een marktwaarde van maximaal $4 miljard zal hebben. In vergelijking met RNDR in hetzelfde vakgebied (met een marktwaarde van $5 miljard), toont dit het hoge groeipotentieel en de interesse van investeerders aan.</p>
<p>Nieuwe ontwikkelingen in de rune sector: De prijs van DOG tokens in de rune sector is gestegen als gevolg van Rune Stone airdrops naar houders, met een marktwaarde van $350 miljoen en een handelsvolume van meer dan 100 BTC op korte termijn. Dergelijke activiteiten stimuleren meestal de handelsenthusiasme op de markt en prijsschommelingen.</p>
<p>De tegenstroomopkomst van <a href="/price/eos-eos" rel="nofollow noopener noreferrer" target="_blank">EOS</a>: Beïnvloed door de aankondiging van nieuwe token-economiebeleid door de <a href="/price/eos-eos" target="_blank" class="blog_inner_link">EOS</a> Network Foundation, steeg de EOS-prijs met 15% tegen de trend in. Het nieuwe beleid omvat maatregelen zoals het vernietigen van 80% van de toekomstige totale aanbod, het sluiten van inflatie, het instellen van een aanbodplafond van 2,1 miljard tokens, een halveringscyclus van 4 jaar en het slaan van ongeveer 950 miljoen EOS. Deze maatregelen zijn bedoeld om de schaarste en waarde van EOS te verbeteren.</p>
<p>Hoewel de algehele markt een neerwaartse trend laat zien, hebben sommige specifieke sectoren en tokens, zoals fanmunten, AI+DePin-concepten en rune sectoren, relatief sterke prestaties laten zien. Het nieuwe nieuws van EOS heeft ook significante prijsstijgingen met zich meegebracht. Investeerders moeten blijven letten op macro-economische veranderingen, bedrijfsfinanciële verslagen en de ontwikkelingsdynamiek binnen elke sector om markttrends beter te begrijpen en overeenkomstige investeringsbeslissingen te nemen. Ondertussen suggereert de markt onzekerheid dat investeerders risico’s passend moeten beheren.</p>
<h2 id="h2-Macro20De20daling20van20de20technologische20aandelen20brengt20druk20op20de20markt20De20Japanse20yen20is20gedaald20naar20een2034jarig20dieptepunt20wat20discussies20heeft20doen20oplaaien20over20de20richting20van20overheidsingrijpen97115"><a name="Macro: De daling van de technologische aandelen brengt druk op de markt; De Japanse yen is gedaald naar een 34-jarig dieptepunt, wat discussies heeft doen oplaaien over de richting van overheidsingrijpen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De daling van de technologische aandelen brengt druk op de markt; De Japanse yen is gedaald naar een 34-jarig dieptepunt, wat discussies heeft doen oplaaien over de richting van overheidsingrijpen</h2><p>Op donderdag vertoonde de Amerikaanse aandelenmarkt verschillende trends, waarbij de S&amp;P 500 index licht steeg, steeg de S&amp;P 500 index met 0,02% tot 5.071,63 punten en steeg de Nasdaq Composite Index met 0,10% tot 15.712,75. De Dow Jones Industrial Average daalde met 0,11% tot 38.460,92 punten.</p>
<p>Van de 11 sectoren in de S&amp;P 500 index, zijn 7 sectoren gestegen, waarbij consumentengoederen, nutsbedrijven, niet-essentiële consumentengoederen en vastgoedaandelen voorop lopen.</p>
<p>Het in Londen genoteerde mijnbouwbedrijf Anglo American heeft donderdag aangekondigd dat ze een volledig overnamevoorstel voor aandelen hebben ontvangen van BHP.AX. Als deze deal wordt bereikt, betekent dit dat ‘s werelds grootste genoteerde mijnbouwbedrijf ook ‘s werelds grootste koperproducent zal worden.</p>
<p>Het voltooien van deze transactie zal ook verdere M&amp;A-activiteiten in de wereldwijde mijnbouwindustrie in gang zetten. Aangezien het bedrijf zijn activa aan het herzien is om de blootstelling aan metalen die cruciaal worden geacht voor de energietransitie te vergroten, is er een aanzienlijke hoeveelheid M&amp;A-activiteit in de industrie geweest.</p>
<p>In een week van rijke financiële verslagen zijn bedrijven in de technologiesector het middelpunt van de aandacht op de markt geworden. Echter, de financiële verslagen van verschillende topbedrijven zijn niet optimistisch. De aandelenkoers van Meta (META.O) daalde met 15%, en het moederbedrijf van Instagram voorspelde lagere dan verwachte inkomsten en hogere kosten voor het kwartaal, wat leidde tot een verslechtering van het marktsentiment en een verkoopgolf in Amerikaanse technologieaandelen en technologiegerelateerde aandelen. Alphabet, Microsoft en Intel zullen later op donderdag rapporteren.</p>
<p>Naast de bedrijfswinsten zullen investeerders ook letten op de Amerikaanse Q1 BBP-gegevens die donderdag worden vrijgegeven en de persoonlijke consumptie-uitgavengegevens van maart die vrijdag worden vrijgegeven. De markt verwacht een kans van 70% op een renteverlaging in september.</p>
<p>De daling van de technologiesector heeft ook invloed gehad op Aziatische aandelenmarkten. De MSCI Asia Pacific aandelenindex, de meest gebruikte buiten Japan, daalde met 0,7%. De Japanse Nikkei-index daalde met 1,3%, de Chinese aandelenmarkt daalde ook, blue chip-aandelen zoals de CSI 300 Index daalden met 0,3% en de Hong Kong Hang Seng-index (. HSI) daalde met 0,5%.</p>
<p>De wisselkoers van de Japanse yen ten opzichte van de Amerikaanse dollar is voor het eerst sinds 1990 onder de $155 gezakt, wat zorgen baart over de interventie van Tokio. Tijdens een seminarie in Washington vorige week verklaarde Kazuo Ueda, gouverneur van de Bank of Japan, dat ongeacht de economische situatie, de Bank of Japan uiteindelijk zal beginnen met het verkleinen van haar balans en dit proces zal introduceren. Ueda benadrukte echter dat de Bank of Japan voorlopig niet significant het tempo van obligatieaankopen zal wijzigen, noch de omvang van de activa-aankoop zal gebruiken als een monetair beleidsinstrument.</p>
<p>Met betrekking tot grondstoffen zijn de olieprijzen licht gedaald vanwege zorgen over een mogelijke vertraging van de Amerikaanse economie, waarbij de zorgen over het risico van escalerende conflicten in het Midden-Oosten worden overtroffen. Amerikaanse ruwe olie daalde naar $ 82,74 per vat, terwijl Brent ruwe olie daalde naar $ 87,99 per vat.</p>
<p>Spot goud steeg naar $2,320.32 per ounce.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>