RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0by1tYXJrdGVuIG9wdGltaXN0aXNjaCBuYSBleHBsb3NpZXZlIGdyb2VpIHZhbiBkZXJpdmF0ZW4sIHBvc2l0aWV2ZSBDRU8gdmFuIEJsYWNrUm9jazsgSXNyYcOrbGlzY2ggcGFybGVtZW50IHZlcmhvb2d0IGJlbGFzdGluZyBvcCBjcnlwdG8sIG5lZ2F0aWV2ZSBpbXBhY3QgdmFuIEZlZA==

2023-07-06, 02:10

<p><img src="https://gimg2.gateimg.com/image/article/16886089990706.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Bitcoin20Stabiel20terwijl20CEO20van20BlackRock20Crypto20Revolutie20Verwelkomt20en20Isralisch20Parlement20Bevordert20Belastingvoordelen20voor20Crypto694276"><a name="Crypto Dagelijks Overzicht: Bitcoin Stabiel terwijl CEO van BlackRock Crypto Revolutie Verwelkomt en Israëlisch Parlement Bevordert Belastingvoordelen voor Crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Stabiel terwijl CEO van BlackRock Crypto Revolutie Verwelkomt en Israëlisch Parlement Bevordert Belastingvoordelen voor Crypto</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> bleef stabiel op $30.000 tijdens de vroege handel op woensdag en toonde veerkracht ondanks 12 opeenvolgende dagen van range-bound trading na een significante prijsstijging van 22% medio juni. Echter,<br><strong><a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> heerste op de derivatenmarkten, met futures open interest van meer dan $12 miljard en positieve financieringstarieven die al 29 opeenvolgende dagen aanhouden.</strong></p>
<p><img src="https://gimg2.gateimg.com/image/article/1688609067Untitled0706 1.png" alt=""><br>BTC futures open interest bereikte een hoogtepunt van 1 jaar - Data per Coinglass</p>
<p>Ondanks een tijdelijke dip in de prijs van BTC en de Relative Strength Index (RSI) die onder de 30 daalde tijdens de opening van de Amerikaanse markt, bleef het algehele sentiment onder handelaren bullish. Korte termijn handelaren grepen de kans om BTC te kopen tegen een gunstige waardering, terwijl langetermijnbeleggers de RSI op de dagelijkse grafiek ueerden, waar deze op 62 stond.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688609122Untitled0706 2.png" alt=""><br>BTC dagelijkse RSI daalde naar 62 - Gegevens per Tradingview</p>
<p>In een andere ontwikkeling, <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a>, een prominente crypto-uitwisseling, heeft een belangrijke stap gezet naar decentralisatie met de lancering van zijn openbare testnet voor de aankomende versie “v4”. Momenteel actief op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en StarkEx-netwerken, <a href="/price/dydx-dydx" target="_blank" class="blog_inner_link">dYdX</a> heeft een gecentraliseerd orderboek en matchingsengine. De nieuwe iteratie heeft echter tot doel deze gecentraliseerde onderdelen te elimineren en volledige decentralisatie te bereiken zonder te vertrouwen op geautomatiseerde market makers zoals <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> Het testnet stelt gebruikers in staat om te experimenteren met virtuele transacties en basisuitwisselingsfuncties, waardoor de weg wordt vrijgemaakt voor toekomstige verbindingen tussen netwerken. Na afloop van de testnetfase,<br><strong>dYdX van plan om stablecoins en Cosmos Inter-Blockchain Communication support te integreren, wat het laatste mijlpaal is voor de officiële lancering van v4.</strong></p>
<p>Ondertussen deelde BlackRock CEO Larry Fink, die eerder sceptisch stond tegenover cryptocurrencies, een positieve kijk op hun potentieel om het financiële systeem te revolutioneren. Fink benadrukte het belang van tokenisatie en merkte op dat het de financiële sector zou kunnen transformeren. Hij noemde specifiek Bitcoin als een internationaal alternatief activum dat zou kunnen dienen als een hedge tegen inflatie en valutaduatie.<br><strong>De iShares-afdeling van BlackRock heeft onlangs een aanvraag ingediend voor een spot Bitcoin exchange-traded fund, wat wijst op de groeiende interesse van het bedrijf in de cryptoruimte. Fink kon echter geen geschatte tijdlijn geven voor goedkeuring door regelgevende instanties.</strong> Ondanks zijn optimistische houding bleef de prijs van Bitcoin relatief stabiel, net onder de $30.500.</p>
<p>In een ander deel van de wereld heeft het Israëlische parlement, bekend als de Knesset, vooruitgang geboekt bij het uitbreiden van de belastingvoordelen die momenteel beschikbaar zijn voor hightechbedrijven naar de cryptosector. Het wetsvoorstel, dat een voorlopige lezing heeft doorstaan, heeft tot doel buitenlandse ingezetenen vrij te stellen van vermogenswinstbelasting op de verkoop van digitale valuta. Bovendien wil het het belastingtarief op crypto-opties voor werknemers, vergelijkbaar met aandelenopties, verlagen van 50% naar ongeveer 25%. Het wetsvoorstel geniet de steun van de coalitieregering onder leiding van premier Benjamin Netanyahu, die aansluit bij hun economisch beleid dat gericht is op het aantrekken van investeerders en bedrijven naar Israël. Deze stap weerspiegelt de voortdurende inspanningen van Israël om de crypto-industrie te integreren en te reguleren, met voorgestelde richtlijnen voor de behandeling van digitale activa en stablecoin-vereisten. Het omarmen van cryptocurrencies wordt gezien als een kans voor Israël om te concurreren met wereldwijde financiële centra zoals Londen en New York.</p>
<h2 id="h2-Bitcoin20BTC2030626200042020Neutrale20Outlook828436"><a name="Bitcoin (BTC) $30,626 (+0.04%) - Neutrale Outlook" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC) $30,626 (+0.04%) - Neutrale Outlook</h2><p><img src="https://gimg2.gateimg.com/image/article/1688609247Untitled0706 4.png" alt=""></p>
<p><img src="https://gimg2.gateimg.com/image/article/1688609256Untitled0706 5.png" alt=""></p>
<p>Voortbouwend op onze vorige analyse, suggereert de afname van het handelsvolume bij de daling van de prijs een afname van de vraag naar Bitcoin (BTC) op het huidige prijsniveau. Desalniettemin is het mogelijk dat we nog één laatste opwaartse beweging zullen waarnemen, waardoor de prijs richting de 4-uurs Uptrust Action (UA) zone van 31257 tot 31377 wordt geduwd. Deze stijging zou kunnen dienen als een herstest voordat we verwachten dat de prijs ons geprojecteerde doel van 29300 zal bereiken.</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>Niveau sleutel: 28420 (Wekelijkse hoogte 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>Dagelijkse ondersteuningszones</strong></p>
<ol>
<li>30025 - 29475</li><li>29095 - 28420</li><li>27970 - 27265</li></ol>
<p>Meer informatie: <a href="https://www.gate.io/blog_detail/2864/market-news-daily-main-token-trends-overview" target="_blank">Marktnieuws | Dagelijks Overzicht van Belangrijkste Token Trends</a></p>
<h2 id="h2-Macro20Dollar20verstevigt20goud20glijdt20weg20Feds20havikachtige20vooruitzichten20schudden20wereldwijde20markten678582"><a name="Macro: Dollar verstevigt, goud glijdt weg; Fed’s havikachtige vooruitzichten schudden wereldwijde markten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Dollar verstevigt, goud glijdt weg; Fed’s havikachtige vooruitzichten schudden wereldwijde markten</h2><p>Wereldwijde markten hadden gemengde gevoelens toen handelaren de nieuwste notulen van de Federal Reserve verwerkten. De Amerikaanse schatkistrendementen stegen terwijl aandelen daalden, beïnvloed door de havikachtige signalen die in de notulen werden onthuld. De S&amp;P 500 sloot 0,2% lager, wat de zorgen van beleggers over mogelijke renteverhogingen weerspiegelt.</p>
<p>De stijging van de opbrengsten op tweejarige en tienjarige Treasuries heeft geleid tot een omgekeerde rendementscurve, een mogelijke indicator van een naderende economische neergang.<br><strong>Hoewel de Federal Reserve Wall Street heeft verrast door zijn cyclus van renteverhogingen te onderbreken, is het nog steeds van plan om dit jaar twee verdere renteverhogingen door te voeren.</strong> De notulen benadrukten verdeeldheid binnen het Federal Open Market Committee, waarbij sommige leden een nieuwe renteverhoging voorstaan vanwege de krappe arbeidsmarkt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688609385Untitled0706 6.png" alt=""></p>
<p>Het aanstaande werkgelegenheidsverslag van juni is van groot belang voor beleggers, omdat het de discussie kan beïnvloeden over de vraag of de Fed zal doorgaan met renteverhogingen of zal kiezen voor een pauze in september. Swaps-handelaren hebben nog niet volledig de verwachte renteverhogingen ingeprijsd, maar weddenschappen op het versoepelen van het beleid van de Fed zijn verder in de toekomst geschoven.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688609407Untitled0706 7.png" alt=""></p>
<p>Valutamarkten zagen de Amerikaanse dollar sterker worden ten opzichte van belangrijke tegenhangers, terwijl de goudprijzen een daling ondergingen. De prijzen van ruwe olie bereikten $ 72 per vat na productieverlagingen door Saoedi-Arabië en Rusland.</p>
<p>Verwacht wordt dat Aziatische markten zullen dalen, wat overeenkomt met de lagere slotkoersen op Wall Street als reactie op de havikachtige signalen van de Fed. Aandelenfutures voor Japan, Australië en Hong Kong daalden, waarbij beleggers bezorgdheid benadrukten. Bovendien,<br><strong>Markten zullen nauwlettend toezien op het bezoek van minister van Financiën Janet Yellen aan Beijing in een poging de betrekkingen tussen de VS en China te verbeteren.</strong></p>
<p>Ondertussen verklaarde het door de centrale bank gesteunde nieuwsagentschap van China dat het land over de nodige instrumenten beschikt om de valutamarkt te stabiliseren, zelfs in het g van een verzwakte yuan. De grootste banken van China hebben ook de tarieven voor de stortingen in Amerikaanse dollars voor bedrijven verlaagd, met als doel de worstelende yuan te ondersteunen.</p>
<p>Terwijl de wereldwijde markten zich een weg banen door mogelijke renteverhogingen,<br><strong>beleggers wachten op cruciale Amerikaanse werkgelegenheidsrapporten om inzicht te krijgen in de staat van de arbeidsmarkt.</strong> De uitkomst van deze rapporten zal waarschijnlijk van invloed zijn op de marktvolatiliteit en de verwachtingen vormgeven met betrekking tot toekomstige acties van de Fed.</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 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 vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>