RGFnZWxpamtzIG5pZXV3cyB8IEJpdGNvaW4gZGFnZWxpamtzZSB0cmFuc2FjdGllcyBzdGlqZ2VuIG5hYXIgcmVjb3JkaG9vZ3RlcyBkaWUgcHJpanN6b3JnZW4ga3VubmVuIHZlcm9vcnpha2VuOyBKdXJpZGlzY2ggZXhwZXJ0IHN1Z2dlcmVlcnQgZGF0IFJpcHBsZSBtb2dlbGlqayBlZW4gc2NoaWtraW5nIHRyZWZ0LCB6ZWxmcyBhbHM

2023-05-03, 01:56

<p><img src="https://gimg2.gateimg.com/image/article/16830788180503.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting202020Bitcoin2020Dagelijkse20transacties20stijgen20naar20recordhoogtes20wat20prijsproblemen20kan20veroorzaken20juridisch20expert20suggereert20dat20Ripple20mogelijk20een20schikking20treft20zelfs20als20het20een20overwinning20behaalt201420miljoen20banen20over20de20hele20wereld20zullen20in20520jaar20verdwijnen569568"><a name="Crypto Dagelijkse Samenvatting:   Bitcoin  Dagelijkse transacties stijgen naar recordhoogtes, wat prijsproblemen kan veroorzaken; juridisch expert suggereert dat Ripple mogelijk een schikking treft, zelfs als het een overwinning behaalt; 14 miljoen banen over de hele wereld zullen in 5 jaar verdwijnen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Dagelijkse transacties stijgen naar recordhoogtes, wat prijsproblemen kan veroorzaken; juridisch expert suggereert dat Ripple mogelijk een schikking treft, zelfs als het een overwinning behaalt; 14 miljoen banen over de hele wereld zullen in 5 jaar verdwijnen</h2><p>Crypto-markten hebben matige stijgingen gekend in de afgelopen dag, waardoor veel activa in de top honderd met maximaal 2% zijn gestegen. Als gevolg hiervan <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is opnieuw boven de $28,6k zone verschenen en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> heeft bijna $1.900 bereikt. Echter, met dergelijke gematigde stijgingen in de hele markt, hebben maar heel weinig activa zich hersteld van enkele van de meer verwoestende verliezen die zijn opgelopen in de afgelopen week.</p>
<p>De volatiele handelstraject kan worden gecorreleerd met de verwoestende prestaties van Amerikaanse aandelen over de afgelopen dag, wat leidde tot de S&amp;P 500, DOW en Nasdaq die allemaal meer dan 500 punten verloren over de afgelopen dag.</p>
<p>In positiever nieuws, op maandag het aantal transacties die plaatsvinden op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> het netwerk bereikte een recordhoogte van 682.099, volgens gegevens gepresenteerd door Glassnode. Met het overschrijden van het eerdere record van 425.000 dat in 2019 werd ingesteld, hebben analisten voorspeld dat deze stijging in netwerktransacties te wijten is aan de toename van het aantal BTC NFT ordinaalinies die op het netwerk plaatsvinden, wat nu ongeveer 3.225 bedraagt. Als gevolg hiervan heeft de toename van netwerktransacties geleid tot een scherpe stijging in de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> het hash-tarief van het netwerk stelt een recordhoogte in van ongeveer 440 exahashes per seconde (EHS).</p>
<p>Deze alternatieve metrische nieuwe hoogtepunten zijn allemaal positieve signalen voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, maar wanneer het wordt gecombineerd met andere veel gevolgde on-chain indicatoren, zijn er verschillende conservatievere signalen. De 7-daagse MA van het aantal actieve adressen dat communiceert met het BTC-netwerk is onlangs gedaald naar het laagste niveau, van meer dan een miljoen per dag tot recentelijk 21 april. Op dezelfde manier daalde het aantal nieuwe adressen naar een meermaands dieptepunt van ongeveer 420.000, scherp lager dan de hoogtepunten van 516.000 die in april werden gezien. Deze combinatie van metingen heeft analisten doen voorspellen dat als er meer Amerikaanse banken instorten, BTC een veilige haven zou kunnen betreden en een prijsvloer van $30.000 zou kunnen handhaven. Als echter het Amerikaanse monetair beleid verbetert, kan dit een omgekeerd effect hebben.</p>
<p>Overigens heeft de juridisch expert John Deaton zich op Twitter uitgesproken over zijn mening over of Ripple een schikking met de SEC zou accepteren. Deaton is van mening dat Amerikaanse beurzen zoals Coinbase of Kraken al dan niet opnieuw zouden noteren. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> zou de beslissing drastisch kunnen beïnvloeden. Op dezelfde manier gelooft Deaton dat of de belangrijke Ripple-partner, Bank of America, zich comfortabel zou voelen over het gerechtelijk vonnis of zou wachten om te zien of rechter Torres wordt teruggedraaid als de SEC in beroep gaat tegen haar beslissing. Deaton merkte op dat de SEC mogelijk een kennisgeving van beroep zou kunnen indienen en deze later zou kunnen intrekken, wat zou kunnen leiden tot meer ruimte voor onderhandelingen. Dit zou uiteindelijk de juridische procedures verder kunnen compliceren en verlengen.</p>
<h2 id="h2-Bitcoin2020BTC202865836202462020Neutrale20Outlook832469"><a name="Bitcoin  (BTC) $28.658,36 (+2,46%) - Neutrale Outlook" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> (BTC) $28.658,36 (+2,46%) - Neutrale Outlook</h2><p><img src="https://gimg2.gateimg.com/image/article/16830788981691683078883_.pic.jpg" alt=""><br>(Data met dank aan TradingView)</p>
<p>Vanaf vandaag, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> begint omhoog te bewegen nadat het de week op een laag niveau is begonnen. Begin de dag te schommelen tussen de bovengrenzen van $27,9k en $28,07k, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> bewoog op dit niveau tot 15.00 uur, waar het toen omhoogschoot naar $28,5k op één kaars. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> begon vervolgens omhoog te bewegen en testte het niveau van $28.8k. Ondanks deze meer positieve prijsprestatie, hypotheseren analisten dat een herkansing met zowel $25.000 als $30.000 op tafel ligt als <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> beweegt zich door onzeker terrein. Als het bereik echter boven de $30k uitbreidt, is het mogelijk dat BTC $31k zou kunnen testen en mogelijk $32.400 in de komende weken, wat zou kunnen leiden tot een opleving van momentum.</p>
<p><strong>Overzicht:</strong></p>
<p><strong>Dichtstbijzijnde uurlijkse ondersteuningszone: 28.718-28.711</strong><br><strong>Dichtstbijzijnde uurlijkse weerstandszone: 28.768-28.759</strong><br><strong>Belangrijkste niveau: 30.000 (Prijsdoel)</strong></p>
<p>Uurlijkse weerstandszones<br>28.711-28.718<br>28.670-28.657<br>28.770-28.777</p>
<p>Uurlijkse ondersteuningszones<br>28.649-28.665<br>28.710-28.720<br>28.750-28.767</p>
<h2 id="h2-Macro201420miljoen20banen20over20de20hele20wereld20verdwijnen20in20520jaar378356"><a name="Macro: 14 miljoen banen over de hele wereld verdwijnen in 5 jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: 14 miljoen banen over de hele wereld verdwijnen in 5 jaar</h2><p>De WEF-top - die elk jaar een bijeenkomst van wereldleiders in Davos, Zwitserland organiseert - heeft geconstateerd dat werkgevers naar verwachting 69 miljoen nieuwe banen zullen creëren tegen 2027 en ongeveer 83 miljoen banen zullen elimineren, wat zou kunnen resulteren in een netto verlies van meer dan 14 miljoen banen of 2% van het huidige aantal werkgelegenheidscijfers. WEF heeft geconcludeerd dat de arbeidsverloop zal worden bijgedragen door de trage economische groei, hoge inflatie en de haast om kunstmatige intelligentie in te zetten. WEF gelooft echter dat de overstap naar hernieuwbare energieen kan fungeren als een krachtige motor voor het genereren van banen.</p>
<p>Vanwege de push om AI te implementeren, zullen bedrijven nieuwe werknemers nodig hebben om deze tools en en te integreren en beheren, wat zal resulteren in een gemiddelde groei van 30% in data-analisten, wetenschappers en machine learning specialisten. Echter, de proliferatie van AI zal veel functies in gevaar brengen, waarbij robots in sommige glen verschillende banen vervangen. Taken zoals archivering, administratie, gegevensinvoer en secretariële banen zullen waarschijnlijk de grootste verliezen lijden. WEF heeft verschillende organisaties ondervraagd en schat dat ongeveer 34% van alle zakelijke taken momenteel wordt uitgevoerd door machines, wat maar een fractie hoger is dan het cijfer van 2020. Er wordt momenteel verwacht dat AI tegen 2027 ongeveer 42% van alle zakelijke taken zal overnemen.</p>
<p>In andere markten gingen belangrijke aandelenindices gisteren op weg naar hun slechtste dag in meer dan een maand, omdat een groot aantal regionale bankaandelen bleven dalen of instortten. Dit leidde ertoe dat de Dow Jones Industrial Average met 540 punten of 1,6% daalde, terwijl de S&amp;P 500 en Nasdaq respectievelijk met 1,7% en 1,4% daalden.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Matthew Webster-Dowsing</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 opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt genoemd. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>