RGFnZWxpamtzIG5pZXV3cyB8IEJpdGNvaW4gYmVyZWlrdGUgZWVuIG5pZXV3IGhvb2d0ZXB1bnQgdmFuICQ3MkssIG1hYXIgZXIgaXMgZWVuIG9uZGVybGlnZ2VuZGUgb3ZlcnZlcmhpdHRpbmdzY3Jpc2lzOyBFciB6YWwgJDIsMyBtaWxqYXJkIGFhbiBBUkIgd29yZGVuIG9udGdyZW5kZWxkOyBNaW5lciBCaXRhcm0gaGVlZnQgNTEuOTA

2024-03-12, 03:31

<p><img src="https://gimg2.gateimg.com/image/article/17102142051_7.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Bitcoin20is20doorgebroken20naar207200020en20analisten20geloven20over20het20algemeen20dat20er20een20potentieel20risico20op20oververhitting20is20Arbitrum20zal20op201620maart2023220miljard20aan20verworven20tokens20ontgrendelen20Mijnbouwbedrijf20Bitarm20koopt20een20grote20hoeveelheid20ASICs103549"><a name="Crypto Dagelijkse Samenvatting: Bitcoin is doorgebroken naar $72.000 en analisten geloven over het algemeen dat er een potentieel risico op oververhitting is; Arbitrum zal op 16 maart $2,32 miljard aan verworven tokens ontgrendelen; Mijnbouwbedrijf Bitarm koopt een grote hoeveelheid ASICs." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> is doorgebroken naar $72.000 en analisten geloven over het algemeen dat er een potentieel risico op oververhitting is; Arbitrum zal op 16 maart $2,32 miljard aan verworven tokens ontgrendelen; Mijnbouwbedrijf Bitarm koopt een grote hoeveelheid ASICs.</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> heeft de $72.000 doorbroken en heeft een nieuw historisch hoogtepunt bereikt, en is zilver voorbijgestreefd in marktwaarde, waardoor het ‘s werelds achtste grootste vermogensbestanddeel is geworden.</p>
<p>Wat betreft de handelsactiviteiten van Bitcoin ETF’s, volgens gegevens van Farside Investor was de uitstroom van Grayscale GBTC op 11 maart ongeveer $494,1 miljoen, de instroom van Bitwise Bitcoin Spot ETF (BITB) was $50 miljoen, de instroom van ARK 21Shares Bitcoin Spot ETF (ARKB) was gisteren $13 miljoen en de instroom van Fidelity Bitcoin Spot ETF (FBTC) was gisteren $215,5 miljoen.</p>
<p>Sinds 23 januari zijn de Bitcoin-prijzen in een opwaartse trend sinds het ‘verkoopnieuws’-effect van spot Bitcoin ETF’s is afgenomen. Sinds hun lancering op 11 januari hebben deze nieuwe BTC-beleggingsfondsen een aanzienlijke instroom van fondsen gezien, waarbij het beheerde vermogen op 11 maart $ 55,3 miljard bereikt, wat leidt tot een ‘oververhittingsignaal’ op de Bitcoin-markt.</p>
<p>CryptoQuant-analisten waarschuwen dat hoewel BTC een historisch hoogtepunt heeft bereikt, het binnenkort aanzienlijke aanpassingen kan ondergaan. Op 8 maart plaatste dit blockchain-analysebedrijf een reeks berichten op het sociale netwerk X, waarin enkele indicatoren werden weergegeven die “mogelijke oververhitting” ondersteunen. Een andere indicator die ze noemden, laat zien dat de gerealiseerde winsten hun hoogste niveau sinds december 2023 bereikten, “de salarissen van mijnwerkers worden nu als extreem hoog beschouwd, terwijl de winstgevendheid het hoogste niveau bereikt sinds december 2023.”</p>
<p>CryptoQuant benadrukte ook dat de ongerealiseerde winstmarge van handelaren 57% heeft bereikt, dus “kortetermijnhouders zijn begonnen met verkopen tegen de hoogste winstmarge sinds februari 2021, wat kan duiden op een toename van verkoopdruk.” Ondertussen toont data van IntoTheBlock aan dat 100% van de Bitcoin-houders momenteel winstgevend zijn, wat ook de mogelijkheid van kortetermijnwinstverkoop vergroot.</p>
<p>Op dit moment bewijst ook de sterk overbought BTC RSI-index dit punt. Coin Glass wees erop dat meer dan 80% van de tijd, binnen een week op een hoge RSI-waarde staat.</p>
<p>Volgens gegevens van Token Unlocks, een digitale activa tracker, zal het Layer 2 blockchain-netwerk Arbitrum ongeveer 1,1 miljard vergrendelde ARB-tokens ter waarde van $2,32 miljard vrijgeven op 16 maart. Dit bedrag vertegenwoordigt ongeveer 76% van de circulerende voorraad van de token en is $2,32 miljard waard op het moment van schrijven.</p>
<p>Arbitrum zal 673,5 miljoen tokens ontgrendelen voor zijn team en consultants, wat ongeveer $1,41 miljard waard is tegen de huidige prijzen; Zijn investeerders hebben 43.825 miljoen tokens uitgegeven ter waarde van ongeveer $915 miljoen. De ontgrendeling van tokens benadrukt ook dat dit een ‘cliff-ontgrendeling’ zal zijn, en er zullen in eerste instantie geen tokens worden vrijgegeven tot de ontgrendelingsdatum. De tokens worden in één keer vrijgegeven op de aangewezen uitgiftedatum.</p>
<p>Bitcoin miner Bitarms heeft op 11 maart 28.000 Bitcoin Continental T21 ASIC-mijnmachines en 19.280 Bitcoin Continental T21 mijnmachines gekocht voor $14 per terahash (TH). Ze hebben in totaal 51.908 ASIC’s gekocht, waaronder 3.888 Bitcoin Continental S21 mijnmachines en 740 Bitcoin Continental S21 hydraulische mijnmachines, voor $17,50/TH.</p>
<p>Als reactie op de daling van de winst van mijnwerkers veroorzaakt door de halvering, heeft het bedrijf voortdurend zijn zakelijke omvang uitgebreid en heeft het 11 operationele Bitcoin-mijnbouwfaciliteiten. Bovendien heeft het ook ontwikkelingen uitgevoerd in Canada, de Verenigde Staten, Paraguay en Argentinië.</p>
<p>Op het moment van publicatie van het artikel is de winkelprijs van elke BitContinent T21 ASIC-miningmachine ongeveer $3.000, met een hash-snelheid van 190 TH/s.</p>
<p>Bitarms President en CEO Geoff Morphy verklaarde dat hij meer mijnbouwmachines had verworven “voordat de verwachte hardwareprijsstijging”. Hij wees er ook op dat ASIC gepland staat om dit jaar te worden geleverd en naar verwachting een totale hash-snelheid van 21 exahashes (EH/s) zal bereiken, ongeveer 3% van de verwerkingscapaciteit van het Bitcoin-netwerk.</p>
<h2 id="h2-Markttrends20BTC20bereikt20herhaaldelijk20nieuwe20hoogtepunten20maar20de20markt20is20relatief20zwak898832"><a name="Markttrends: BTC bereikt herhaaldelijk nieuwe hoogtepunten, maar de markt is relatief zwak" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC bereikt herhaaldelijk nieuwe hoogtepunten, maar de markt is relatief zwak</h2><p>Bitcoin (BTC) brak binnen één dag door $72.000 heen en vestigde daarmee een nieuw historisch hoogtepunt. Ondertussen zijn er ook duidelijke tekenen van aanvulling in de traditionele mainstream munten en vertoont de algehele markt een trage consolidatietrend. Met betrekking tot de macro-economie heeft de Amerikaanse aandelenmarkt gemengde winsten en verliezen gezien, terwijl AI-leider Nvidia een omkering van trend en een daling heeft ervaren.</p>
<h3 id="h3-Markt20hotspots886964"><a name="Markt hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots</h3><p>Traditionele publieke blockchain munten zoals CELO, AVAX, RUNE, DOT en GLMR zijn aanzienlijk gestegen. Daarvan heeft de prijs van <a href="/price/celo-celo" target="_blank" class="blog_inner_link">CELO</a> meer dan $1,8 bereikt, met een dagelijkse stijging van meer dan 50%. De stijging van CELO wordt ondersteund door verschillende factoren, waaronder <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> aankondiging van de lancering van USDT op het <a href="/price/celo-celo" rel="nofollow noopener noreferrer" target="_blank">Celo</a> blockchainnetwerk en de lancering van het financieringsplatform Kickstarter door Celo.</p>
<p>De prestaties van de POW-sector zijn indrukwekkend: concept tokens zoals SYS, LTC en RVN, die proof of work zijn, zagen ook vorige week een aanzienlijke stijging. Gezien het feit dat er nog een maand te gaan is tot de halveringsdatum van Bitcoin, heeft de toenemende vraag naar POW-concepttokens op de markt geleid tot indrukwekkende groei in deze projecten.</p>
<p>De Layer2-token zag een aanzienlijke stijging als gevolg van het nieuws van de online beurs, en de Metis-token zag ook een aanzienlijke stijging. Met de Cancun-upgrade van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gepland voor 13 maart, presteerden de meeste Layer2-tokens niet beter dan de winsten van Ethereum, maar Metis presteerde goed, gestimuleerd door het nieuws van de beurs.</p>
<p>Over het algemeen, afgezien van Bitcoin die een historisch hoogtepunt bereikt, heeft de cryptomarkt een aanzienlijke toename gezien van traditionele openbare ketenmunten en POW-concepttokens, terwijl andere sector tokens zich in de aanpassingsfase bevinden. Ondertussen kunnen gerelateerde projecten met de aanstaande <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Cancun-upgrade en de naderende halveringsdatum van Bitcoin mogelijk blijven profiteren van marktaandacht en kapitaalinstroom.</p>
<h2 id="h2-Macro20Licht20wereldwijde20marktcorrectie20CEO20van20JPMorgan20Chase20dringt20aan20op20renteverlaging20na20juni20Inflatiegegevens20staan20op20het20punt20te20worden20vrijgegeven20goud20is20gestagneerd20na20het20bereiken20van20een20hoogtepunt262165"><a name="Macro: Licht wereldwijde marktcorrectie; CEO van JPMorgan Chase dringt aan op renteverlaging na juni; Inflatiegegevens staan op het punt te worden vrijgegeven, goud is gestagneerd na het bereiken van een hoogtepunt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Licht wereldwijde marktcorrectie; CEO van JPMorgan Chase dringt aan op renteverlaging na juni; Inflatiegegevens staan op het punt te worden vrijgegeven, goud is gestagneerd na het bereiken van een hoogtepunt</h2><p>Op 12 maart meldde Reuters dat de mondiale markt matig was gedaald van recente hoogtepunten vóór de publicatie van Amerikaanse inflatiegegevens op dinsdag. Het is onwaarschijnlijk dat de Aziatische markt te veel in beide richtingen zal schommelen, maar er kunnen wel schommelingen zijn in de Indiase roepie en de Zuid-Koreaanse won; op de economische kalender staan de inflatie van India en de notulen van de vergadering van de Zuid-Koreaanse centrale bank bovenaan de prioriteitenlijst.</p>
<p>Als gevolg van de sterke stijging van de Chinese aandelenmarkt was de algehele correctie op de Aziatische aandelenmarkten op maandag veel kleiner, terwijl de daling op Wall Street matig was. Desalniettemin werd de NASDAQ-index opnieuw de grootste daling onder de drie belangrijkste Amerikaanse indices, terwijl marktlieveling NVIDIA 2% daalde na een val van 5,5% op vrijdag.</p>
<p>De Nikkei-index (.N225) van Japan daalde met 0,84%, waarbij de Bank of Japan zijn daling voortzette. Ondanks een aanzienlijke daling op de aandelenmarkt heeft de centrale bank op maandag geen Japanse exchange-traded funds gekocht, wat de speculatie aanwakkert dat het ultra-soepele monetaire beleid op het punt staat te veranderen.</p>
<p>Intussen zal het Consumer Price Index (CPI) rapport van februari voor de Verenigde Staten worden vrijgegeven om 12:30 Greenwich Mean Time, met een verwachte stijging van 0,4% deze maand en een stabiele jaarlijkse tarief van 3,1%. Er wordt verwacht dat de kerninflatie met 0,3% zal stijgen, waardoor de jaarlijkse groeisnelheid op het laagste niveau sinds begin 2021 van 3,7% komt.</p>
<p>Jamie Dimon, CEO van JPMorgan Chase, drong er bij de Federal Reserve op aan om te wachten tot na juni om de rentetarieven te verlagen, omdat hij van mening is dat de centrale bank haar geloofwaardigheid in de strijd tegen inflatie moet verbeteren.</p>
<p>De markt verwacht een kans van 84% dat de Federal Reserve de rentetarieven in juni zal verlagen, en heeft de impact van een renteverlaging van 90 basispunten dit jaar geabsorbeerd.</p>
<p>“Ik denk dat ze moeten vertrouwen op data. Als ik hen was, zou ik wachten”, zei Damon live op de Australian Financial Review Business Summit in New York. Hij is van mening dat de Amerikaanse economie goed heeft gepresteerd en bijna als welvarend kan worden omschreven, maar hij waarschuwt de markt om het idee van een zachte landing niet volledig te accepteren. Hij gelooft dat de kans op een recessie ongeveer 65% is, maar kan ook de mogelijkheid van stagflatie niet uitsluiten.”</p>
<p>Op 12 maart bleven de goudprijzen stabiel omdat Amerikaanse consumentenprijsgegevens mogelijk van invloed zijn op de koers van het monetaire beleid van de Federal Reserve. Na een recordstijging van de goudprijzen vorige week, hebben handelaren geen nieuwe posities ingenomen. Vanaf GMT 0157 bleef spotgoud stabiel op $ 2182,48 per ounce na negen opeenvolgende handelsdagen te zijn gestegen en bereikte vrijdag een historisch hoogtepunt van $ 2194,99. De Amerikaanse futures bleven ook ongewijzigd op $ 2188,70.</p>
<p>Wat betreft grondstoffen steeg Amerikaanse ruwe olie met 0,28% tot $78,15 per vat, terwijl Brent-ruwe olie met 0,33% steeg tot $82,48.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S. &amp; Icing.</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 beleggingsadviezen.<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 wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>