RGFnZWxpamtzIG5pZXV3cyB8IFNFQyB2ZXJ3ZXJwdCBFVEYncywgbGlxdWlkYXRpZXMgbmVtZW4gdG9lLCBBenVraSBORlQtdmVybmlldXdpbmc7IFdlcmVsZHdpamRlIGFhbmRlbGVuIHN0aWpnZW4gdm9vcnppY2h0aWc=

2023-07-03, 01:21

<p><img src="https://gimg2.gateimg.com/image/article/16883467830703.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Crypto20Volatiliteit20Regelgevende20Ontwikkelingen20en20NFT20Uitdagingen719677"><a name="Crypto Dagelijkse Samenvatting: Crypto Volatiliteit, Regelgevende Ontwikkelingen en NFT Uitdagingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Crypto Volatiliteit, Regelgevende Ontwikkelingen en NFT Uitdagingen</h2><p>De cryptocurrency markt heeft een relatief rustig weekend gehad, waarbij <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (BTC) en Ether (ETH) marginale winsten zagen. Echter,<br><strong>Vrijdag bracht aanzienlijke volatiliteit en een golf van liquidaties met zich mee, ter waarde van $216 miljoen</strong> Dit werd in gang gezet door het nieuws dat de Amerikaanse Securities and Exchange Commission (SEC) aanvragen voor spot heeft afgewezen. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> exchange-traded funds, wat leidt tot een snelle reactie van de markt.</p>
<p>Bitcoin steeg aanvankelijk boven de $31.200, maar daalde snel naar slechts $29.470. De daaropvolgende stabilisatie rond $30.000 maakte enige herstel mogelijk. Helaas,<br><strong>De volatiliteit resulteerde in de liquidatie van meer dan 68.000 handelaren, waarbij longposities goed waren voor $116 miljoen aan verliezen en shortposities voor $100 miljoen.</strong>.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688347126Untitled0703 1.png" alt=""><br>Korte positie liquidatie steeg op vrijdag - Gegevens per Coinglass</p>
<p>Bitcoin-handelaren werden het zwaarst getroffen, gevolgd door Ether-handelaren. <a href="/price/bitcoin-cash-bch" rel="nofollow noopener noreferrer" target="_blank">Bitcoin Cash</a>(BCH) heeft ook bijgedragen aan de liquidaties met $22 miljoen verlies. Bybit exchange heeft de grootste enkele liquidatieorder gezien, waarbij een BTC-USD positie ter waarde van $4,57 miljoen betrokken was.</p>
<p>In regulatienieuws heeft de BZX Exchange van Cboe Coinbase gekozen als de markt voor zijn surveillance-delingsovereenkomst bij het opnieuw indienen van zijn aanvragen voor spot bitcoin exchange-traded funds (ETF’s). Opvallend is dat andere grote spelers zoals Fidelity, WisdomTree, VanEck, ARK Invest, Galaxy/Invesco en BlackRock ook aanvragen hebben ingediend voor spot bitcoin ETF’s, in samenwerking met Cboe of Nasdaq.<br><strong>De SEC had de oorspronkelijke aanvragen eerder als ‘ontoereikend’ beschouwd vanwege het gebrek aan specificatie met betrekking tot surveillance-delingsovereenkomsten. Door Coinbase te noemen, streeft Cboe ernaar aanvullende toegang tot gegevens over spot Bitcoin-transacties op de beurs te bieden.</strong> De formele erkenning van Coinbase door de SEC als een belangrijke gereguleerde markt voor bitcoin blijft echter onzeker.</p>
<p>In Zuid-Korea is een op zichzelf staande digitale activa-wet aangenomen met als doel de bescherming van investeerders te verbeteren. De wetgeving ter bescherming van de gebruikers van virtuele activa consolideert 19 crypto-gerelateerde wetten en stelt definities vast voor digitale activa, terwijl straffen worden opgelegd voor overtredingen zoals marktmanipulatie en oneerlijke handelspraktijken.<br><strong>De Financial Services Commission zal toezicht houden op crypto-operators en activabewaarders, waarbij de Bank of Korea gemachtigd is om dergelijke platforms te onderzoeken. De wetgeving vereist ook verzekeringsdekking, reservefondsen en een goede registratie van gegevens.</strong> Deze stap komt na de ineenstorting van tokens gecreëerd door Do Kwon, die een $2 biljoen crypto-marktcrash heeft veroorzaakt. Ondanks de daling van het maandelijkse handelsvolume in spot crypto, staat Zuid-Korea bekend om periodieke manieën rond virtuele activa.</p>
<p>Wat betreft het rijk van niet-fungibele tokens (NFT’s), kreeg het blue-chipmerk Azuki te maken met terugslag en technische problemen na zijn recente “Elementals” NFT-munt. De collectie was prompt uitverkocht en genereerde $ 38 miljoen aan inkomsten. Verzamelaars uitten echter hun frustratie vanwege technische problemen tijdens het muntproces en vermeende overeenkomsten tussen het nieuwe kunstwerk en de originele collectie, wat leidde tot een daling van de bodemprijs met 44%. In reactie hierop<br><strong>Azuki hield een besloten gesprek met zijn gemeenschap om zorgen aan te pakken en zijn plannen voor de toekomst uiteen te zetten. Het team erkende hun fouten en gaf te kennen dat ze van plan zijn de Elementals-artwork bij te werken om het verder te onderscheiden van de oorspronkelijke collectie.</strong>.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688347184Untitled0703 2.png" alt=""><br>Azuki Elementals Voorgestelde Wijzigingen Eerste Versie - Met dank aan Twitter-gebruiker Arcanic</p>
<p>Azuki onthulde ook plannen voor een animeserie met hun karakteruniversum, waarin Web3-technologieën en interactieve elementen met NFT’s worden geïntegreerd. In de communitycall werd gesproken over mogelijke beloningen voor langetermijnhouders en degenen met zeldzame kenmerken.</p>
<p>Ondanks de uitdagingen waar de gemeenschapsleden voor staan, blijven ze optimistisch over de toekomst van Azuki en het vermogen om het vertrouwen te herwinnen. Op dit moment staat de minimumprijs van Azuki Elementals op 1,29 ETH, met een handelsvolume van ongeveer 11.930 ETH, volgens OpenSea. De oorspronkelijke Azuki-collectie heeft een minimumprijs van ongeveer 8,19 ETH, met een handelsvolume van meer dan 596.900 ETH.</p>
<h2 id="h2-Bitcoin20BTC2030626200042020Neutrale20vooruitzichten449804"><a name="Bitcoin (BTC) $30.626 (+0,04%) - Neutrale vooruitzichten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC) $30.626 (+0,04%) - Neutrale vooruitzichten</h2><p><img src="https://gimg2.gateimg.com/image/article/1688347145Untitled0703 3.png" alt=""></p>
<p><img src="https://gimg2.gateimg.com/image/article/1688347155Untitled0703 4.png" alt=""></p>
<p><strong>Overzicht:</strong></p>
<ul>
<li><strong><em>Dichtstbijzijnde dagelijkse ondersteuningszone: 30025 - 29475</em></strong></li><li><strong><em>Dichtstbijzijnde dagelijkse weerstandszone: 30690 - 31015</em></strong></li><li><strong><em>Sleutelniveau: 28420 (Hoogste wekelijkse niveau tussen 21-28 december 2020)</em></strong></li></ul>
<p><strong>Dagelijkse weerstandszones</strong></p>
<ol>
<li>30690 - 31015</li><li>31530 - 32255</li><li>33100 - 33600</li></ol>
<p><strong>Zones voor dagelijkse ondersteuning</strong></p>
<ol>
<li>30025 - 29475</li><li>29095 - 28420</li><li>27970 - 27265</li></ol>
<h2 id="h2-Macro20Wereldwijde20aandelen20stijgen20maar20hebzucht20getemperd20door20voorzichtigheid79763"><a name="Macro: Wereldwijde aandelen stijgen, maar hebzucht getemperd door voorzichtigheid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wereldwijde aandelen stijgen, maar hebzucht getemperd door voorzichtigheid</h2><p>Wereldwijde markten vertonen tekenen van positiviteit, aangezien Aziatische aandelen naar verwachting hoger zullen openen na een rally op Wall Street en aanwijzingen van afnemende inflatie in de VS. Futures-contracten voor aandelen in Japan, Australië en Hong Kong wijzen op vroege winsten, terwijl in de VS genoteerde Chinese bedrijven een vooruitgang van 1% hebben ervaren. Het positieve nieuws over de recordautoleveringen van Tesla in het tweede kwartaal zal naar verwachting ten goede komen aan de leveranciers in Azië.</p>
<p>De Nasdaq 100 en S&amp;P 500 presteerden sterk in de eerste helft van het jaar, waarbij Apple een belangrijke mijlpaal bereikte van een marktkapitalisatie van $3 biljoen. Handelaren winnen vertrouwen uit gegevens die een matiging van de inflatie laten zien, hoewel dit ten koste is gegaan van de groei. De activiteit op de obligatiemarkt bleef beperkt en belangrijke valuta’s bleven stabiel ten opzichte van de dollar. De olieprijzen kenden minimale veranderingen omdat de focus ligt op uitdagingen in de vraag en het complexe aanbodperspectief.</p>
<p>Beleggers worden gewaarschuwd om niet te hebzuchtig te worden, aangezien de wereldwijde aandelen losgekoppeld zijn van de verslechterende economische achtergrond, nadat ze al dubbelcijferige winsten hebben behaald in 2023.<br><strong>Sommige geldbeheerders waarschuwen voor een mogelijke verrassende neergang in de tweede helft van het jaar als gevolg van toenemende winstwaarschuwingen van bedrijven en havikachtige retoriek van centrale banken.</strong></p>
<p><img src="https://gimg2.gateimg.com/image/article/1688347295Untitled0703 5.png" alt=""></p>
<p>Stijgende rentetarieven en mogelijke spanningen op financiële markten zijn bijzonder zorgwekkend voor de rentegevoelige techsector.<br><strong>Hoewel historische gegevens suggereren dat aandelen hun winsten mogelijk niet volledig zullen terugdraaien, kan de combinatie van een laag handelsvolume en de seizoensgebonden zomerse stilte marktcorrecties versterken als handelaren besluiten hun bullish posities af te bouwen.</strong> Daarom wordt voor de tweede helft van het jaar voorzichtigheid en een conservatieve benadering aanbevolen.</p>
<p>In China duidt de benoeming van Pan Gongsheng door president Xi Jinping als de hoogste functionaris van de Communistische Partij bij de People’s Bank of China (PBOC) op een toewijding om de huidige aanpak te handhaven te midden van de voortdurende strijd van het land om economisch momentum terug te winnen.<br><strong>De benoeming van Pan suggereert een voortzetting van bescheiden renteverlagingen en gerichte leenmaatregelen.</strong> Terwijl er steeds meer oproepen zijn voor meer stimulering, blijven er zorgen bestaan over zwakke consumentenbestedingen en onroerend goed. De rol van de PBOC wordt hervormd onder Xi’s leiderschap, waarbij de zwakkere partijrang van Pan mogelijk de invloed van de bank op het nemen van economische beslissingen op hoog niveau vermindert. De uitdagingen van Pan omvatten het beheren van de yuan, het stabiliseren van de valuta en het navigeren door regulerende maatregelen op de vastgoedmarkt.</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 opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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 zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>