RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBFVEYgaW5zdHJvb20gdmFuIG1lZXIgZGFuICQxLDUgbWlsamFyZCBpbiBlZW4gd2VlaywgRElBIHN0aWpndCBtZXQgbWVlciBkYW4gNDAwJSBzaW5kcyBzZXB0ZW1iZXI=

2024-10-18, 04:25

<p><img src="https://gimg2.gateimg.com/image/article/172922534010.18.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETF20ontving20grote20netto20instroom20gedurende20420opeenvolgende20dagen20Worldcoin20is20gelanceerd20op20het20mainnet950468"><a name="Crypto Dagelijkse Samenvatting: BTC ETF ontving grote netto instroom gedurende 4 opeenvolgende dagen, Worldcoin is gelanceerd op het mainnet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF ontving grote netto instroom gedurende 4 opeenvolgende dagen, Worldcoin is gelanceerd op het mainnet</h2><p>Volgens gegevens van Farside Investor, de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Spot ETF’s hadden gisteren een netto instroom van $473 miljoen. BlackRock IBIT had een netto instroom van $311,7 miljoen en Ark ARKB had een netto instroom van $100 miljoen. Gisteren had de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF’s hadden een netto instroom van $48,03 miljoen. Daarvan had BlackRock ETHA een netto instroom van $23,7 miljoen.</p>
<p><strong>Worldcoin is omgedoopt tot World Network en heeft aangekondigd dat World Chain is gelanceerd op het mainnet</strong></p>
<p>Volgens The Block heeft Sam Altman’s ondersteunde Worldcoin officieel zijn naam gewijzigd in World Network (afgekort als World), en is zijn Layer2-netwerk World Chain mainnet gelanceerd. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, Alchemie, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, Safe, Dune en Etherscan zullen de release van deze blockchain ondersteunen. De blockchain is gebouwd met behulp van OP Stack, en World Network stelt dat gebruikerstransacties ongeveer 44% van de activiteit op OP Mainnet uitmaken, waardoor het de grootste toepassing op het netwerk is.</p>
<p><strong>SEC heeft officieel beroep aangetekend tegen de uitspraak in de Ripple-zaak</strong></p>
<p>De Amerikaanse Securities and Exchange Commission (SEC) heeft officieel beroep aangetekend tegen de <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> uitspraak gedaan door rechter Analisa Torres. Op donderdag heeft de regelgevende instantie Formulier C ingediend bij het Amerikaanse Tweede Circuit Hof van Beroep. Dit heeft opnieuw een juridisch geschil veroorzaakt over de vraag of <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> verkopen op cryptohandelplatforms voldoen aan effectenvereisten. Toezichthoudende autoriteiten hebben kritische aspecten van de gerechtelijke uitspraak in twijfel getrokken, waaronder de vrijspraak van Ripple-functionarissen en niet-geldelijke XRP-distributies. De uitkomst van deze zaak kan aanzienlijke gevolgen hebben voor toekomstige cryptoregulatie.</p>
<p>Op 3 oktober gaat de Amerikaanse SEC in beroep tegen de eerdere uitspraak van het Amerikaanse Hof van Beroep voor het Tweede Circuit met betrekking tot de <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> betalingsbedrijf Ripple, volgens documenten van woensdag. De woordvoerder van de SEC verklaarde: ‘Wij zijn van mening dat de uitspraak van de rechtbank in de Ripple-zaak in strijd is met tientallen jaren van jurisprudentie van het Hooggerechtshof en effectenwetten, en we kijken ernaar uit om onze argumenten te presenteren in het Tweede Circuit.’</p>
<p>Eerder, op 7 augustus, b de rechter Ripple om een civiele boete van $125 miljoen te betalen, ver onder de aanvankelijk door de SEC gevraagde boete van $2 miljard. De uitspraak keurde ook gedeeltelijk goed en wees de voorlopige herstelmaatregel van de SEC af met betrekking tot de verkoop van XRP-tokens door Ripple.</p>
<p><strong>Naarmate de Amerikaanse verkiezingen naderen, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> gaat een fase van hoge volatiliteit in</strong></p>
<p>QCP publiceerde een dagelijks rapport waarin staat dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> gisteravond met 2,20% steeg, kortstondig terugstuiterend naar de $68.000 mark ondersteund door sterke spotvraag, en vervolgens stabiliserend in het bereik van $67.000. Tijdens de handelssessie van de VS werden er veel langetermijnopties met een vervaldatum van 28 maart op de markt gekocht, met 600 contracten met een uitoefenprijs van $120.000.</p>
<p>Dit geeft aan dat optimistische langetermijnkopers zijn teruggekeerd in deze opleving. Gisteren zijn de Bitcoin ETF’s met $ 456 miljoen gestegen, waarmee vier dagen van nettostromen worden voortgezet. Deze sterke en voortdurend groeiende kapitaalinstromen kunnen een belangrijke indicator zijn dat BTC opnieuw zijn historische hoogtepunt van $ 73.790 zal bereiken.</p>
<p>Hoewel de Amerikaanse verkiezingen de volgende belangrijke katalysator zijn voor Bitcoin en cryptocurrency, is er nog steeds onzekerheid op de markt over de post-verkiezingstrend van Bitcoin. De handelsprijs van opties die de vervaldatum van de verkiezing benaderen, ligt 10% hoger dan andere vervaldatumopties. Aangezien mensen aandacht besteden aan de verkiezing, zullen eventuele veranderingen in peilingen of verhalen van de campagne van kandidaten worden versterkt in spotprijzen.</p>
<h2 id="h2-Markttrends20DIA20steeg20met204020BTC20spot20ETF20zag20sterke20instroom617382"><a name="Markttrends: DIA steeg met 40%, BTC spot ETF zag sterke instroom" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: DIA steeg met 40%, BTC spot ETF zag sterke instroom</h2><h3 id="h3-Markt20Hotspots375746"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>DOGE steeg en op het nieuwsoppervlak tweette Musk over D.O.G.E (Department of Government Efficiency), wat leidde tot marktkapitaaljacht. De Amerikaanse presidentsverkiezing nadert en Trump, gesteund door Musk, heeft momenteel een hoge winstkans. De markt heeft hoge verwachtingen van een Amerikaanse president die bullish is over cryptocurrency;</p>
<p>Het DIA-protocol voor orakelmachines is met 40% gestegen, waarbij DIA-prijzen sinds september met meer dan 400% zijn gestegen, en andere orakelmachines zoals UMA zijn ook gestegen. De huidige circulerende marktkapitalisatie van DIA is $120 miljoen, wat een zekere opwaartse potentie heeft in vergelijking met de marktwaarde van het toonaangevende protocol. <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a>, wat $7 miljard is;</p>
<p>Politieke concept memes uit de VS zoals FIGHT en FEARNOT zijn gestegen, mede dankzij het nieuws over Trump’s leidende positie in de Amerikaanse presidentsverkiezingen, en Trump-gerelateerde politieke memes zijn over het algemeen gestegen.</p>
<h3 id="h3-Mainstream20Munten696383"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC heeft $68.000 overschreden en deze week blijven BTC-spot-ETF’s sterke instroom van meer dan $1,5 miljard hebben, waarbij de markt over het algemeen optimistisch is;</p>
<p>ETH steeg iets mee met de markt, maar de algehele prestaties zijn nog steeds relatief traag in vergelijking met andere openbare layer1 blockchains;</p>
<p>Altcoins vielen over het algemeen, en vroege sterke munten kwamen in de aanpassingszone, waarbij de markt wachtte op nieuwe toonaangevende tokens.</p>
<h2 id="h2-Macroeconomie20Amerikaanse20aandelen20schommelden20Buffett20haalde20369920miljoen20uit20de20markt20wat20van20invloed20was20op20het20marktsentiment3881"><a name="Macroeconomie: Amerikaanse aandelen schommelden, Buffett haalde $369,9 miljoen uit de markt, wat van invloed was op het marktsentiment" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: Amerikaanse aandelen schommelden, Buffett haalde $369,9 miljoen uit de markt, wat van invloed was op het marktsentiment</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt schommelden, waarbij de S&amp;P 500-index met 0,02% daalde tot 5.841,47 punten; De Dow Jones Industrial Average steeg met 0,37% tot 43.239,05 punten; De Nasdaq-index steeg met 0,04% tot 18.373,61 punten. Het referentiepunt van de 10-jaars Treasury-opbrengst is 4,09%, terwijl de 2-jaars Treasury-opbrengst, die het meest gevoelig is voor de beleidsrente van de Federal Reserve, 3,96% bedraagt.</p>
<p>JPMorgan Chase verklaarde dat de Amerikaanse aandelenmarkt begonnen is met het verwerken van de overwinning van de Republikeinse kandidaat Trump, en zelfs van de volledige overwinning van de Republikeinse Partij. Marktstrateeg Nikolaos Panigirtzoglou zei dat de recente stijging van Amerikaanse aandelen naar historische hoogtepunten, vooral de uitstekende prestaties van Amerikaanse bankaandelen, aangeeft dat beleggers wedden op de overwinning van voormalig president Trump bij de verkiezingen van november en een vergelijkbaar patroon volgen als in 2016. Vanwege de verwachting dat de Trump-regering minder toezicht zal houden op de bankregulering dan tijdens de regering-Biden, zijn de aandelenprijzen van de Amerikaanse banksector hersteld. De SPDR S&amp;P Regional Banking ETF (KRE) is deze maand bijna 6% gestegen, waarbij financiële aandelen de best presterende sector zijn in de S&amp;P 500-index deze maand. Panigirtzoglou verklaarde dat de recente trends in banken, de Amerikaanse dollar en obligatierendementen matig zijn in vergelijking met 2016, en dat de kans dat Trump wint aanzienlijk is toegenomen, wat naar verwachting uiteindelijk de prijzen van Bitcoin en goud zal ondersteunen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Icing</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingssuggestie. Alle beleggingen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>