RGFnZWxpamtzIG5pZXV3cyB8IEFtZXJpa2FhbnNlIGFhbmRlbGVuIHN0aWpnZW4gYWxzIGdldm9sZyB2YW4gZmluYW5jacOrbGUgdmVyc2NodWl2aW5nLCBCaXRjb2luIGhlcnN0ZWx0IHRlIG1pZGRlbiB2YW4ganVyaWRpc2NoZSBnZXZlY2h0ZW4gZW4gb3B0aW1pc3Rpc2NoZSB1cGdyYWRl

2023-06-07, 01:43

<p><img src="https://gimg2.gateimg.com/image/article/16861021200607.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Bitcoin20leidt20Cryptoherstel20als20optimisme20Bedrockupgrade20voltooit20en20Coinbase20geconfronteerd20wordt20met20een20rechtszaak20van20de20SEC52116"><a name="Crypto Daily Digest: Bitcoin leidt Crypto-herstel als optimisme Bedrock-upgrade voltooit en Coinbase geconfronteerd wordt met een rechtszaak van de SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> leidt Crypto-herstel als optimisme Bedrock-upgrade voltooit en Coinbase geconfronteerd wordt met een rechtszaak van de SEC</h2><p>Cryptocurrency-prijzen kenden op dinsdag een opmerkelijk herstel, met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>(BTC) neemt de leiding na een uitverkoop die werd veroorzaakt door de rechtszaak van de Amerikaanse Securities and Exchange Commission (SEC) tegen Binance. BTC steeg met 5,1%, waardoor de $27.000 grens werd overschreden. Terwijl er een tweede rechtszaak werd aangespannen tegen concurrent Coinbase, vertoonde ook de bredere cryptomarkt tekenen van herstel, zij het in mindere mate. Ether (ETH) steeg met 4,1%, en andere tokens zoals ADA, SOL, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, en MATIC vertoonden verschillende bewegingen. Interessant genoeg vermeldden de SEC-documenten BTC en ETH niet, wat aangeeft dat deze toonaangevende cryptocurrencies als grondstoffen worden beschouwd. Marktanalisten suggereren dat de aanpak van altcoins uiteindelijk ten goede kan komen aan bitcoin, aangezien investeerders hun focus en investeringen kunnen verleggen naar de meer gevestigde token.</p>
<p>In een andere belangrijke ontwikkeling, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, een laag 2 schaaloplossing voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, heeft met succes de Bedrock-upgrade voltooid, waardoor de blockchain een stap dichter bij zijn streven staat om een ​​’Superchain’ te worden, bestaande uit meerdere interoperabele mini-blockchains. De upgrade, geïmplementeerd als een harde vork, had tot doel de algehele functionaliteit van de keten te verbeteren. Opmerkelijke verbeteringen zijn onder andere een vermindering van de bevestigingstijd van stortingen van 10 minuten naar slechts 1 minuut en een afname van 40% van de gasvergoedingen. De software-upgrade vond plaats op dinsdag, waarbij externe infrastructuurelementen geleidelijk weer online kwamen. De <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> Foundation heeft aangekondigd dat het openbare eindpunt binnenkort operationeel zal zijn.</p>
<p>Na de voltooiing van de Bedrock-upgrade kende de inheemse token van Optimism, $OP, een opmerkelijke stijging van 10% in waarde in de afgelopen 24 uur.</p>
<p>Echter, te midden van de positieve ontwikkelingen, bevindt Coinbase, een van de toonaangevende cryptocurrency-beurzen, zich verwikkeld in een juridische strijd met de SEC. De toezichthoudende instantie heeft een rechtszaak aangespannen tegen Coinbase en beschuldigt de beurs ervan zich niet te hebben geregistreerd als makelaar, beurs of clearingbedrijf. Daarnaast beweert de SEC dat het stakingsprogramma van Coinbase in strijd is met effectenwetten. Deze rechtszaak volgt op een soortgelijke actie tegen Binance en markeert een escalatie in de inspanningen van de SEC om de cryptobranche te reguleren. De situatie is met name uitdagend voor Coinbase, aangezien het bedrijf sterk afhankelijk is van de Amerikaanse markt en daardoor kwetsbaar is voor de mogelijke gevolgen van de rechtszaak.</p>
<p>Brian Armstrong, CEO van Coinbase, ging naar Twitter om zijn standpunt te uiten, waarbij hij het bedrijf verdedigde en verklaarde dat hij trots is om de industrie in de rechtbank te vertegenwoordigen. Armstrong benadrukte dat de SEC eerder het bedrijf van Coinbase had beoordeeld en de overgang naar een openbaar bedrijf had goedgekeurd. Juridische experts betogen echter dat naar de beurs gaan niet impliceert dat de bedrijfsactiviteiten of wettigheid van een bedrijf zijn goedgekeurd. Naar de beurs gaan betekent eenvoudigweg dat de SEC het aanbodprospectus heeft beoordeeld en heeft gecontroleerd of er aan de indieningsvereisten is voldaan.</p>
<p>De uitkomst van de juridische strijd tussen Coinbase en de SEC blijft onzeker, met mogelijke verstrekkende gevolgen voor zowel de beurs als de bredere crypto-industrie. Mocht de SEC.</p>
<h2 id="h2-Bitcoin20BTC2027276200182020Neutrale20Outlook616875"><a name="Bitcoin (BTC) $27,276 (+0.18%) - Neutrale Outlook" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC) $27,276 (+0.18%) - Neutrale Outlook</h2><p><img src="https://gimg2.gateimg.com/image/article/1686102049Untitled0607 1.png" alt=""></p>
<p><img src="https://gimg2.gateimg.com/image/article/1686102060Untitled0607 2.png" alt=""></p>
<p>Het plotselinge herstel van BTC was duidelijk in de vorm van een overspoelende kaars, een patroon dat doorgaans een voortzetting van een opwaartse trend suggereert. Zoals vermeld in de analyse van gisteren, suggereert het wekelijkse tijdsbestek echter dat de BUEC-fase (Back Up Against Creek) mogelijk pas voltooid is als BTC het wekelijkse niveau van 24270 bereikt. Desondanks heeft de recente vooruitgang in de prijs van BTC mogelijk enig vertrouwen gewekt bij handelaren. Daarom is het van cruciaal belang om het handelsvolume nauwlettend in de gaten te houden om te bepalen of de bullish trend zal aanhouden.</p>
<h2 id="h2-Macro20Financile20verschuiving20zorgt20voor20hoop20op20een20bredere20marktrally20naarmate20Amerikaanse20aandelen20stijgen724076"><a name="Macro: Financiële verschuiving zorgt voor hoop op een bredere marktrally naarmate Amerikaanse aandelen stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Financiële verschuiving zorgt voor hoop op een bredere marktrally naarmate Amerikaanse aandelen stijgen</h2><p>Aziatische aandelentermijncontracten gaven woensdag een positieve trend in de regio aan, gedreven door meerdere factoren, waaronder tekenen van stimulans in China, positieve geopolitieke ontwikkelingen en kracht in Amerikaanse aandelen. De dag ervoor hadden Amerikaanse aandelen winsten geboekt, aangezwengeld door een verschuiving naar financiële aandelen, wat hoop op een bredere marktrally buiten de technologiesector aanwakkerde.</p>
<p>De S&amp;P 500 steeg iets, ondanks de daling van het aandeel Apple, wat de algehele tech-rally temperde. Regionale banken boekten echter opmerkelijke winsten, met de KBW Regional Bank-index die met 5,4% steeg en de Russell 2000 met 2,7% steeg. De outperformance van small-cap aandelen ten opzichte van de tech-zware Nasdaq 100 trok ook de aandacht, wat een significante gebeurtenis markeert die sinds november 2020 niet meer is gezien.</p>
<p>Beleggers merkten ook de rally van 3,8% van de in de VS genoteerde Chinese bedrijven op, ondersteund door twee belangrijke ontwikkelingen. Ten eerste het plan van de Amerikaanse minister van Buitenlandse Zaken Antony Blinken om China in de komende weken te bezoeken, wat wijst op een mogelijke ontdooiing van de betrekkingen tussen de VS en China. Ten tweede zouden de Chinese autoriteiten naar verluidt aan grote banken hebben gevraagd om voor de tweede keer in minder dan een jaar de depositorente te verlagen, wat wijst op inspanningen om de economie te stimuleren.</p>
<p>Vooruitkijkend naar woensdag, gaven futures voor Japanse en Australische aandelen lichte winsten aan, terwijl Hong Kong futures met 1,9% stegen. Handelaren hielden nauwlettend in de gaten of er mogelijke overheidsinterventies waren om de trage economische groei van China en de kwakkelende aandelen te ondersteunen. Zelfs Bloomberg Economics verwachtte dat de People’s Bank of China mogelijk al medio juni haar éénjarige referentierente zou verlagen.</p>
<p>Terwijl de Amerikaanse markten veerkracht toonden, met de S&amp;P 500 op de rand van een bullmarkt, heerste er voorzichtigheid op de wereldwijde markten. Sommige analisten vroegen zich af of de aandelenprijzen te snel waren gestegen, gedreven door overmatig enthousiasme over de vooruitzichten van kunstmatige intelligentie.</p>
<p>De wereldeconomie werd geconfronteerd met onzekerheden als gevolg van zorgen over renteverhogingen die van invloed waren op de economische activiteit en kwetsbaarheden in landen met een lager inkomen, zoals benadrukt in een rapport van de Wereldbank. Handelaren verwachtten echter steeds meer dat de Federal Reserve de rentetarieven tijdens haar bijeenkomst in juni zou handhaven, gezien de aanhoudend hoge Amerikaanse inflatie. Richard H. Clarida, voormalig vicevoorzitter van de Federal Reserve, suggereerde ook dat renteverlagingen onwaarschijnlijk waren tot 2024.</p>
<p>Opmerkelijk genoeg leek de prestatie van aandelen minder waarschijnlijk te worden beïnvloed door de behoeften van het Ministerie van Financiën na de opschorting van het schuldenplafond, volgens experts. Dit verlichtte de zorgen dat een verhoogde uitgifte geld zou afleiden van risico-activa.</p>
<p>In valutamarkten handelden belangrijke valuta’s binnen nauwe marges aan het begin van de sessie van woensdag. Ondertussen ervoeren overheidsobligatierendementen in Australië en Nieuw-Zeeland marginale stijgingen.</p>
<p>Grondstoffen vertoonden gemengde bewegingen, waarbij goud stabiel bleef, terwijl olie iets terugdeinsde van zijn winsten op dinsdag, na het nieuws over de productieverlaging van Saoedi-Arabië. Tarweprijzen stegen nadat Oekraïne meldde dat Russische troepen een reusachtige dam in het zuiden van het land hadden opgeblazen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Peter L. </strong>, Gate.io Onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te publiceren mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen bij schending van het auteursrecht.<br></div><p></p><br></div></div></div>