RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0by1tYXJrdCB2aWVsIG92ZXIgaGV0IGFsZ2VtZWVuOyBaS3N5bmMgdmFuIHBsYW4gb20gMyw2QiBaSy10b2tlbnMgdGUgbHVjaHRlbjsgJEhVTlRFUkJPREVOIHN0ZWVnLCBtYWFyIGFuZGVyZSBwb2xpdGlla2UgbWVtZXMgd2VyZGVuIG92ZXIgaGV0IGFsZ2VtZWVuIHZlcmtvY2h0Lg==

2024-06-12, 04:02

<p><img src="https://gimg2.gateimg.com/image/article/17181648351_8.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20De20algemene20daling20op20de20cryptomarkt20heeft20aanzienlijke20liquidatie20veroorzaakt20ZKsync20zal20volgende20week203620miljard20ZK20tokens20uitdelen20via20een20airdrop20HUNTERBODEN20steeg20maar20andere20politieke20memes20werden20over20het20algemeen20verkocht20De20Financile20Afdeling20van20Polygon20Community20heeft20een20langetermijnplan20aangekondigd20om20120miljard20tokens20vrij20te20geven490051"><a name="Crypto Dagelijks Overzicht: De algemene daling op de cryptomarkt heeft aanzienlijke liquidatie veroorzaakt; ZKsync zal volgende week 3,6 miljard ZK tokens uitdelen via een airdrop; $HUNTERBODEN steeg, maar andere politieke memes werden over het algemeen verkocht; De Financiële Afdeling van Polygon Community heeft een langetermijnplan aangekondigd om 1 miljard tokens vrij te geven." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: De algemene daling op de cryptomarkt heeft aanzienlijke liquidatie veroorzaakt; ZKsync zal volgende week 3,6 miljard ZK tokens uitdelen via een airdrop; $HUNTERBODEN steeg, maar andere politieke memes werden over het algemeen verkocht; De Financiële Afdeling van <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> Community heeft een langetermijnplan aangekondigd om 1 miljard tokens vrij te geven.</h2><p>Crypto Dagelijks Overzicht: De algemene daling op de cryptomarkt zorgde voor aanzienlijke liquidatie; ZKsync zal volgende week 3,6 miljard ZK tokens uitdelen; $HUNTERBODEN steeg, maar andere politieke memes werden over het algemeen verkocht; Het Polygon Community Finance Department kondigde een langetermijnplan aan om 1 miljard tokens vrij te geven.</p>
<p>In de afgelopen twee dagen heeft de cryptomarkt verkoop meegemaakt, wat heeft geleid tot een aanzienlijke stijging van het liquidatievolume. Volgens de gegevens van CoinGlass heeft de verkoop in de afgelopen 24 uur geleid tot ongeveer $270,4 miljoen aan geliquideerde geheven posities, waarbij longposities goed waren voor $238 miljoen.</p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> daalde met 3,5% tot $67.275 binnen 24 uur, terwijl <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> daalde met 4,6% tot $3.495. <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> leidt met een vereffend bedrag van $70,5 miljoen, waarvan $64,6 miljoen een uitgebreide positie is. Het vereffende bedrag van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> is $68,88 miljoen. De GMCI 30-index, die de topcryptocurrencies volgt, daalde met 4,6% tot 135,58, het laagste niveau sinds 20 mei.</p>
<p>Vanwege de aankomende publicatie van twee macro-economische gegevens op woensdag - het maandelijkse Consumer Price Index-rapport en de monetaire beleidsverklaring van de Federal Reserve - zijn marktattitudes voorzichtig geweest.</p>
<p><strong>ZKsync zal volgende week 3,6 miljard ZK-tokens airdroppen</strong><br>De ZKsync Association zal volgende week 3,675 miljard ZK-tokens uitdelen aan vroege gebruikers en adoptanten van het Ethereum Layer 2-netwerk ZKsync. ZKsync verklaarde dinsdag dat dit overeenkomt met 17,5% van de totale voorraad ZK-tokens, wat neerkomt op 21 miljard.</p>
<p>Gebruikers kunnen vanaf volgende week airdrop-tokens ontvangen, met een deadline van 3 januari 2025. Bijdragers kunnen vanaf 24 juni ontvangen. Bovendien zal 49,1% van de tokenvoorraad worden toegewezen via ecosysteemplanning, waarbij 17,2% wordt toegewezen aan investeerders en 16,1% aan het Matter Labs-team.</p>
<p>ZKsync verklaarde dat airdrops 695.232 portefeuilles zouden bestrijken, en de rechtmatigheid en toewijzing zullen gebaseerd zijn op een momentopname van de ZKsync Era en ZKsync Lite-evenementen op 24 maart 2024, ter gelegenheid van de eerste verjaardag van de lancering van het ZKsync Era-mainnet.</p>
<p>17,5% van de ZK airdrops wordt toegewezen aan twee groepen gemeenschapsleden - gebruikers (89%) en bijdragers (11%). Gebruikers voeren transacties uit op ZKsync en bereiken activiteitsdrempels, terwijl bijdragers individuen, ontwikkelaars, onderzoekers, gemeenschappen en bedrijven zijn die bijdragen aan het ZKsync-ecosysteem en protocollen via ontwikkeling, promotie of educatie.</p>
<p><strong>$HUNTERBODEN is gestegen, maar andere politieke memes werden over het algemeen verkocht</strong><br>De meme sector, met als thema de Amerikaanse president Joe Biden en de Republikeinse leider Donald Trump, maakt een grotere verkoopgolf mee dan de algehele cryptomarkt.</p>
<p>Volgens de gegevens van CoinGecko is de marktkapitalisatie van politieke financiën (PolitiFi) memes in de afgelopen 24 uur met meer dan 13% gedaald. De FreeTrump-token ($TRUMP) leidde de daling en viel met 45% in de afgelopen 24 uur. De grootste PolitiFi-token qua marktkapitalisatie, MAGA (TRUMP) ($560 miljoen), daalde met 13%. Deze tokens hebben natuurlijk geen officiële associatie met enige politieke figuur.</p>
<p>De federale jury oordeelde dat Hunter Biden schuldig werd bevonden aan drie federale misdrijven met betrekking tot wapens en dat hij de wet overtrad die drugsgebruikers verbiedt om vuurwapens te bezitten. Volgens CNN is dit de eerste keer dat de zoon van de huidige president is veroordeeld tijdens het ambtstermijn van zijn vader.</p>
<p>Toen het schuldig verdict werd aangekondigd op woensdag, de Hunter Boden-token gebaseerde op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> is geëxplodeerd en is in de afgelopen 24 uur met meer dan 30% gestegen tot $0.001514 op het moment van publicatie. Een van de meest populaire memecoins in 2024, Jeo Boden (BODEN), daalde met 5,5% naar $0.1855.</p>
<p><strong><a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> De Community Finance-afdeling heeft aangekondigd dat ze van plan zijn om 1 miljard tokens vrij te geven op de lange termijn.</strong><br>De afdeling Community Finance heeft een langetermijnplan aangekondigd om de ontwikkeling van blockchain te bevorderen, waarbij binnen tien jaar 1 miljard tokens zullen worden vrijgegeven. De Community Vault verklaarde: ‘Na consensus in de gemeenschap is de Community Vault opgericht en zal binnen tien jaar 1 miljard POL worden vrijgegeven, ongeveer 100 miljoen POL per jaar, allemaal voor bouwers.’ POL zal de inheemse token van Polygon worden en uiteindelijk MATIC vervangen.</p>
<p>Het Ministerie van Financiën verklaarde dat geïnteresseerde bouwers vanaf dinsdag kunnen solliciteren voor het ‘eerste seizoen’ van het plan. In de beginfase van het stimuleringsplan zal het Ministerie van Financiën 35 miljoen MATIC (ongeveer $22 miljoen) verdelen aan projecten die zijn gebouwd op Polygon. De deadline voor de aanvraag voor het eerste seizoen is 31 augustus 2024, met een financieringsbedrag van ongeveer 5.000 of meer MATIC-tokens.</p>
<p>De Polygon Community Vault is een protocol-gebaseerd fonds onafhankelijk van Polygon laboratories en andere Polygon entiteiten, beheerd via een raamwerk om gemeenschapsdeelname te bevorderen. Het ontwerp en de lancering hebben tot doel duurzame economische ondersteuning te bieden voor de verdere ontwikkeling en groei van het Polygon ecosysteem. Bijna een jaar geleden stelde het Ethereum schaalbaarheidsoplossing Polygon een technische upgrade voor van zijn inheemse MATIC-tokens in zijn Polygon 2.0 roadmap. De nieuwe POL-token heeft tot doel gestaked te worden over meerdere ketens in het Polygon ecosysteem.</p>
<p>Het Ministerie van Financiën verklaarde in de aankondiging: “Gezien de huidige upgrade van de token van MATIC naar POL, zal de subsidie voor het eerste kwartaal worden uitgegeven in de vorm van MATIC.”</p>
<h2 id="h2-Markttrends20De20markt20daalt20over20het20algemeen20de20ogen20zijn20gericht20op20de20CPIgegevens20van20vandaag20om20de20richting20te20bepalen138793"><a name="Markttrends: De markt daalt over het algemeen, de ogen zijn gericht op de CPI-gegevens van vandaag om de richting te bepalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt daalt over het algemeen, de ogen zijn gericht op de CPI-gegevens van vandaag om de richting te bepalen</h2><p>BTC zakte onder de $67.000, Bitcoin spot ETF’s begonnen te verschuiven van netto <a href="/price/synthetix-network-snx" rel="nofollow noopener noreferrer" target="_blank">snx价格</a> s naar netto uitstroom, waarmee de vorige trend van 20 opeenvolgende dagen van netto <a href="/price/synthetix-network-snx" rel="nofollow noopener noreferrer" target="_blank">snx价格</a> s.</p>
<p>ETH is onder de $3.500 gezakt, dit duidt erop dat het marktsentiment aan het veranderen kan zijn.</p>
<p>Altcoins daalden over het algemeen, terwijl de nieuw gelanceerde munten IO en ZK beide gewaardeerd werden op meer dan $1 miljard. De secundaire markt presteerde slecht.</p>
<h3 id="h3-Macroeconomie340723"><a name="Macroeconomie:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie:</h3><p>De Amerikaanse aandelenmarkt heeft ook een volatiele trend laten zien, ondanks dat Apple een historisch hoogtepunt heeft bereikt. Marktdeelnemers wachten op de publicatie van de CPI-gegevens (consumentenprijsindex) om 12:00 uur (UTC), die morgen om 2 uur ‘s nachts een belangrijke leidraad zullen vormen voor het toekomstige inflatie- en rentebeleid. De markt kan aanzienlijke fluctuaties ervaren voor en na het vrijgeven van de gegevens.</p>
<h3 id="h3-Markt20Hotspots921982"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>DePIN Star Token IO:</strong><br>Essentiële informatie: IO werd gisteravond om 12:00 (UTC) gelanceerd op Gate.io, met een huidige marktkapitalisatie van $3 miljard; Ter vergelijking, RNDR op dezelfde baan heeft een marktkapitalisatie van $4,5 miljard, terwijl AKT een marktkapitalisatie heeft van $1 miljard.</p>
<p>Analyse: Als een nieuwe sterrentoken op het DePIN-traject heeft IO snel marktaandacht gekregen. Hoewel de marktkapitalisatie niet zo hoog is als die van de leidende RNDR, is deze aanzienlijk hoger dan die van AKT, wat wijst op markterkenning van het potentieel ervan.</p>
<p><strong>AI Publieke Keten AO</strong><br>Basisinformatie: AO wordt morgen uitgegeven en AR kan in een verhouding van 1:1 worden omgewisseld voor AO. De verwachte waardering is $1 miljard.</p>
<p>Analyse: Als een nieuwe munt voor AR, wordt verwacht dat AO een waarde heeft van $1 miljard op de markt, wat wijst op hoge verwachtingen voor AI publieke keten projecten. AR-houders kunnen AO in een verhouding van 1:1 omwisselen, wat mogelijk een nieuwe investeringshausse kan veroorzaken.</p>
<p><strong>Layer2 Project Zksync Airdrop</strong><br>Basisinformatie: Op basis van prijzen van buiten de beurs verhandelde transacties is de huidige waardering van de ZK-markt $7,5 miljard. Ter vergelijking, de ARB marktkapitalisatie van het Layer2-project op dezelfde baan is $2,6 miljard, en de OP marktkapitalisatie is $2,2 miljard.</p>
<p>Analyse: Na de aankondiging van Zksync van zijn airdrop-plan was de marktreactie niet zo enthousiast als verwacht. Ondanks een waardering van $7,5 miljard kan het beperkte aantal adressen dat gedekt wordt door airdrops leiden tot een lage marktparticipatie en enthousiasme.</p>
<p>Over het algemeen wacht de markt op belangrijke macro-economische gegevens, en binnen de cryptomarkt beïnvloeden de dynamiek van verschillende projecten voortdurend het sentiment en de besluitvorming van investeerders. De toekomstige markttrend zal afhangen van factoren zoals macro-economische gegevens, projectvoortgang en algemeen marktsentiment.</p>
<h2 id="h2-Macro20Voorafgaand20aan20de20publicatie20van20CPI20en20Fedresoluties20bereikten20de20SampP2050020en20Nasdaq20nieuwe20recordhoogtes20De20verwachte20ongewijzigde20rentetarieven20van20de20Federal20Reserve20leidden20tot20een20trage20marktsentiment829023"><a name="Macro: Voorafgaand aan de publicatie van CPI en Fed-resoluties bereikten de S&amp;P 500 en Nasdaq nieuwe recordhoogtes; De verwachte ongewijzigde rentetarieven van de Federal Reserve leidden tot een trage marktsentiment." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Voorafgaand aan de publicatie van CPI en Fed-resoluties bereikten de S&amp;P 500 en Nasdaq nieuwe recordhoogtes; De verwachte ongewijzigde rentetarieven van de Federal Reserve leidden tot een trage marktsentiment.</h2><p>Op dinsdag 11 juni bleven beleggers voorzichtig terwijl ze wachtten op de komende inflatiegegevens en de resultaten van de beleidsvergadering van de Federal Reserve. De Nasdaq- en S&amp;P 500-indices lieten echter winst zien op dinsdag, en sloten op historische hoogte en keerden het vroege verlies om.</p>
<p>Specifieke index: De Dow Jones Industrial Average daalde met 0,31% en sloot op 38.747,42 punten; de S&amp;P 500 index steeg 0,27% tot 5.375,32 punten; en de Nasdaq Composite Index steeg 0,88% tot 17.343,55 punten.</p>
<p>Voordat het ministerie van Arbeid het rapport over de consumentenprijsindex (CPI) uitbracht, daalde het rendement op benchmarkobligaties van staatsobligaties. Hoewel beleggers geen verandering in de doelrente van het federale fonds verwachten, zal het Federal Open Market Committee (FOMC) naar verwachting een samenvatting van de economische prognoses publiceren, die zal helpen het toekomstige beleidspad van de centrale bank te verduidelijken.</p>
<p>Onder de tech-reuzen steeg de aandelenprijs van Apple met 7% naar een historisch hoogtepunt nadat een nieuwe AI-functie werd uitgebracht om de vraag naar de iPhone te revitaliseren. Dit dreef de Nasdaq Composite Index met 0,9% omhoog en de S&amp;P 500 Index met 0,3%, wat resulteerde in een nieuwe slotkoers.</p>
<p>Aziatische aandelenmarkten openden slecht op woensdag. De MSCI Asia Pacific aandelenindex daalde met 0,1%, terwijl de Nikkei-index in Japan met 0,8% daalde. Technologieaandelen presteerden echter relatief goed, met de MSCI Asia Pacific (exclusief Japan) IT-index die met 1% steeg.</p>
<p>Gegevens tonen aan dat de consumentenprijsindex in China in mei met 0,1% is gedaald op maandbasis, lager dan verwacht, en met 0,3% op jaarbasis is gestegen. Chinese blue-chip aandelen daalden met 0,1%, terwijl de Hong Kong Hang Seng Index zijn eerdere daling voortzette en met 1,2% daalde.</p>
<p>Door de goede prestaties van technologieaandelen op Wall Street zijn de Taiwanese en Zuid-Koreaanse aandelenmarkten, die voornamelijk uit technologieaandelen bestaan, gestegen met respectievelijk 0,7% en 0,3%.</p>
<p>De Amerikaanse dollarkoers heeft sinds de publicatie van de gegevens over de non-farm payroll vorige week vrijdag een stijgende trend laten zien op de valutamarkt, met een piek van 105,31 tegenover belangrijke valuta. Als gevolg van de overwinning van extreemrechtse krachten bij de Europese verkiezingen en politieke onrust veroorzaakt door vervroegde verkiezingen in Frankrijk, daalde de euro scherp ten opzichte van de Amerikaanse dollar tot $1,0734, wat de vierde opeenvolgende handelsdag van daling markeert.</p>
<p>Enkele uren na de publicatie van de Amerikaanse CPI-gegevens wordt verwacht dat de Federal Reserve tijdens beleidsvergaderingen de rentetarieven ongewijzigd zal handhaven. De focus ligt echter op de vraag of het de drie renteverlagingen van dit jaar zal handhaven in zijn prognose in de ‘dot chart’.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen voor de derde opeenvolgende handelsdag gestegen. Brent ruwe olie futures stegen met 0.2% tot $83.11 per vat, terwijl Amerikaanse ruwe olie futures met $0.4 stegen tot $78.19 per vat.</p>
<p>De goudprijs daalde lichtjes met 0,2% tot $2.311,80 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 enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan ​​op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>