RGFnZWxpamtzIG5pZXV3cyB8IEJUQyB3b3JkdCB2ZXJ3YWNodCAkNjlLIHRlIGRvb3JicmVrZW4sIG1hcmt0c2VudGltZW50IGJsaWpmdCBncmV0aWc7IEJpZGVuIHRyZWt0IHppY2ggdGVydWcgdWl0IGRlIHByZXNpZGVudHNjYW1wYWduZSwgd2FhcmRvb3IgZ2VyZWxhdGVlcmRlIHRva2VucyBrZWxkZXJlbg==

2024-07-22, 04:00

<p><img src="https://gimg2.gateimg.com/image/article/17216207121_17.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20BTC20wordt20verwacht20om20door20te20breken206900020en20het20sentiment20in20de20cryptomarkt20blijft20leunen20naar20hebzucht20Biden20trekt20zich20terug20uit20de20presidentscampagne20BODENtoken20daalt20met204420RollupFinance20kondigt20aan20dat20het20de20activiteiten20zal20stoppen20Strikte20wetten20in20ZuidKorea20met20betrekking20tot20cryptobeurzen20treden20in20werking228692"><a name="Crypto Dagelijks Overzicht: BTC wordt verwacht om door te breken $69,000, en het sentiment in de cryptomarkt blijft leunen naar hebzucht; Biden trekt zich terug uit de presidentscampagne, BODEN-token daalt met 44%; Rollup.Finance kondigt aan dat het de activiteiten zal stoppen; Strikte wetten in Zuid-Korea met betrekking tot cryptobeurzen treden in werking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: BTC wordt verwacht om door te breken $69,000, en het sentiment in de cryptomarkt blijft leunen naar hebzucht; Biden trekt zich terug uit de presidentscampagne, BODEN-token daalt met 44%; Rollup.Finance kondigt aan dat het de activiteiten zal stoppen; Strikte wetten in Zuid-Korea met betrekking tot cryptobeurzen treden in werking</h2><p>Eerst gaan we de handelsactiviteit van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> Volgens gegevens van Farside Investor had Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (GBTC) op 19 juli een kapitaaluitstroom van $20,3 miljoen. Ondertussen ontving iShares Trust Bitcoin Spot ETF (IBIT) $116,2 miljoen aan instromen, Fidelity Bitcoin Spot ETF (FBTC) ontving $141 miljoen aan instromen, VanEck Bitcoin Spot ETF (HODL) ontving $41,8 miljoen aan instromen en Bitwise Bitcoin Spot ETF (BITB) ontving $44,6 miljoen aan instromen.</p>
<p>Met de sterke opleving van de prijzen van mainstream tokens heeft de crypto Fear and Greed Index het ‘gierigste’ niveau in meer dan een maand bereikt. Dit komt overeen met het tegenovergestelde scenario van de ‘extreme angst’ van vorige week, wat de marktvisie van gewone handelaren vertegenwoordigt. Sommige handelaren geloven dat BTC naar verwachting door zijn historische hoogtepunt van $69.000 zal breken.</p>
<p><strong>Joe Biden trekt zich terug uit de presidentscampagne, BODEN-token daalt met 44%</strong></p>
<p>De Amerikaanse president Joe Biden heeft aangekondigd dat hij geen herverkiezing zal nastreven in de aanstaande presidentsverkiezingen van 2024. De afgelopen weken heeft Biden steeds meer druk ondervonden om zich terug te trekken uit de race, met verschillende huidige senatoren die eisen dat hij dat doet, en rapporten suggereren dat de voormalige president Barack Obama dat ook doet.</p>
<p>Biden’s verklaring, die op zondag werd vrijgegeven, zei dat aftreden in het belang van de partij en het land is. Hij verklaarde dat hij vicepresident Kamala Harris zou steunen als de kandidaat van de Democratische Partij. Met de bekendmaking van dit nieuws is de Meme-coin Jeo Boden-token met 44% gedaald. Ondertussen zijn de tokens van andere potentiële concurrenten aanzienlijk gestegen. Met name een meme genaamd Kamala Horris is gestegen met 52%, terwijl de meme Gabin Noosum is gestegen met 115%.</p>
<p>Relatief gezien, nadat de Republikeinse presidentskandidaat Donald Trump’s tegenstander zich terugtrok uit de race, steeg ook de prijs van tokens die naar hem vernoemd zijn. Doland Tremp is het meest getroffen mem, met een stijging van 24% sinds het nieuws bekend werd.</p>
<p>Biden’s zwakke optreden in het debat van vorige maand heeft discussies op gang gebracht over eventuele vervanging van hem als de presidentskandidaat, en sindsdien heeft hij steeds meer druk ondervonden. Volgens ABC News hebben vooraanstaande Democraten, waaronder de meerderheidsleider van de Senaat Chuck Schumer, de afgelopen week opgeroepen tot zijn terugtrekking.</p>
<p>Terwijl de Democratische Partij zich voorbereidt om volgende maand tijdens de Democratische Nationale Conventie in Chicago haar presidentskandidaat te kiezen, is het momenteel onduidelijk of de partij het voorbeeld van Biden zal volgen en Harris zal voordragen. Volgens een toonaangevend contract van Polymarket is de kans dat vicepresident Harris kandidaat wordt 81%, terwijl de kans op een reguliere ‘andere’ kandidaat 12% is.</p>
<p><strong>Rollup.Finance kondigt aan dat het binnenkort de activiteiten zal staken</strong></p>
<p>Het gedecentraliseerde derivatehandelsplatform Rollup Finance heeft aangekondigd dat het zijn activiteiten zal stopzetten. Het project verklaarde op X: “Gedurende de 16 maanden van continue werking hebben we de storm van de bear market doorstaan, het handelsvolume verhoogd, handelaren behouden en innovatie gebracht door middel van partnerschappen. Echter, vanwege het gebrek aan zkSync-middelen en een product-market fit, hebben we onze positie opnieuw geëvalueerd en besloten deze stap te nemen.”</p>
<p>Rollup.Finance geeft aan dat de activa van de gebruiker veilig zijn en dat de gebruiker een maand de tijd heeft om middelen te liquideren en op te nemen. Orders die niet worden gesloten bij afloop zullen automatisch worden geliquideerd en getroffen gebruikers krijgen nog een maand de tijd om middelen op te nemen. Het platform wordt volledig gesloten op 21 september 2024 en gerelateerde applicaties zullen niet beschikbaar zijn. Daarna worden de officiële e-mail, het Twitter-account en de Discord chat-ondersteuningskanalen stopgezet.</p>
<p>Rollup.Finance drukt zijn diepste dankbaarheid uit aan vroege gebruikers en investeerders, en verklaart dat sommige teamleden zullen blijven streven naar de gedecentraliseerde toekomst van DeFi en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p><strong>Strikte wetten met betrekking tot cryptobeurzen in Zuid-Korea treden in werking</strong></p>
<p>Op 19 juli traden nieuwe regelgeving van de financiële veiligheidsregulerende instantie van Zuid-Korea in werking. Ze hebben tot doel gebruikers te beschermen tegen het kopen en opslaan van crypto-activa via virtuele activadienstverleners (VASP).</p>
<p>Volgens een verklaring van de Financial Services Commission (FSC) van Zuid-Korea op 17 juli moet VASP meerdere maatregelen nemen om de veiligheid van gebruikers van cryptocurrency te waarborgen. Deze omvatten het kopen van verzekeringen voor de crypto-activa van gebruikers om hackers en kwaadwillende aanvallen te voorkomen, het scheiden van de cryptomiddelen van klanten van de uitwisselingsmiddelen en het veilig opslaan van klantendeposito’s in banken.</p>
<p>VASP moet ook een bepaald niveau van due diligence handhaven om het witwassen van geld op haar platform te voorkomen en moet verdachte transacties melden aan toezichthoudende autoriteiten.</p>
<p>Het FSC-document stelt dat VASP altijd een systeem voor het monitoren van verdachte transacties moet handhaven en verdachte transactieactiviteiten onmiddellijk moet melden aan de Financial Supervisory Service (FSS).</p>
<p>Zuid-Koreaanse cryptobeurzen hebben hun bezorgdheid geuit over deze regelgeving, omdat ze geloven dat dit kan leiden tot het verwijderen van veel tokens. Op 3 juli meldde Cointelegraph dat als onderdeel van de nieuwe wet ter bescherming van crypto-gebruikers, 20 Zuid-Koreaanse cryptobeurzen in de komende zes maanden in totaal 1.333 cryptocurrencies zullen beoordelen. De Digital Asset Exchange Alliance (DAXA) verklaarde dat er ‘weinig kans is op een grootschalige delisting die in één keer plaatsvindt’.</p>
<p>Ondertussen heeft de regeringspartij van Zuid-Korea, de Nationale Krachtpartij, officieel voorgesteld de uitvoering van het beleid van het belasten van winsten uit crypto-handel uit te stellen. De partij wijst erop dat de huidige sentimenten ten opzichte van crypto-activa verslechteren en dat het snel belasten van virtuele activa ‘op dit moment niet verstandig is’.</p>
<h2 id="h2-Markttrends225612"><a name="Markttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends</h2><p>BTC brak vanochtend kortstondig door de $68.000, met spot ETF-inflows van meer dan $2 miljard in de afgelopen twee weken.</p>
<p>ETH heeft de $3.500 grens doorbroken en het ETH ETF wordt naar verwachting op 23 juli openbaar verhandeld. Sommige gemeenschappen geloven dat het na goedkeuring van het ETH ETF een kortetermijn-bearish trend kan zijn.</p>
<p>SOL is teruggekeerd boven $180 en de Meme-token blijft de meest indrukwekkende sector onder Altcoins.</p>
<h3 id="h3-Gegevensindicatoren987922"><a name="Gegevensindicatoren:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gegevensindicatoren:</h3><p>Vandaag staat de AHR999-index op 0,95, wat aangeeft dat de markt de bodemzone heeft overschreden en geleidelijk stijgt. De Fear Greed Index is 70 en in vergelijking met de extreme angst voor de prijs van Bitcoin van $53.500 is het marktsentiment in korte tijd in een gekke staat beland.</p>
<p>De Fear Greed Index staat op 70, en in vergelijking met de extreme angst bij de BTC-prijs van $53.500, is het marktsentiment in korte tijd in een razernij terechtgekomen.</p>
<h3 id="h3-Macroeconomie493656"><a name="Macroeconomie:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie:</h3><p>Amerikaanse aandelen: De S&amp;P 500 daalde vorige week met 1,97%, de Nasdaq Composite daalde met 3,65% en de Dow Jones Industrial Average steeg met 0,72%. Tech giganten zoals Microsoft, Google en Apple hebben allemaal aanzienlijke dalingen ervaren.</p>
<p>Politieke Dynamiek: Biden kondigt terugtrekking aan, Zwarte Vice President Harris zal de presidentskandidaat van de Democratische Partij worden, en Trump’s kansen om te winnen op Polymarket zijn gedaald tot 63%.</p>
<h3 id="h3-Markt20Hotspots269019"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>BTC: De aanzienlijke stijging van BTC doorbrak de $68000, slechts 8% verwijderd van een historisch hoogtepunt, waardoor de algehele markt steeg. De Bitcoin Nashville Conference van deze week zal plaatsvinden op de 27e, en de Amerikaanse presidentskandidaat Trump zal de conferentie bijwonen. Bovendien is het privévliegtuig van de rijkste man ter wereld, Musk, ook geland in Nashville, en er zijn geruchten op de markt dat Musk mogelijk ook de Bitcoin-conferentie zal bijwonen. De profielfoto van Musk’s X-account is ook vervangen door een profielfoto met laserogen. De laatste keer dat hij zijn profielfoto naar deze veranderde, was in april 2019, waarna BTC een bullmarktstadium betrad.</p>
<p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteem: SOL keert terug boven de $180, waardoor de algehele sterke prestaties van het Solana-ecosysteem worden gestimuleerd. WEN, POPCAT, MEW en andere kattenmeme-munten zijn gestegen. POPCAT staat op het punt om de eerste kattenmeme-munt te worden die de marktwaarde van $1 miljard doorbreekt, en MEW bereikte ook een historisch hoogtepunt in het weekend. De huidige totale marktwaarde van kattenmeme-munten bedraagt $2,6 miljard, en de huidige totale marktwaarde van hondenmeme-munten bedraagt $39,2 miljard.</p>
<h3 id="h3-Samenvatting905775"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h3><p>Over het geheel genomen is het marktsentiment in een korte periode verschoven van angst naar hysterie, voornamelijk gedreven door de sterke stijging van mainstream valuta’s zoals BTC en ETH. Op macro-economisch gebied lijkt de cryptomarkt onafhankelijk te zijn gedreven, ondanks de slechte prestaties van technologieaandelen, vooral door de aankomende Bitcoin-conferentie en de mogelijke deelname van Musk. Ondertussen hebben Meme-munten in het Solana-ecosysteem het ook goed gedaan en zijn ze een van de markt-hotspots geworden.</p>
<p>Beleggers moeten aankomende grote conferenties en ETF-noteringen in de gaten houden, die mogelijk een aanzienlijke invloed hebben op het marktsentiment en de prijstrends. Ondertussen moet aandacht worden besteed aan het korte termijn neerwaartse risico van oververhitting van de markt.</p>
<h2 id="h2-Macro20Wereldwijde20technische20storing20Wall20Street20sluiting20Na20het20vertrek20van20Biden20staan20Aziatische20aandelenmarkten20onder20druk35659"><a name="Macro: Wereldwijde technische storing, Wall Street sluiting; Na het vertrek van Biden staan Aziatische aandelenmarkten onder druk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wereldwijde technische storing, Wall Street sluiting; Na het vertrek van Biden staan Aziatische aandelenmarkten onder druk</h2><p>Op 19 juli daalde de Amerikaanse aandelenmarkt op vrijdag verder, doordat de marktonzekerheid toenam als gevolg van de voortdurende chaos veroorzaakt door wereldwijde technologische storingen. De technische problemen van het cybersecuritybedrijf Crowdstrike hebben verstoringen veroorzaakt in meerdere sectoren, waaronder luchtvaart, bankwezen en gezondheidszorg, wat heeft geleid tot het instorten van het Windows-besturingssysteem van Microsoft. Hoewel kwetsbaarheden zijn ontdekt en verholpen, zijn sommige diensten nog steeds beïnvloed.</p>
<p>De specifieke drie belangrijkste indices: de Dow Jones Industrial Average daalde met 0,93%, de Standard&amp;Poor’s Index daalde met 0,71%, en de Nasdaq Index daalde met 0,81%.</p>
<p>Vanuit een wekelijks perspectief hebben zowel de Nasdaq- als de S&amp;P 500-indexen hun slechtste weekprestatie sinds april geregistreerd, terwijl de Dow Jones-index uiteindelijk geen daling wist te ontlopen na eerder deze week een historisch hoogtepunt te hebben bereikt.</p>
<p>Op 22 juli openden Aziatische aandelenmarkten lager op maandag, omdat de centrale bank van China onverwacht de rente verlaagde maar er niet in slaagde het marktsentiment te stimuleren. Tegelijkertijd versterkten de futures op Wall Street nadat de Amerikaanse president Joe Biden zijn terugtrekking uit de race aankondigde. De People’s Bank of China heeft de korte rente met tien basispunten verlaagd om de langetermijnkosten en obligatierendementen te verlagen. Eerder publiceerde Peking een beleidsdocument waarin het economische plan werd uiteengezet.</p>
<p>De MSCI Asia Pacific aandelenindex daalde met 1,0%, de Nikkei-index in Japan daalde met 1,1%, de referentie-index in Zuid-Korea daalde met 1,5% en de aandelenmarkt van Taiwan daalde met 2,4%.</p>
<p>Deze week zullen meerdere belangrijke economische gegevens worden vrijgegeven en de Federal Reserve zal vrijdag zijn langverwachte inflatie-indicator vrijgeven, waarmee de handel van deze week wordt afgesloten. Er wordt verwacht dat de kernindex van de persoonlijke consumptie-uitgaven in juni met 0,1% zal stijgen, waarbij het jaarlijkse percentage iets daalt naar 2,5%. De markt verwacht dat dit de basis zal leggen voor een renteverlaging in september, waarbij de futures-prijzen een kans van 97% laten zien op een renteverlaging in september. Bovendien wordt verwacht dat het BBP-groeipercentage in het tweede kwartaal zal stijgen van 1,4% in het eerste kwartaal naar een geannualiseerd groeipercentage van 1,9%.</p>
<p>Op het gebied van grondstoffen zijn de olieprijzen door geopolitieke factoren licht gestegen. Er is geen vooruitgang geboekt in de overeenkomst over het staakt-het-vuren in Gaza vanwege het intense gevecht tussen het Israëlische leger en Palestijnse militanten in Rafa. Brent ruwe olie steeg met 22 cent naar $82,85 per vat, terwijl Amerikaanse ruwe olie met 36 cent steeg naar $80,49 per vat.</p>
<p>Volgens een rapport van Invesco is geopolitieke concurrentie de grootste zorg geworden voor beleggers, zelfs groter dan inflatie. Dit heeft geleid tot een voorkeur voor veilige haven activa zoals goud. De prijs van goud blijft op $2.407 per ounce, dicht bij het historische hoogtepunt van $2.483,60 dat vorige week werd bereikt.</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 visie van de onderzoeker en vormt geen enkele beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>