RGFnZWxpamtzIE5pZXV3cyB8IEJUQyBlbiBFVEggZ2VkYWFsZCwgQ3J5cHRvbWFya3QgbWFha3RlIGVlbiB0ZXJ1Z3RyZWtraW5nIG1lZTsgVGV0aGVyIGxhbmNlZXJkZSBlZW4gbmlldXdlIHRva2VuIGdlZGVrdCBkb29yIGdvdWQ7IERlIGluaXRpw6tsZSBtYXJrdGthcGl0YWxpc2F0aWUgdmFuIFpLc3luYyBBaXJkcm9wIGlzIGJpam5

2024-06-18, 03:36

<p><img src="https://gimg2.gateimg.com/image/article/17186816491_13.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Tether20lanceerde20nieuwe20tokens20gesteund20door20goud20De20nieuwe20ZuidKoreaanse20wet20vereist20dat20beurzen20regelmatig20tokenlijsten20beoordelen20De20initile20marktkapitalisatie20van20de20ZKsync20airdrop20nadert2080020miljoen826536"><a name="Crypto Dagelijkse Samenvatting: Tether lanceerde nieuwe tokens gesteund door goud; De nieuwe Zuid-Koreaanse wet vereist dat beurzen regelmatig tokenlijsten beoordelen; De initiële marktkapitalisatie van de ZKsync airdrop nadert $800 miljoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> lanceerde nieuwe tokens gesteund door goud; De nieuwe Zuid-Koreaanse wet vereist dat beurzen regelmatig tokenlijsten beoordelen; De initiële marktkapitalisatie van de ZKsync airdrop nadert $800 miljoen</h2><p>Laten we eerst de handelsactiviteiten van onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETFs. Volgens gegevens van Farside Investor had Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETFs (GBTC) op 17 juni een uitstroom van $3 miljoen. Ondertussen had Fidelity Bitcoin spot ETF (FBTC) uitstroom van $9200, Bitwise Bitcoin spot ETF (BITB) instroom van $2.9 miljoen, en ARK 21Shares Bitcoin spot ETF (ARKB) uitstroom van $50 miljoen.</p>
<p><strong><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> heeft een nieuwe token gelanceerd die wordt ondersteund door Zwitsers goud in opslag, waarmee de synthese van cryptocurrencies wordt uitgebreid</strong><br>Tether, ‘s werelds grootste leverancier van stablecoins voor de Amerikaanse dollar, heeft de lancering aangekondigd van een nieuwe crypto genaamd ‘gepegde activa’. Volgens een maandag vrijgegeven verklaring zal het bedrijf een nieuwe token lanceren die wordt ondersteund door echt fysiek goud dat in Zwitserland is opgeslagen, om een reeks digitale activa uit te brengen.</p>
<p>De eerste aankomende token heet ‘Alloy by Tether’, afgekort als aUSDT. Tether CEO Paolo Ardoino zei op het X-platform: ‘Alloy van Tether is een open platform dat gebruikers in staat stelt om onderpand gedekte digitale activa te creëren en zal binnenkort deel uitmaken van Tether’s nieuwe platform voor tokenisatie van digitale activa dat naar verwachting later dit jaar zal worden gelanceerd.’</p>
<p>Tether beschrijft een USDT als een crypto ‘ontworpen om de waarde van één dollar te volgen’, maar ‘over-gecollateraliseerd door’. <a href="/price/tether-gold-xaut" rel="nofollow noopener noreferrer" target="_blank">Tether Gold</a>(XAUT),” benadrukkend dat de token gedekt wordt door daadwerkelijk goud. Gebruikers kunnen XAUT gebruiken als onderpand om aUSDT tokens te creëren. Op dit moment is de marktkapitalisatie van XAUT $573 miljoen, ver onder die van USDT.</p>
<p><strong>Nieuwe Zuid-Koreaanse wet vereist dat beurzen regelmatig tokenlijsten controleren</strong><br>Zuid-Korea zal op 19 juli de Virtual Asset User Protection Act implementeren. De Financial Services Commission (FSC) van Korea heeft 29 geregistreerde crypto-beurzen op de hoogte gebracht om regelmatig de tokens die op hun beurzen zijn genoteerd te ueren en te beslissen of ze de handel blijven ondersteunen.</p>
<p>De nieuwe wet vereist dat crypto exchanges voldoen aan strengere criteria voor het beoordelen van token listings en bestaande genoteerde tokens elke zes maanden beoordelen om ervoor te zorgen dat ze voldoen aan de nieuwe richtlijnen. Na de initiële beoordeling moet de exchange elke drie maanden onderhoudsbeoordelingen uitvoeren.</p>
<p>In februari van dit jaar heeft de Zuid-Koreaanse overheid de meest recente herziene versie van de Virtual Asset User Protection Act vrijgegeven. In april gaf de Financial Supervisory Commission van Zuid-Korea aan dat zij strengere reguleringsrichtlijnen zou opstellen voor het noteren van nieuwe tokens op crypto-beurzen. Hierbij worden maatregelen voorgesteld om de marktmonitoring en beveiliging te verbeteren, zoals het verbieden van de notering van tokens voor geïnfecteerde projecten. Deze nieuwe normen kunnen voorkomen dat projecttokens met beveiligingskwetsbaarheden en onopgeloste beveiligingsproblemen worden genoteerd op lokale beurzen.</p>
<p><strong> De initiële marktkapitalisatie van de ZKsync airdrop is bijna $800 miljoen </strong><br>Layer 2 blockchain ZKsync lanceerde een zeer verwachte ZK-token airdrop, waarbij naar verluidt 45% van de tokens binnen slechts twee uur werden geclaimd. Volgens CoinGecko-gegevens was de openingsprijs van ZK-tokens $0,31, gevolgd door een daling van ongeveer 31% en momenteel op $0,198. Volgens het circulerende aanbod bedraagt de marktkapitalisatie ongeveer $800 miljoen, met ongeveer 3,7 miljard tokens beschikbaar voor distributie. Na volledige verwatering bedraagt de marktwaarde $4,5 miljard.</p>
<p>Sommige gebruikers zijn ontevreden over het ontwerp van de airdrop en zijn van mening dat er sprake is van oneerlijke verdeling en dat enkele vermoedelijke heksadressen een grote hoeveelheid tokens ontvangen. Het team erkent het niet-traditionele ontwerp. Vorige week deelde het Matter Labs-team het tokenverdelingsplan van de ZKsync Association.</p>
<p>Volgens het plan zal 89% van de airdrops worden opgeëist door ZKsync-gebruikers, inclusief iedereen die handelt op de ZKsync-blockchain en een ongespecificeerde activiteit drempel bereikt. De overgebleven tokens zullen worden toegewezen aan ecosysteembijdragers, ZKsync native projecten, on-chain gemeenschappen en bouwers.</p>
<p>Matter Labs verklaarde ook dat werknemers 16,1% van de ZK-tokens zullen ontvangen, en investeerders zullen 17,2% ontvangen, die één jaar vergrendeld zullen zijn en binnen drie jaar worden vrijgegeven. De resterende tokenvoorraad zal worden toegewezen aan de tokenconferentie van ZKsync (29,3%) voor nieuwe governance-doeleinden, terwijl het overige deel zal worden gebruikt voor ecosysteemplanning (19,9%).</p>
<h2 id="h2-Markttrends925918"><a name="Markttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends</h2><p>BTC steeg ‘s nachts boven de $66.000 en keerde toen om, viel vanmorgen onder de $65.000.</p>
<p>De ETH-prijs daalde vanmorgen tot onder de $3.400, wat wijst op een bepaalde achteruitgang.</p>
<p>Altcoins zijn over het algemeen met meer dan 10% gedaald, en de trending token ZK met een grote marktkapitalisatie heeft veel geld uit de markt aangetrokken.</p>
<h3 id="h3-Macroeconomie237117"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>Markttrend: Amerikaanse aandelen blijven stijgen naar nieuwe historische hoogtepunten, met fondsen die massaal naar technologische aandelen stromen.</p>
<h3 id="h3-Markt20Hotspots999267"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Layer2-protocol Zksync: ZK is gistermiddag gelanceerd op grote handelsplatforms, met een huidige prijs van 0.2u, aanzienlijk lager dan de over-the-counter prijs van 0.4u. De huidige circulerende marktkapitalisatie van ZK is $740 miljoen. De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> de gasvergoeding is gedaald tot een recordlaagte van 1 gas in 8 jaar, en wanneer de gasvergoeding voor Layer1 niet langer stijgt, wordt het brancheverhaal voor Layer2 niet langer geaccepteerd door de markt.</p>
<p>Meme sector: MEW steeg gedurende de dag met 25% en is nu gedaald. MEW is een Meme-token van het kattentype op Gate.io <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Chain, die onlangs is gelanceerd op het Koreaanse handelsplatform en contracten op BN, met voortdurend positief nieuws. De huidige marktkapitalisatie van MEW is bijna $400 miljoen, waardoor het de hoogst gerangschikte kat-gebaseerde Meme-token is qua marktkapitalisatie.</p>
<p>De cryptomarkt ondergaat een golf van aanpassing van de huidige markttrend. De terugtrekking van BTC en ETH duidt op marktzwakte, en de wijdverbreide daling van Altcoins verscherpt deze trend.</p>
<p>Op macroniveau kan de aanhoudende stijging en het recordhoog presteren van Amerikaanse aandelen van invloed zijn op de economie. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flow</a> van fondsen op de cryptomarkt. Beleggers kunnen enkele fondsen van de cryptomarkt naar de aandelenmarkt overdragen om stabielere rendementen na te streven.</p>
<h2 id="h2-Macro20Voor20de20publicatie20van20de20opmerkingen20van20de20Fed20bereikten20de20SampP2050020en20Nasdaq20nieuwe20hoogtepunten20bij20de20slotkoersen20terwijl20Wall20Street20en20Euraziatische20markten20beide20stegen928505"><a name="Macro: Voor de publicatie van de opmerkingen van de Fed, bereikten de S&amp;P 500 en Nasdaq nieuwe hoogtepunten bij de slotkoersen, terwijl Wall Street en Euraziatische markten beide stegen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Voor de publicatie van de opmerkingen van de Fed, bereikten de S&amp;P 500 en Nasdaq nieuwe hoogtepunten bij de slotkoersen, terwijl Wall Street en Euraziatische markten beide stegen.</h2><p>Op 17 juni, voordat belangrijke economische gegevens en toespraken van functionarissen van de Federal Reserve deze week worden vrijgegeven, bereikten de S&amp;P 500- en Nasdaq-indexen maandag nieuwe slotrecords. De enthousiasme voor kunstmatige intelligentie heeft voornamelijk de stijging van technologische aandelen gestuurd. Onder grote tech-aandelen herstelden Apple en Microsoft zich na een daling in de vroege handelssessie en sloten respectievelijk 1,97% en 1,31% hoger. Na de aankondiging van nieuwe AI-functies is de vraag naar iPhones van Apple opnieuw ontbrand, waarbij de opwaartse trend van vorige week wordt voortgezet.</p>
<p>Specifieke indices: de Dow Jones-index steeg met 0,49%, de S&amp;P 500-index steeg met 0,77% en de Nasdaq-index steeg met 0,95%.</p>
<p>Twee effectenbedrijven hebben hun prognoses voor de S&amp;P 500 verhoogd op basis van hun technologische kracht en enthousiasme voor kunstmatige intelligentie. Goldman Sachs heeft zijn doel voor de S&amp;P 500-index aan het einde van 2024 verhoogd naar 5.600 punten, terwijl Evercore ISI zijn referentie-indexprognose heeft verhoogd van 4.750 punten naar 6.000 punten.</p>
<p>De belangrijke economische gegevens die deze week worden vrijgegeven, omvatten de detailhandelsverkopen van mei op dinsdag, gevolgd door gegevens over industriële productie, nieuwe woningbouwstarts en de initiële waarde van de S&amp;P Purchasing Managers Index. Bovendien zal de markt op woensdag gesloten zijn vanwege de juni-vakantie.</p>
<p>Op 18 juni volgden Aziatische aandelenmarkten de stijging van Wall Street omdat de markt speeches van Federal Reserve-functionarissen later die dag verwachtte. Zorgen over Europese politieke onrust zijn afgenomen, wat het marktsentiment heeft verhoogd en EUROSTOXX 50-futures met 0,6% heeft doen stijgen, waarbij sommige van de scherpe dalingen van vorige week werden teruggedraaid. De FTSE-indexfutures in het Verenigd Koninkrijk stegen ook met 0,43%. Daarnaast staat de Bank of Australia op het punt haar rentebesluit aan te kondigen, wat de kracht van de Australische dollar en binnenlandse aandelenmarkten beïnvloedt.</p>
<p>De MSCI Azië-Pacific-aandelenindex steeg met 0,68%, de Nikkei-index in Japan steeg met 0,83%, de Hang Seng-index in Hong Kong steeg met 0,14% en de Chinese blue chip-aandelen stegen lichtjes met 0,17%.</p>
<p>De Amerikaanse dollar daalde lichtjes met 0,04% ten opzichte van de Japanse yen naar 157,68 yen op de valutamarkt. De euro daalde naar $1,0729, terwijl het pond steeg met 0,04% naar $1,27105. De onshore wisselkoers van de Chinese yuan ten opzichte van de Amerikaanse dollar is gedaald naar een zeven maanden laag van 7,2554, mede als gevolg van gemengde economische gegevens die op maandag zijn vrijgegeven.</p>
<p>Met betrekking tot grondstoffen steeg de prijs van Brent ruwe olie futures met 0,11% naar $84,34 per vat. Vanwege het toenemende vraagperspectief en investeerders die geloven dat OPEC+ olieproducerende landen hun productieplannen vanaf het vierde kwartaal van dit jaar kunnen opschorten of intrekken, zijn de olieprijzen licht gestegen.</p>
<p>Spotgoud steeg met 0,13% tot $2.321,99 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 beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te publiceren op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>