RGFnZWxpamtzIG5pZXV3cyB8IEV0aGVyZXVtIERlbmN1biBVcGdyYWRlcyBrdW5uZW4gZGUgdmVyd2Vya2luZ3Nrb3N0ZW4gdmVybGFnZW4gdG90IDA7IFRlc2xhIHdvcmR0IHZlcmRhY2h0IDEuNzg5IGV4dHJhIEJUQydzIHRlIGhlYmJlbiBnZWtvY2h0OyBEbyBLd29uIHphbCB3b3JkZW4gdWl0Z2VsZXZlcmQgYWFuIFp1aWQtS29yZWE

2024-03-08, 05:09

<p><img src="https://gimg2.gateimg.com/image/article/17098745171_6-05.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Ethereum20Dencunupgrade20kan20L2handelskosten20verlagen20tot20020Tesla20koopt20178920BTCs20Terraoprichter20Do20Kwon20zal20worden20uitgeleverd20aan20ZuidKorea20voor20berechting356843"><a name="Crypto Daily Digest: Ethereum Dencun-upgrade kan L2-handelskosten verlagen tot 0; Tesla koopt 1.789 BTC’s; Terra-oprichter Do Kwon zal worden uitgeleverd aan Zuid-Korea voor berechting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Dencun-upgrade kan L2-handelskosten verlagen tot 0; Tesla koopt 1.789 BTC’s; Terra-oprichter Do Kwon zal worden uitgeleverd aan Zuid-Korea voor berechting</h2><p>Laten we eerst eens kijken naar de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens Farside Investor-gegevens, op 7 maart, bleven de GBTC-fondsen van Grayscale doorgaan met <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> aanzienlijk gestegen, tot $374,8 miljoen; Ondertussen was de instroom van Bitwise <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (BITB) $40,5 miljoen, de instroom van ARK 21Shares Bitcoin spot ETF (ARKB) was $42,1 miljoen en de nettostroom van WisdomTree Bitcoin spot ETF (BTCW) was $6,6 miljoen.</p>
<p>Volgens Cointelgraph hebben spot Bitcoin ETF’s unieke invloed op de aanbod-dynamiek. De stabiele koopdruk heeft geleid tot ongekende verschijnselen, waaronder het bereiken van historische hoogtepunten vóór de halvering.</p>
<p>Timothy Peterson, oprichter en beleggingsmanager van Cane Island Alternative Advisors, analyseerde de huidige trend en verklaarde dat de vraag naar ETF’s Bitcoin mogelijk al in 2024 naar zes cijfers zou kunnen brengen. Op 7 maart vertelde hij abonnees op X: ‘De goedkeuring van Bitcoin spot ETF’s lijkt een accumulatie te hebben veroorzaakt, en als dit doorgaat, zal de prijs van Bitcoin tegen oktober 2024 $100.000 bereiken.’</p>
<p>Ondertussen heeft een speciale ‘blauwe walvis’-operatie ook aandacht getrokken - volgens Arkham-monitoring is de Bitcoin-portemonnee-trackingfunctie van Tesla onlangs toegevoegd aan het gegevensdashboard. De BTC-portemonnee die verband houdt met Tesla toont een saldo van 11.509 BTC, ongeveer 1.789 BTC meer dan het saldo van 9.720 BTC dat werd gemeld in het laatste financiële rapport.</p>
<p>Gebruikers van het X-platform vragen: “Is Tesla weer begonnen met het kopen van Bitcoin?” of dat de recente digitale veranderingen te wijten zijn aan boekhoudkundige fouten. Sommige gebruikers hebben gereageerd op de discussie dat Tesla mogelijk is begonnen met het kopen van BTC na de laatste financiële conference call en mogelijk verslag uitbrengt over de nieuw gekochte BTC in de volgende financiële conference call. Momenteel hebben Tesla en Elon Musk geen commentaar gegeven op de vraag of Tesla Bitcoin zal kopen.</p>
<p>De Dencun-upgrade van de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De lancering van blockchain staat gepland voor 13 maart, wat de eerste stap is naar de uitvoering van een Rollup-gerichte routekaart en het netwerk in staat zal stellen om te fungeren als de geschikte database voor de Layer 2 blockchain om gegevens efficiënter en goedkoper op te slaan. Rollup is een Ethereum-protocol dat, als schaalbaarheidsoplossing, transacties apart verwerkt van het mainnet om de snelheid te verbeteren en de kosten te verlagen.</p>
<p>In een onderzoeksrapport op woensdag verklaarde Fidelity Digital Assets dat deze upgrade de schaalbaarheid zal bieden die nodig is om miljoenen gebruikers op de layer 2-blockchain te ondersteunen, waardoor het een “meer geschikte gedistribueerde database voor andere blockchains” wordt. Deze verbeteringen zullen naar verwachting meer gebruikers in het Ethereum-ecosysteem brengen en de totale potentiële markt (TAM) van het netwerk uitbreiden.</p>
<p>“Analist Max Wadington schreef: ‘De verbetering van Ethereum als een database biedt Layer 2-gebruikers de mogelijkheid om nul transactiekosten te benaderen, wat ongetwijfeld meer gebruikers zal aantrekken.’”</p>
<p>Het rapport stelt echter dat de upgrade geen directe positieve impact zal hebben op Ethereum-gebruikers, aangezien de beloofde kostendaling voor Layer 2-gebruikers geen invloed zal hebben op transacties op de onderliggende Ethereum-blockchain.</p>
<p>De recente upgrade van Dencun heeft ook positief nieuws gebracht voor ETH-prijzen en het ecosysteem van Ethereum. Momenteel heeft ETH de $3.900 overschreden en wordt gemeld op $3.904,3.</p>
<p>De failliete medeoprichter van Terraform Labs, Do Kwon, kan worden uitgeleverd aan zijn thuisland, Zuid-Korea, in plaats van de Verenigde Staten, waar hij geconfronteerd zal worden met aanklachten. Volgens lokale media heeft het hof van beroep de eerdere beslissing van de Podgorica High Court in Montenegro om Kwon uit te leveren aan de Verenigde Staten teruggedraaid, onder vermelding van ‘ernstige schendingen van de voorschriften voor strafvordering’.</p>
<p>Volgens The Wall Street Journal gaf Kwon te kennen dat hij wil worden uitgeleverd aan Zuid-Korea. Hij wordt naar verluidt geconfronteerd met maximaal 40 jaar gevangenisstraf in het land. Terraform Labs heeft op 21 januari faillissement aangevraagd in de Verenigde Staten. De <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Het ecosysteem stortte in mei 2022 in. Na de ineenstorting verscheen Kwon niet totdat hij werd gearresteerd in Montenegro, waar hij naar verluidt een vals paspoort gebruikte om naar Dubai te reizen.</p>
<h2 id="h2-Markttrends20Solanas20onchain20ecoen20gaan20viraal20en20AIconcepten20hebben20dringend20leidende20tokens20nodig20om20voorop20te20lopen767315"><a name="Markttrends: Solana’s on-chain ecoen gaan viraal, en AI-concepten hebben dringend leidende tokens nodig om voorop te lopen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Solana’s on-chain ecoen gaan viraal, en AI-concepten hebben dringend leidende tokens nodig om voorop te lopen</h2><p>De prijzen van BTC en Ethereum vertonen allebei een stijgende trend, en Ethereum staat op het punt de Cancun-upgrade te ondergaan, wat de aandacht van de markt trekt. Ondertussen groeit het ecosysteem op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De keten gedijt ook goed, wat leidt tot een verschuiving in marktsentiment richting hype over de Solana-keten.</p>
<p>Op macro niveau heeft de Amerikaanse aandelenmarkt een opwaartse trend laten zien, met AI gigant Nvidia die een historisch hoogtepunt heeft bereikt, wat schadelijk kan zijn voor de AI concept tokens in cryptocurrencies.</p>
<h3 id="h3-Markt20hotspots162249"><a name="Markt hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots</h3><p>De prijs van SOL-tokens is gestegen en projecten in het Solana-ecosysteem, zoals JUP en RAY, hebben ook aanzienlijke stijgingen gezien. Volgens rapporten bereidt Pantera Capital zich voor om voor $250 miljoen aan SOL-tokens van de FTX-beurs te kopen, wat een van de redenen kan zijn waarom de SOL-prijs de $145 heeft overschreden. Ondertussen lanceerde Jupiter Exchange Genesis-voting, waarbij JUP-tokens worden gestaked om Launchpad-fee rewards te ontvangen, wat de JUP-prijzen aanzienlijk verhoogt. De positie van JUP in het Solana-ecosysteem kan worden geanalyseerd als de positie van UNI in het Ethereum-ecosysteem.</p>
<p>Projecten in het Layer1-veld, zoals RUNE, SEI, FTM, etc., hebben ook prijsstijgingen meegemaakt. Volgens rapporten zal Sei V2 Ethereum Virtual Machine (EVM) ondersteunen.</p>
<p>AI-concepttokens zoals MDT en NFP zijn ook aanzienlijk gestegen. Het is te zien dat de fondsen van AI-concepttokens wegvloeien uit projecten aan de frontlinie, zoals WLD, FET, AGIX, enz., en naar projecten van de derde en vierde rang. Het moet echter worden opgemerkt dat de markt voor AI-concepten op korte termijn mogelijk niet duurzaam is, tenzij er tekenen zijn dat het toonaangevende project WLD opnieuw de markt leidt.</p>
<p>Het Meme-concept token blijft dalen, maar de prestaties van PEPE zijn relatief sterk. Musk reageerde op informatie gerelateerd aan PEPE op Twitter, en de makers van PEPE zijn ook van plan nieuwe PEPE NFT’s te lanceren, die allemaal de prestaties van PEPE-tokens ondersteunen.</p>
<p>Samenvattend zijn er meerdere hete onderwerpen opgedoken in de huidige markt, waaronder projecten in het Solana-ecosysteem, het Layer1-veld, AI-concepttokens, enz. Investeerders moeten deze hete onderwerpen nauwlettend volgen en op basis van de marktomstandigheden overeenkomstige investeringsbeslissingen nemen.</p>
<h2 id="h2-Macro20Verwachtingen20van20renteverlagingen20hebben20geleid20tot20een20daling20van20de20Amerikaanse20dollar20Hongkong20de20Filipijnen20en20andere20regios20ondersteunen20CBDC20digitale20valuta20Goud20en20olieprijzen20maken20een20stijging20door667633"><a name="Macro: Verwachtingen van renteverlagingen hebben geleid tot een daling van de Amerikaanse dollar; Hongkong, de Filipijnen en andere regio’s ondersteunen CBDC digitale valuta; Goud- en olieprijzen maken een stijging door" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Verwachtingen van renteverlagingen hebben geleid tot een daling van de Amerikaanse dollar; Hongkong, de Filipijnen en andere regio’s ondersteunen CBDC digitale valuta; Goud- en olieprijzen maken een stijging door</h2><p>Aan de wereldwijde marktzijde had de markt vrijdag meer vertrouwen in renteverlagingen vanwege de verklaring van Federal Reserve-voorzitter Jerome Powell over renteverlagingen in de komende maanden. De Amerikaanse dollar maakte vrijdag de grootste wekelijkse daling van het jaar mee, terwijl de Japanse yen steeg vanwege toenemende speculatie over renteverhogingen.</p>
<p>Japanse handelaren zijn gespannen, met lichte schommelingen in de Aziatische ochtendhandel, in afwachting van de Amerikaanse werkgelegenheidsgegevens later op de dag. Dit kan verdere bevestiging geven van de marktverwachtingen voor renteverlagingen in de VS in juni.</p>
<p>Internationaal is er nieuw nieuws over de ontwikkeling van digitale valuta. Op 7 maart kondigde de Hong Kong Monetary Authority de lancering aan van een nieuw project voor centrale bank digitale valuta (wCBDC) op groothandelsniveau, genaamd Ensemble, om de ontwikkeling van de tokenisatiemarkt in Hong Kong te ondersteunen.</p>
<p>Het Ensemble-project richt zich op de wCBDC “Sandbox” die de Monetaire Autoriteit dit jaar zal lanceren, waarbij verder onderzoek en testen worden uitgevoerd naar tokenisatieglen, waaronder de afwikkeling van getokeniseerde reële activa (zoals groene obligaties, vrijwillige emissiereducties, vliegtuigen, oplaadstations voor elektrische voertuigen, elektronische vrachtbrieven en financieel beheer), die waarschijnlijker zullen uitgroeien tot nieuwe infrastructuur voor de financiële markt als brug tussen getokeniseerde reële activa en getokeniseerde valuta’s bij transacties.</p>
<p>Ensemble is een belangrijk onderdeel van de reeks maatregelen van de HKMA ter bevordering van de ontwikkeling van de tokenisatiemarkt. Het project is ook gebaseerd op een tokenized deposit use case experiment uitgevoerd door de Monetaire Autoriteit in 2023 met HSBC, Hang Seng Bank en Ant Group. De Monetaire Autoriteit zal relevante internationale belanghebbenden, waaronder andere centrale banken en organisaties, uitnodigen om deel te nemen aan toekomstige wCBDC ‘Sandbox’-experimenten en onderzoek.</p>
<p>Als de “Sandbox” van wCBDC een positieve reactie van de industrie kan ontvangen, zal de Monetaire Autoriteit wCBDC tijdig uitgeven.</p>
<p>Ondertussen heeft een functionaris van de Bangko Sentral ng Pilipinas (BSP) ook meer details onthuld over het plan van de centrale bank om de wholesale digitale valuta van de centrale bank (wCBDC) te bestuderen. Mamerto Tangonan, vice-gouverneur van de afdeling Betaling en Monetair Beheer van de Centrale Bank, verklaarde tijdens een persconferentie op 6 maart dat het pilotproject wCBDC genaamd Project Agila tegen het einde van dit jaar zal worden voltooid. De Federal Reserve heeft echter aangegeven dat het mogelijk geen steun zal verlenen aan de uitgifte van digitale valuta in de Verenigde Staten.</p>
<p>Wat betreft de goudprijzen wordt verwacht dat het de grootste wekelijkse stijging in vijf maanden zal zien en in de buurt van historische hoogtepunten zal blijven zweven. De opmerkingen van Federal Reserve-voorzitter Jerome Powell hebben de weddenschap op een renteverlaging in het midden van het jaar versterkt en er zal later een belangrijk werkgelegenheidsrapport worden vrijgegeven. Op dit moment, om 03:50 Greenwich Mean Time, wordt spotgoud geprijsd op $2.157,16 per ounce en zweeft rond het historische hoogtepunt van $2.164,09 dat op de vorige handelsdag werd bereikt.</p>
<p>Met betrekking tot grondstoffen zijn de olieprijzen op vrijdag gestegen als gevolg van de toegenomen vraag van China en de Verenigde Staten, ‘s werelds grootste consumentenlanden. Tegelijkertijd gaf de Federal Reserve een positief signaal af over de mogelijkheid van renteverlagingen. Brent ruwe olie futures stegen met 0,6%, of 49 cent, tot $83,45 per vat. West Texas Intermediate ruwe olie futures in de Verenigde Staten stegen met 0,7%, of 60 cent, tot $79,53.</p>
<p>Deze week zijn beide contracten echter licht gedaald, waarbij Brent ruwe olie en WTI respectievelijk met 0,1% en 0,5% zijn gedaald.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S.</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 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 auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>