RGFnZWxpamtzIE5pZXV3cyB8IFNVSSBiZXJlaWt0IGhpc3RvcmlzY2ggaG9vZ3RlcHVudCwgTkVJUk9FVEggV2hhbGUgVHJhZGVycyBzdGlqZ3Q=

2024-10-14, 04:16

<p><img src="https://gimg2.gateimg.com/image/article/172887920510.14.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20NEIROETH20houders20zijn20aanzienlijk20toegenomen20en20ARB20zal20grote20ontgrendeling20verwelkomen261581"><a name="Crypto Dagelijkse Samenvatting: NEIROETH houders zijn aanzienlijk toegenomen en ARB zal grote ontgrendeling verwelkomen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: NEIROETH houders zijn aanzienlijk toegenomen en ARB zal grote ontgrendeling verwelkomen</h2><p>Volgens de gegevens van Farside Investor was er een nettostroom van $253 miljoen naar de Amerikaanse spotmarkt. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s afgelopen vrijdag, waaronder $117 miljoen van Fidelity FBTC, $97,6 miljoen van ARKB, en geen instroom of uitstroom van gelden van BlackRock IBIT.</p>
<p>Afgelopen vrijdag, de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF had een nettostroom van $100.000, met $8,6 miljoen van Fidelity FETH en $8,7 miljoen van Grayscale GBTC.</p>
<p><strong>Als <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> als het onder de $61.000 zakt, zal de cumulatieve liquiditeitssterkte van mainstream CEX-orders 653 miljoen bereiken</strong></p>
<p>Volgens Coinglass-gegevens, als <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> onder de $61.000 zakt, zal de cumulatieve liquidatiekracht van reguliere CEX-orders 653 miljoen bereiken; Aan de andere kant, als Bitcoin doorbreekt naar $64.000, zal de cumulatieve liquidatiekracht van reguliere CEX-shortorders 848 miljoen bereiken.</p>
<p>De liquidatiegrafiek geeft niet het exacte aantal contracten weer dat geliquideerd moet worden, noch hun precieze waarde. De kolommen op de uitsplitsingsgrafiek geven de belangrijkheid, d.w.z. de sterkte, van elke uitsplitsingscluster weer ten opzichte van zijn naburige uitsplitsingsclusters.</p>
<p>Daarom laat de liquidatiegrafiek zien in hoeverre de doelprijs zal worden beïnvloed wanneer deze een bepaalde positie bereikt. Een hogere “liquidatiekolom” geeft aan dat de prijs een sterkere reactie zal hebben als gevolg van de liquiditeitsgolf zodra deze arriveert.</p>
<p><strong>ARB, AXS en andere tokens zullen een eenmalige grootschalige ontgrendeling ontvangen, ter waarde van ongeveer $220 miljoen.</strong></p>
<p>Volgens gegevens van Token Unlocks zullen ARB, AXS en andere tokens volgende week aanzienlijk worden ontgrendeld, met een waarde van ongeveer $220 miljoen. Daaronder:</p>
<p>Arbitrarum (ARB) zal naar verwachting ongeveer 92,65 miljoen tokens ontgrendelen om 21.00 uur Beijing-tijd op 16 oktober, met een verhouding van 2,56% ten opzichte van de huidige <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> en een waarde van ongeveer $49,4 miljoen;</p>
<p><a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> Omstreeks 21:10 uur Beijing-tijd op 14 oktober zal (AXS) ongeveer 9,25 miljoen tokens ontgrendelen, met een huidige stroomverhouding van 6,08% en een waarde van ongeveer $43,1 miljoen;</p>
<p>Eigenlayer (EIGEN) zal ongeveer 11,22 miljoen tokens ontgrendelen om 3 uur ‘s ochtends Beijing-tijd op 16 oktober, wat overeenkomt met 6,01% van de huidige circulatie en ongeveer $43,9 miljoen in waarde.</p>
<p><strong>NEIROETH walvisactiviteit is recentelijk sterk gestegen, waarbij GSR momenteel 4,04% van de totale voorraad tokens vasthoudt</strong></p>
<p>Volgens Spot On Chain monitoring lijkt Neiro op ETH (NEIROETH op Gate site) de accumulatiefase te hebben verlaten en zijn walvissen actiever geworden, met kopers waaronder GSR Markets, momenteel in het bezit van 40,4 miljoen NEIROETH, wat overeenkomt met 4,04% van het totale aanbod. De laatste toename in bezit was twee dagen geleden; Smart Money 0xe9f verkocht OM en ATH ter waarde van $1 miljoen 3 uur geleden en ruilde ze in voor de eerste batch van 8,45 miljoen munten; bwecapital.eth heeft twee dagen geleden 4,065 miljoen munten verzameld, wat overeenkomt met 0,4% van het circulerende aanbod;</p>
<p>De verkopers omvatten entiteiten die $145 miljoen hebben verdiend aan SHIB en 17,5 miljoen eenheden vijf dagen geleden hebben verkocht, wat resulteerde in een verlies van $1,49 miljoen (-55%); Walvis 0x00D heeft in de afgelopen 17 uur 4,7 miljoen munten ($531.000) gestort op CEX en heeft $247.000 (+87%) verdiend.</p>
<h2 id="h2-Markttrends20SUI20bereikte20een20historisch20hoogtepunt20fan20tokens20stegen20gezamenlijk555498"><a name="Markttrends: SUI bereikte een historisch hoogtepunt, fan tokens stegen gezamenlijk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: SUI bereikte een historisch hoogtepunt, fan tokens stegen gezamenlijk</h2><h3 id="h3-Markt20Hotspots192025"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>SUI brak door $ 2,2 en bleef een nieuw historisch hoogtepunt neerzetten, met nieuwe openbare ketenprojecten zoals APT en TIA die dit voorbeeld volgden. SUI is het leidende token in de publieke ketensector in deze ronde van markttrends, met een algemene marktkapitalisatie in de top 20;</p>
<p>De opkomst van fan tokens zoals CHZ, OG en PSG, en de collectieve toename van fan tokens duiden vaak op het einde van de korte termijn markttrend en kunnen binnenkort een aanpassingszone betreden;</p>
<p>BOME steeg met meer dan 10%, waardoor andere <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> om in ketenmeme-projecten zoals MANKEI en PENG mee te doen.</p>
<h3 id="h3-Mainstream20Munten346142"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC is nog steeds volatiel tussen $60.000 en $66.000, en de prijs bevindt zich momenteel in het midden van de Bollinger Bands. Deze week is een kritieke periode voor de toekomstige prijstrend van BTC;</p>
<p>ETH’s prestaties is zwak, met ETH ETF handelsvolume en fondsinvesteringen ver onder de verwachtingen, en de wekelijkse volatiliteit van ETH is minder dan 10%;</p>
<p>Altcoins daalden over het algemeen, met toonaangevende tokens zoals POPCAT en FTM die eerder een terugval ondervonden, en er zijn momenteel geen andere toonaangevende projecten op de markt.</p>
<h2 id="h2-Macroeconomie20De20Amerikaanse20aandelenmarkt20sloot20gezamenlijk20hoger20afgelopen20vrijdag20en20de20waarschijnlijkheid20dat20de20Fed20de20rente20in20november20met202520basispunten20verlaagt20is20aanzienlijk20toegenomen145652"><a name="Macroeconomie: De Amerikaanse aandelenmarkt sloot gezamenlijk hoger afgelopen vrijdag, en de waarschijnlijkheid dat de Fed de rente in november met 25 basispunten verlaagt, is aanzienlijk toegenomen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: De Amerikaanse aandelenmarkt sloot gezamenlijk hoger afgelopen vrijdag, en de waarschijnlijkheid dat de Fed de rente in november met 25 basispunten verlaagt, is aanzienlijk toegenomen</h2><p>De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk hoger, waarbij de S&amp;P 500-index met 0,61% steeg naar 5.815,03 punten; de Dow Jones Industrial Average steeg met 0,97% naar 42.863,86 punten; de Nasdaq-index steeg met 0,33% naar 18.342,94 punten. Vorige week steeg de Dow Jones-index met 1,21%, de Nasdaq-index met 1,13% en de S&amp;P 500-index met 1,11%. Het referentiepunt van de 10-jaars Treasury-opbrengst is 4,08%, terwijl de opbrengst van de 2-jaars Treasury, het meest gevoelig voor de beleidsrente van de Federal Reserve, 3,95% is.</p>
<p>De notulen van de vergadering van de Federal Reserve in september, vorige week vrijgegeven, toonden een diepere divergentie in de omvang van de renteverlaging. Hoewel Powell vrijwel unaniem de stem leidde om een renteverlaging van 50 basispunten te ondersteunen, pleitte niet alleen gouverneur Bauman voor een renteverlaging van 25 basispunten, maar vonden meer functionarissen dat het normaliseren van het beleid geleidelijk zou moeten gebeuren.</p>
<p>Op donderdag bleek uit gegevens dat de Amerikaanse CPI voor september op jaarbasis met 2,4% is gestegen en op maandbasis met 0,2%; De kern-CPI steeg op jaarbasis met 3,3% en op maandbasis met 0,3%, beide hoger dan de verwachtingen van de markt. Uit de focus op de inflatie van de supercore-services door Fed-voorzitter Powell blijkt dat de groeipercentages op jaarbasis en op maandbasis in september met 0,02% zijn afgenomen. Ze zijn respectievelijk met 0,06% gestegen ten opzichte van augustus, waarbij de groeipercentages op maandbasis drie opeenvolgende maanden stijgen.</p>
<p>De gegevens tonen aan dat het anti-inflatieproces in de Verenigde Staten begint te vertragen en het eerder gevreesde risico van een opleving van de kerninflatie zich voordoet. Dit kan aanzienlijke invloed hebben op het tempo en de omvang van de daaropvolgende renteverlagingen. Na de bekendmaking van de gegevens wedden handelaren dat de waarschijnlijkheid van de Federal Reserve om de rente in november met 25 basispunten te verlagen hoger is dan 80%.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Ijs</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 voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>