RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBrZWVydCB0ZXJ1ZyBuYWFyICQ2MS4wMDAsIE5FSVJPQ1RPIHdvcmR0IGhldCBtZWVzdCBvcHZhbGxlbmRlIHRva2Vu

2024-09-18, 04:06

<p><img src="https://gimg2.gateimg.com/image/article/17266322509.18.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Digest20BTC20ETFs20zagen20grote20instroom20met20een20aanzienlijk20verhoogde20waarschijnlijkheid20van20een20renteverlaging20van205020basispunten20in20september459593"><a name="Crypto Dagelijkse Digest: BTC ETF’s zagen grote instroom, met een aanzienlijk verhoogde waarschijnlijkheid van een renteverlaging van 50 basispunten in september" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Digest: BTC ETF’s zagen grote instroom, met een aanzienlijk verhoogde waarschijnlijkheid van een renteverlaging van 50 basispunten in september</h2><p>Volgens gegevens van Farside Investor is de nettostroom van US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De handel in ETF’s bedroeg gisteren $186 miljoen. Daarvan ontving Fidelity FBTC een nettostroom van $56 miljoen, ontving Ark ARKB een nettostroom van $42 miljoen en ontving Bitwise BITB een nettostroom van $45 miljoen. BlackRock IBIT heeft geen instroom of uitstroom van fondsen.</p>
<p>De VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De spot ETF had gisteren een uitstroom van $15 miljoen, waarbij de handelsvolume van ETH ETF over het algemeen relatief klein was. Onder hen had Grayscale ETHE een uitstroom van $17,9 miljoen, terwijl BlackRock ETHA geen instroom of uitstroom van fondsen had.</p>
<p><strong>Gegevens: Het aantal CEX Bitcoin-stortingsadressen daalde tot het laagste niveau in de afgelopen jaren, wat wijst op een afname van de verkoopdruk</strong></p>
<p>Volgens een recent onderzoeksrapport van CryptoQuant is het aantal stortingsadressen op het <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> CEX-platform gedaald tot 132.100, het laagste niveau in vele jaren. Deze indicator vertegenwoordigt het aantal adressen dat inkomende transacties naar het handelsplatform stuurt. Analyse toont aan dat het laagste niveau in jaren wijst op een afname van het aantal investeerders dat Bitcoin verkoopt op spot handelsplatforms, wat kan duiden op een afname van verkoopdruk.</p>
<p>Maar CryptoQuant onderzoeksdirecteur Julio Moreno merkte ook op dat wanneer stortingen op handelsplatforms afnemen, dit niet alleen kan duiden op een afname van de interesse van mensen om Bitcoin te verkopen. Dit kan ook betekenen dat er een afname is in de algemene vraag naar Bitcoin, omdat minder handelaren geld storten om te wedden op prijsstijgingen.</p>
<p><strong>Eigenpie zal op 20 september een IDO uitvoeren.</strong></p>
<p>Eigenpie plaatste op sociale media dat de IDO zal worden gehouden op Magpie Launchpad via het Arbitrum-netwerk. De snapshot wordt genomen tussen 18 en 20 september om de IDO-quota-toewijzing te bepalen voor vlMGP-houders, MGPs en vlMGP-vernietigers. IDO begint om 21:00 (Peking-tijd) op 20 september en eindigt om 21:00 (Peking-tijd) op 24 september. De toewijzing van aandelen in de private plaatsingsronde is als volgt:</p>
<p>· Eigenpie Points-houders zijn goed voor 70,59%<br>· VLMGP-houders zijn goed voor 20,59%<br>· MGP/vlMGP vernietigers zijn goed voor 8,82%</p>
<p>De private placement-ronde zal binnen 24 uur worden afgerond, met een FDV van $3 miljoen. De publieke ronde zal 72 uur duren, met een FDV van $6 miljoen, en de uiteindelijke prijs zal worden bepaald door het totale bedrag aan toegezegde fondsen in deze ronde te delen door het totale aantal verkochte tokens in deze ronde. Het totale tokenaandeel van IDO is 3.600.000 EGP, en het private equity-token zal 6 maanden worden vergrendeld en vervolgens lineair worden ontgrendeld binnen 2 jaar. De tokens van de openbare aanbieding zullen 100% worden ontgrendeld tijdens TGE.</p>
<p><strong>De kans dat de Fed deze week de rente met 50 basispunten verlaagt, is 63%.</strong></p>
<p>Volgens de ‘FedWatch’-gegevens van CME is de kans dat de Federal Reserve de rente in september met 25 basispunten verlaagt 37,0%, en de kans dat de rente met 50 basispunten wordt verlaagd, is 63,0%.</p>
<h2 id="h2-Markttrends20BTC20leidde20de20algemene20stijging20van20de20markt20terwijl20NEIROCTO20zich20onderscheidde20van20de20massa367002"><a name="Markttrends: BTC leidde de algemene stijging van de markt, terwijl NEIROCTO zich onderscheidde van de massa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC leidde de algemene stijging van de markt, terwijl NEIROCTO zich onderscheidde van de massa</h2><h3 id="h3-Gangbare20Munten762377"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>BTC keerde vanochtend terug naar $61.000 en consolideert momenteel rond de $60.000. BTC ETF’s hebben weer grote instroom en de Federal Reserve staat op het punt de rentetarieven te verlagen;</p>
<p>ETH vertoonde zwakke prestaties, met bijna geen prijsschommelingen gedurende de dag, nog steeds zwevend rond $2.300, en ETH ETF’s gaan door met <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> uit;</p>
<p>Altcoins hebben de algemene opleving van de markt gevolgd, met uitstekende prestaties van NEIROCTO, BIGTIME, FIGHT en anderen;</p>
<p>Wat betreft data-indicatoren was de AHR999-index vandaag 0,65, wat wijst op een significante rebound in BTC-prijzen; De Fear &amp; Greed Index staat op 45 en de marktsentiment is verbeterd na een algemene stijging.</p>
<h3 id="h3-Markt20Hotspots473672"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Meme sector: NEIROCTO, FIGHT, BABYDOGE en andere stegen, waarbij NEIROCTO de ster-token werd die de markt leidde met meer dan 100% intraday winst. NEIROCTO is de eerste Neiro-token die is ingezet op de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> blockchain, wat deze week veel aandacht kreeg van marktfondsen en binnen 24 uur zijn prijs verdubbelde. FIGHT is een meme-munt die verband houdt met het concept van de Amerikaanse presidentsverkiezingen. Amerikaanse presidentskandidaat Trump tweette over FIGHT-slogans, wat de stijging van FIGHT stimuleerde. De intraday stijging van FIGHT bereikte ooit 400%, maar is nu scherp gedaald.</p>
<p>GameFi-sector: BIGTIME, MAVIA en anderen zijn gestegen, waarbij BIGTIME de best presterende GameFi-token is geworden met een stijging van 45% intraday. Het BIGTIME-spel is al een jaar online en is sinds de recente lancering op een Koreaans handelsplatform in opkomst. Het BIGTIME-project blijft de game-inhoud voortdurend bijwerken en een goede community opbouwen. En nog een opkomend spel, Mavia, is een tower defense-strategiespel dat gisteren werd aangekondigd om te worden gelanceerd op de Web Ruby Marketplace. Gebruikers kunnen in-game activa verhandelen en in november functionaliteit voor het verhandelen van MAVIA-tokens aan de marktplaats toevoegen.</p>
<p>Sociaal concept: UXLINK is met meer dan 60% gestegen, met een huidige marktkapitalisatie van $123 miljoen, en UXLINK is met 500% gestegen in vergelijking met het begin van de maand. Uxlink is de <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">web3</a> infrastructure van sociale platformen, en UXLink-tokens kunnen de waarde van het hele Uxlink-ecosysteem vastleggen.</p>
<h2 id="h2-Macroeconomie20SampP2050020bereikte20een20nieuw20historisch20hoogtepunt20de20Federal20Reserve20zal20morgenochtend20vroeg20de20rentetarieven20bespreken448415"><a name="Macroeconomie: S&amp;P 500 bereikte een nieuw historisch hoogtepunt, de Federal Reserve zal morgenochtend vroeg de rentetarieven bespreken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: S&amp;P 500 bereikte een nieuw historisch hoogtepunt, de Federal Reserve zal morgenochtend vroeg de rentetarieven bespreken</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt schommelden, waarbij de S&amp;P 500-index met 0,03% steeg naar 5634,58 punten; De Dow Jones Industrial Average daalde met 0,04% naar 41606,18 punten; De Nasdaq-index steeg met 0,20% en sloot af op 17628,06 punten. Het referentiepunt voor de 10-jarige schatkistrente bedraagt 3,65%, terwijl het rendement op de 2-jarige schatkist, dat het meest gevoelig is voor het rentebeleid van de Federal Reserve, 3,59% bedraagt.</p>
<p>Deze week zal de wereld beginnen met de ‘Super Central Bank Week’, en de focus van financiële markten zal liggen op de rentebeslissingen die worden aangekondigd door de Federal Reserve en de Bank of Japan. Bovendien zullen ook centrale banken in meerdere landen zoals het Verenigd Koninkrijk, Brazilië, Noorwegen en Indonesië hun laatste rentebesluiten bekendmaken. President Lagarde van de Europese Centrale Bank en verschillende leden zullen binnen de week toespraken houden. De bekende macro-journalist Nick Timiraos, bekend als de ‘stem van de Federal Reserve’, verklaarde onlangs dat de Fed deze week zeker de rentetarieven zal verlagen, maar het is nog steeds onzeker of de omvang van deze renteverlaging 50 basispunten zal zijn of de traditionele 25 basispunten.</p>
<p>Volgens de ‘FedWatch’-gegevens van CME is de kans dat de Federal Reserve in september de rente met 25 basispunten verlaagt 37,0%, en de kans dat de rente met 50 basispunten wordt verlaagd 63,0%.</p>
<h3 id="h3-Conclusie681543"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Het algehele sentiment op de huidige markt is hersteld, gedreven door positief macro-economisch nieuws. Bitcoin en enkele Altcoins hebben een sterke prestatie laten zien, vooral in de Meme en GameFi sectoren waar tokens een significante opwaartse trend hebben laten zien. Ethereum en sommige activa vertonen echter nog steeds zwakte en investeerders moeten de marktdynamiek en beleidswijzigingen nauwlettend volgen, voorzichtig opereren en activa redelijk toewijzen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>IJsing</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 zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>