RGFnZWxpamtzIG5pZXV3cyB8IFRldGhlciB2YW4gcGxhbiBvbSAkNTAwIG1pbGpvZW4gdGUgaW52ZXN0ZXJlbiBpbiBCaXRjb2luLW1pbmluZywgNjQlIHZhbiBkZSBpbnN0ZWxsaW5nZW4gemFsIGh1biBiZXppdCB2YW4gY3J5cHRvLWFjdGl2YSB2ZXJob2dlbiwgSnVwaXRlciB6YWwgdm9sZ2VuZGUgd2VlayBzdGFydGVuIG1ldCBUb2t

2023-11-17, 04:30

<p><img src="https://gimg2.gateimg.com/image/article/17002018701_17.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Tether20van20plan20om2050020miljoen20te20investeren20in20Bitcoin20mining206420van20de20instellingen20zal20hun20bezit20van20crypto20activa20in20de20toekomst20vergroten711320"><a name="Crypto Dagelijks Overzicht: Tether van plan om $500 miljoen te investeren in Bitcoin mining, 64% van de instellingen zal hun bezit van crypto activa in de toekomst vergroten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> van plan om $500 miljoen te investeren in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> mining, 64% van de instellingen zal hun bezit van crypto activa in de toekomst vergroten</h2><p>Volgens Bloomberg, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> Holdings Ltd. neemt maatregelen om een van ‘s werelds grootste te worden <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Tether’s aankomende CEO, Paolo Ardoino, verklaarde in een interview dat het bedrijf van plan is om ongeveer $500 miljoen te investeren in de komende zes maanden door de bouw van zijn eigen miningfaciliteiten en investeringen in andere bedrijven.</p>
<p>De investering omvat een deel van een kredietregeling van $610 miljoen die deze maand door Tether is verstrekt aan het genoteerde Bitcoin-mijnbouwbedrijf Northern Data AG, dat Tether in september heeft verworven.</p>
<p>Aan de andere kant heeft de Bitcoin-betalingsapplicatie Strike gebruikers uit 36 landen buiten de Verenigde Staten ondersteund om Bitcoin rechtstreeks via de apps te kopen, en de dienst zal in de toekomst worden uitgebreid naar meer dan 65 landen.</p>
<p>In tegenstelling tot Amerikaanse gebruikers die Bitcoin gratis kopen, moeten wereldwijde gebruikers een vergoeding van 3,9% betalen voor Bitcoin-aankopen. Ondertussen is het kanaal Send Globally nu beschikbaar voor wereldwijde Strike-gebruikers, waardoor klanten uit ondersteunde landen/regio’s fiatgeld, USDT of Bitcoin in lokale valuta kunnen inwisselen. Bovendien is Strike een partnerschap aangegaan met Biterfill, een crypto-betalingsbedrijf, en kunnen Strike-gebruikers nu dagelijkse benodigdheden kopen via het Lightning Network.</p>
<p>Onlangs verklaarde Coinbase in een blogpost dat haar in opdracht uitgevoerde enquête onder 250 institutionele beleggers door Institutional Investors aantoonde dat institutionele beleggers zich actief willen bezighouden met investeren in cryptocurrencies en optimistisch zijn over de toekomst:</p>
<p>64% van de momenteel ondervraagde crypto-investeerders verwacht hun allocatie in de komende drie jaar te verhogen; Onder institutionele investeerders die geen cryptocurrency hebben toegewezen, verwachtte 45% dit binnen de komende drie jaar te doen; 57% van de ondervraagde institutionele investeerders gelooft dat de prijzen in de komende 12 maanden zullen stijgen, terwijl slechts 8% van de mensen in oktober 2022 dezelfde mening is toegedaan; Respondenten geloven dat blockchain in de toekomst traditionele betalings- en handelsafwikkelingstracks kan vervangen.</p>
<p>Onlangs bleek uit een nieuw rapport van blockchain beveiligingsplatform Imunefi dat bijna de helft van alle crypto-verliezen als gevolg van Web3-kwetsbaarheden in 2022 te wijten zijn aan Web2-beveiligingsproblemen zoals het lekken van privésleutels.</p>
<p>Het rapport beoordeelt de uitbuitingsevenementen van crypto-kwetsbaarheden van 2022 en categoriseert ze in verschillende soorten kwetsbaarheden. De conclusie van het rapport is dat het Web3-ecosysteem in 2022 een totaal verlies leed van $ 3,948,856,037 aan fondsen (inclusief hackeraanvallen en vermoedelijke fraude-incidenten), waarvan 46.48% van het verlies niet te wijten was aan defecten in slimme contracten, maar eerder aan “infrastructuurdefecten” of problemen met de computeren van het ontwikkelingsbedrijf.</p>
<p>Wat betreft token airdrops, is het vermeldenswaardig dat de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteemhandelsaggregator Jupiter Exchange heeft gedetailleerde informatie vrijgegeven over JUP-gemeenschapsairdrops. Het totale aantal JUPs is 10 miljard, waarvan 40% via vier rondes van airdrops aan de gemeenschap zal worden verdeeld. In de eerste ronde zal 10% van de tokens (1 miljard) worden verdeeld. 955.000 portefeuilles die vóór 2 november rechtstreeks met Jupiter hebben geïnterageerd, komen in aanmerking voor airdrops.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag937999"><a name="Belangrijkste Token Trends van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste Token Trends van vandaag</h2><h3 id="h3-BTC372944"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1700201904BTC.png" alt=""><br>Deze week gaat verder met hoge schommelingen en consolidatie. Korte termijn steun bevindt zich op het niveau van $36.000, terwijl de algehele opwaartse trendsteun wordt vastgehouden op $33.085. Korte termijn weerstand blijft op $37.755. Er vormt zich een voortzettingspatroon en het is raadzaam om de richting te observeren. Hoewel deze week mogelijk geen significante trends laat zien, worden er grotere bewegingen verwacht volgende week.</p>
<h3 id="h3-ETH582074"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1700201923ETH.png" alt=""><br>Na het niet kunnen doorbreken van de weerstand van $2.135, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> tweemaal teruggetrokken naar de ondersteuning van $1.951. Korte termijn volume blijft bearish en de aandacht moet worden gericht op het al dan niet vormen van een W-bottom structuur bij de ondersteuning. Conservatieve longposities worden voorgesteld bij het doorbreken van $2.135, met als doel $2.381. Conservatieve shortposities moeten wachten op een doorbraak onder $1.951.</p>
<h3 id="h3-ARKM55073"><a name="ARKM" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ARKM</h3><p><img src="https://gimg2.gateimg.com/image/article/1700201941ARKM.png" alt=""><br>Korte termijn positionering blijft op $0.4250, met een recente hoogtepunt op $0.6150. De maand wordt gezien als positief voor verdere stijging, gericht op $0.65, $0.7425, $0.8900, $1.2529 en $1.8250. Een mislukking om opnieuw te stijgen kan leiden tot een triple bottom, wat voorzichtigheid signaleert tegen mogelijke consolidatie vóór een opwaartse beweging.</p>
<h2 id="h2-Macro20De20werkloosheid20in20de20VS20heeft20een20nieuw20hoogtepunt20bereikt20de20markt20verwacht20dat20de20rente20in20juni20volgend20jaar20zal20worden20verlaagd635103"><a name="Macro: De werkloosheid in de VS heeft een nieuw hoogtepunt bereikt, de markt verwacht dat de rente in juni volgend jaar zal worden verlaagd." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De werkloosheid in de VS heeft een nieuw hoogtepunt bereikt, de markt verwacht dat de rente in juni volgend jaar zal worden verlaagd.</h2><p>Op donderdag overtrof het aantal aanvragen voor werkloosheidsuitkeringen in de Verenigde Staten vorige week de verwachtingen en steeg naar 231.000, het hoogste niveau in bijna drie maanden. Het aantal mensen dat een werkloosheidsuitkering aanvraagt, is gestegen naar 1,865 miljoen, het hoogste niveau in bijna twee jaar.</p>
<p>De werkloosheidsgegevens tonen een zwakke arbeidsmarkt, wat het standpunt versterkt dat de Federal Reserve waarschijnlijk de rente niet verder zal verhogen.</p>
<p>Beïnvloed door de werkloosheidscijfers daalde de Amerikaanse dollindex op korte termijn, veerde in de buurt van de 104-markering op en sloot uiteindelijk dicht bij 104,39. Het rendement van de Amerikaanse schatkist is gedaald tot een wekelijks dieptepunt. Het rendement van de Amerikaanse schatkist op 10 jaar sloot op 4,441%; Het rendement van de Amerikaanse schatkist op 2 jaar, dat gevoeliger is voor het rentetariefbeleid van de Federal Reserve, sloot op 4,85%.</p>
<p>De drie belangrijkste Amerikaanse aandelenindices schommelden nauw, waarbij de Dow 0,13% lager sloot, de Nasdaq 0,12% hoger sloot en de S&amp;P 500-index 0,1% hoger sloot. Spot goud steeg rechtlijnig tijdens de handelssessie en bereikte een maximum van 1987,9, gevolgd door een lichte daling en sloot uiteindelijk 1,06% hoger op $1981,32 per ounce, een nieuw hoogtepunt in twee weken; Spot zilver bereikte kortstondig het 24e niveau en sloot uiteindelijk 1,27% hoger op $23,75 per ounce.</p>
<p>Internationale olieprijzen zijn gedaald naar het laagste niveau sinds juli, getrokken door zwakke Amerikaanse economische gegevens en de uitbreiding van de voorraden ruwe olie. WTI ruwe olie daalde bijna 6% op het diepste punt en sloot uiteindelijk 4,78% lager op $72,86 per vat; Brent ruwe olie versnelde zijn daling na het breken van de 80-mark en sloot uiteindelijk 4,34% lager af op $77,44 per vat.</p>
<p>De vicevoorzitter van de Federal Reserve, Jefferson, de gouverneur van de Federal Reserve, Cook, en Kugler vertelden een Amerikaanse senator dat het momenteel onduidelijk is hoelang het proces van de Federal Reserve om haar balans te verkleinen zal duren, maar ze zeiden dat het proces mogelijk niet snel zal eindigen.</p>
<p>Voorzitter Maester van de Cleveland Fed zei: “We moeten meer bewijs zien dat de inflatie de 2% zal bereiken. Er is nog niet besloten of er nog een renteverhoging nodig is. Dit (huidige probleem) gaat niet over het verlagen van de rente, maar over hoelang we een verkrappingsbeleid zullen handhaven, en de (rentetarieven) kunnen hoger zijn.”</p>
<p>Ondertussen verklaarde Federal Reserve Governor Cook dat het aanhoudende momentum van de vraag de snelheid van de inflatiedaling kan vertragen en waakzaam blijft over het risico van een scherpe daling van de economische activiteit.</p>
<p>Eigenlijk gelooft de markt niet meer dat de Federal Reserve de rente kan verhogen, ongeacht wat de ambtenaren zeggen. In plaats daarvan is de markt meer bezorgd over wanneer de rente volgend jaar verlaagd zal worden, omdat het verlagen van de rente een nieuwe golf van welvaart zal stimuleren. Tegenwoordig wordt algemeen verwacht dat dit rond juni volgend jaar zal zijn, wat perfect samenvalt met de Bitcoin-halveringscyclus. Het is voorstelbaar dat met de komst van renteverlagingen volgend jaar, de crypto-markt opnieuw zal ontvlammen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<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 op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>