RGFnZWxpamtzIG5pZXV3cyB8IEp1c3RpbiBTdW4gbGFuY2VlcnQgQml0Y29pbiBMYXllcjI7IE1pY3JvU3RyYXRlZ3kgaG91ZHQgbWVlciBkYW4gJDEwIG1pbGphcmQgYWFuIEJUQyB2YXN0OyBCbGFzdCBUVkwgb3ZlcnNjaHJpamR0ICQxLDcgbWlsamFyZDsgU0VJIGRvb3JicmVla3QgJDEgZW4gc3RlbHQgZWVuIG5pZXV3IGhpc3Rvcml

2024-02-16, 03:23

<p><img src="https://gimg2.gateimg.com/image/article/17080536631_10.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Justin20Sun20lanceerde20Bitcoin20Layer220Blast20TVL20overschrijdt201720miljard56922"><a name="Crypto Dagelijkse Samenvatting: Justin Sun lanceerde Bitcoin Layer2, Blast TVL overschrijdt $1,7 miljard" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Justin Sun lanceerde <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Layer2, Blast TVL overschrijdt $1,7 miljard</h2><p>Op 15 februari heeft Grayscale volgens Arkham Monitoring 2399,657 BTC overgemaakt naar het Coinbase Prime-adres, wat overeenkomt met ongeveer $126 miljoen. Daarnaast heeft Grayscale 1756,294 BTC overgemaakt naar een nieuw adres, dat vermoedelijk het nieuwe bewaaradres van Grayscale is.</p>
<p>Volgens een rapport van CryptoQuant, een bedrijf voor on-chain data-analyse, op 14 februari, is meer dan driekwart van de nieuwe <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Investeringen in de afgelopen twee weken zijn afkomstig van Bitcoin spot ETF’s, exclusief grayscale GBTC. Het rapport stelt: ‘We schatten dat meer dan 75% van de nieuwe investeringen in Bitcoin afkomstig zijn van deze ETF’s. Bovendien zijn de investeringen van deze ETF’s gemeten naar gerealiseerde marktwaarde in slechts één maand gestegen tot 2% van de historische totale investering in Bitcoin.’</p>
<p>Met de opkomst van het Bitcoin-ecosysteem begon Justin Sun zich te begeven op Bitcoin Layer2.</p>
<p>Gisteren kondigde Justin Sun officieel aan <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> Lancering van een Bitcoin Layer 2-oplossing en routekaart, met als doel de interoperabiliteit tussen Bitcoin- en TRON-netwerken te verbeteren.</p>
<p>TRON is van plan tokens te integreren binnen het TRON-netwerk, inclusief stablecoins met een marktwaarde van $55 miljard, met het Bitcoin-netwerk en zijn laag 2 structuur, zoals Bitcoin ordinaal, via zijn laag 2 oplossing om cross-chain toegang tot activa te bevorderen en financiële vitaliteit te verbeteren.</p>
<p>De routekaart bestaat uit drie fasen: het uitbreiden van de brug van Bitcoin-assets naar <a href="/price/tron-trx" target="_blank" class="blog_inner_link">TRON</a> in de α-fase; samenwerken met het Bitcoin Layer 2-protocol in de β-fase; een oplossing van de tweede laag aankondigen voor het integreren van TRON-, BTTC- en Bitcoin-netwerken in de γ-fase. Dit plan heeft tot doel de snelheid en lage kosten van POS-en te behouden, terwijl de veiligheid van POW&amp;UTXO wordt gewaarborgd, wat een belangrijke stap is voor TRON in het verbeteren van de interoperabiliteit en praktische toepasbaarheid van blockchain-technologie.</p>
<p>Volgens Bloomberg zijn de Bitcoin-bezittingen van MicroStrategy momenteel $10 miljard waard. Eerder verklaarde Michael Saylor, oprichter van MicroStrategy, in een interview met CNBC dat de ongerealiseerde winsten van Bitcoin-investeringen van MicroStrategy naar schatting $3,5 miljard bedroegen toen de prijs van Bitcoin steeg naar $50000. Sinds de aankoop van Bitcoin in 2020 heeft het bedrijf in totaal 190.000 Bitcoins in bezit gehad, met een gemiddelde aankoopprijs van $31.224 en een totale kosten van ongeveer $5,93 miljard.</p>
<p>Telefonica, een Spaans telecommunicatiebedrijf, kondigde op donderdag de oprichting van een strategische alliantie aan met Chainlink Labs, een Web3-oplossingsprovider. Door samenwerking zijn de twee bedrijven toegewijd om real-world telecommunicatiefuncties te integreren in blockchain-netwerken om de beveiliging te verbeteren. Het eerste gebruiksscenario in de samenwerking zal de SIM SWAP API betreffen, geïntroduceerd door de Global Association of Mobile Communications s Open Gateway (een mobiel netwerk dat programmeerbare interfaces voor ontwikkelaars biedt). Telefonica is een lid van GSMA.</p>
<p>OpenAI heeft de lancering aangekondigd van een nieuw kunstmatig intelligentiesysteem genaamd Sora, dat tot één minuut aan realistische video’s kan maken op basis van tekstuele aanwijzingen. Deze video’s kunnen complexe scènes tonen met meerdere personages, acties en nauwkeurige thema’s en achtergronden. OpenAI CEO Sam Altman verklaarde dat deze tool aanvankelijk alleen beschikbaar zal zijn voor enkele makers. Ondertussen ontwikkelt het bedrijf nieuwe tools om te helpen bij het detecteren welke video’s zijn gegenereerd door Sora als onderdeel van de beveiligingsbeoordeling en voorbereidingswerkzaamheden voor de productlancering.</p>
<p>Op 15 februari bereikte volgens DeBank-gegevens de totale waarde van de activa van het Layer 2-netwerk Blast-contractadres, gelanceerd door Blur-oprichter Pacman, $1,764 miljard, met ongeveer $1,6 miljard aan ETH gestort in het Lido-protocol en meer dan 147 miljoen DAIs gestort in het Maker-protocol. Volgens de Gate.io-markt heeft de SEI van het L1 openbare-ketenproject nu een waarde van meer dan 1 USDT, met een piek van $1,03 en momenteel $1,01, met een stijging van meer dan 10% in 24 uur, waarmee een nieuwe historische hoogte wordt bereikt.</p>
<p>Op 16 februari, volgens Defi Llama gegevens, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het op Rustprotocol (TVL) gebaseerde op EigenLayer heeft $3,417 miljard bereikt, waarvan de top drie protocollen ether.fiTVL is, met een bereik van $1,216 miljard, een maandelijkse stijging van 392%; PufferFinance is een halve maand online geweest, met een TVL van $968 miljoen; KelpDAOTVL bereikte $461 miljoen, met een maandelijkse stijging van 172%.</p>
<h2 id="h2-Macro20Gegevens20gemengd20economische20groei20kan20in20de20toekomst20vertragen724115"><a name="Macro: Gegevens gemengd, economische groei kan in de toekomst vertragen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Gegevens gemengd, economische groei kan in de toekomst vertragen</h2><p>Op donderdag was het maandelijkse detailhandelsverkoopcijfer in de Verenigde Staten voor januari -0,8%, lager dan de verwachte -0,1%, met een vorige waarde van 0,60%, de grootste daling sinds maart 2023. De maandelijkse rate van de Amerikaanse importprijsindex in januari bedroeg 0,8%, verwacht werd 0%. De vorige waarde werd naar beneden bijgesteld van 0% naar -0,7%, de grootste stijging sinds maart 2022. Het aantal eerste aanvragen voor werkloosheidsuitkeringen in de Verenigde Staten voor de week eindigend op 10 februari bedroeg 212.000, lager dan de verwachte 220.000, waarbij de vorige waarde steeg van 218.000 naar 220.000. De prijsstelling op de swapmarkt weerspiegelt meer beleidsverruiming door de Federal Reserve in 2024.</p>
<p>Na de publicatie van de detailhandelsverkoopgegevens weerspiegelt de prijsstelling op de swapmarkt de beleidsverruiming van de Federal Reserve in 2024. De Amerikaanse dollarkoers daalde in de korte termijn met ongeveer 20 punten. De spotgoudprijs steeg in de korte termijn bijna $6 en keerde terug boven het niveau van 2.000.</p>
<p>Als gevolg van gemengde economische gegevens in de Verenigde Staten, heeft de Amerikaanse dollarkoers een aanzienlijke daling doorgemaakt tijdens de handelssessie in de VS, maar bleef boven het niveau van 104, om uiteindelijk met 0,42% te dalen tot 104,27, wat de tweede opeenvolgende handelsdag van daling markeert. Het rendement van de benchmark 10-jarige Amerikaanse staatslening daalde kortstondig onder de 4,2% tijdens de handel en veerde toen op tot 4,233%. Het rendement van de rentegevoelige 2-jarige Amerikaanse staatslening bleef vrijwel onveranderd op 4,578%.</p>
<p>Spotgoud keerde terug boven de $2.000-grens en steeg naar een intraday hoogtepunt van $2.008,36 tijdens de handel, om uiteindelijk 0,61% hoger te sluiten op $2.004,43 per ounce; Spotzilver steeg aanzienlijk gedurende de dag en stond kort boven $23, om uiteindelijk 2,46% hoger te sluiten op $22,92 per ounce.</p>
<p>De twee oliën zijn licht gestegen. WTI-ruwe olie begon te stijgen in de pre-US-sessie, bereikte een intraday hoogtepunt van $78,04 tijdens de handelssessie en daalde vervolgens lichtjes voordat deze uiteindelijk met 1,36% sloot op $77,53 per vat; Brent-ruwe olie sloot met 1,6% hoger op $82,74 per vat.</p>
<p>De Amerikaanse aandelenmarktindex sloot 0,91% hoger, de S&amp;P 500-index steeg met 0,58% en de Nasdaq steeg met 0,3%. Aandelen van blockchain-concepten sloten over het algemeen hoger, met Coinbase (COIN.O) die 3,3% steeg, Meta Platforms (META.O) die met 2,27% steeg, IBM (IBM.N) die met 1,78% steeg en AMD (AMD.O) die met 1,09% steeg.</p>
<p>Vanwege het koude weer in de Verenigde Staten blijven consumenten doorgaans thuis, en de daling van de detailhandelsverkopen in januari overtrof de verwachtingen aanzienlijk, wat twijfels opriep of de consumentenbestedingen aan het begin van het nieuwe jaar kunnen aanhouden.</p>
<p>De scherpe daling van de detailhandelsverkopen in de Verenigde Staten in januari werd voornamelijk veroorzaakt door de daling van de omzet van autodealers en benzinestations. Deze daling vond plaats na een relatief sterke prestatie tijdens het vakantieseizoen. De verkopen in december werden ook gedeeltelijk beïnvloed door seizoensgebonden factoren. Niet-gecorrigeerde detailhandelsverkopen dalen doorgaans in januari.</p>
<p>Morgan Stanley-econoom Daniel Silver zei: ‘Het is moeilijk om zeker te weten wat de ‘juiste’ seizoensfactoren zijn voor een bepaalde maand, maar in vergelijking met de seizoensfactoren die verband houden met deze twee maanden in voorgaande jaren, lijken de seizoensfactoren in december 2023 en januari 2024 ongebruikelijk. Bij het proberen de trend van de gegevens te bepalen, kunnen individuele seizoensaanpassingsveranderingen in deze maanden over het hoofd worden gezien.</p>
<p>Andere instellingen geloven dat de bewering van een onverwacht sterke Amerikaanse economie is verpletterd na gegevens die een onverwachte daling in de detailhandelsverkopen lieten zien. De CPI-gegevens van dinsdag zorgden ervoor dat handelaren hun weddenschappen op renteverlagingen uitstelden, terwijl de gegevens van vandaag aangeven dat de consumentenbestedingen afnemen, wat een dovish signaal is. Dit zal de Amerikaanse dollar verlagen en kan de aandelen die gevoelig zijn voor rentetarieven stimuleren.</p>
<p>Amerikaanse consumenten worden geconfronteerd met stijgende rentetarieven, aanhoudende inflatie en moeilijkheden bij het verkrijgen van krediet, omdat de tijdens de pandemie opgebouwde spaargelden opraken. Een lichtpuntje is echter dat de arbeidsmarkt in goede staat blijft. De sterke winstgevendheid van grote technologiebedrijven heeft ook de aandelenmarkt doen stijgen, wat heeft bijgedragen aan de toename van de welvaart van sommige Amerikanen.</p>
<p>Ondanks een reeks opmerkelijke ontslagen onlangs, voornamelijk in de technologie- en mediaindustrie, blijft het aantal mensen dat een werkloosheidsuitkering aanvraagt in de Verenigde Staten nog steeds op een laag niveau zweven. Als gevolg van de krappe arbeidsmarkt kunnen sommige ontslagen werknemers het gemakkelijk vinden om nieuwe banen te vinden. Tijdens en na de COVID-19-pandemie zijn de meeste bedrijven terughoudend om werknemers te ontslaan omdat ze het moeilijk vinden om vacatures in te vullen.</p>
<p>Op dit moment zijn er geen duidelijke tekenen van recessie in de Verenigde Staten, maar economen voorspellen over het algemeen dat de economische groei de komende maanden zal vertragen.</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 mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>