RGFnZWxpamtzIG5pZXV3cyB8IE9yZGluYWxzIFJlbGVhc2VzIEdlbmVzaXMgUnVuZSwgV29ybWhvbGUgYmVnaW50IG1ldCBoZXQgb3BlaXNlbiB2YW4gYWlyZHJvcHM7IERlIG5pZXV3ZSBmYXNlIHZhbiBoZXQgQXJiaXRydW0gRm91bmRhdGlvbiBGdW5kaW5nIFByb2dyYW07IERlIHdlcmVsZG1hcmt0IGlzIHZsYWs=

2024-04-01, 04:11

<p><img src="https://gimg2.gateimg.com/image/article/17119446131_2.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20De20oprichter20van20Ordinals20heeft20de20genesis20rune20uitgebracht20en20Wormhole20heeft20de20start20van20de20airdrop20claims20aangekondigd20De20derde20fase20van20het20Arbitrum20Foundation20financieringsprogramma653196"><a name="Crypto Daily Digest: De oprichter van Ordinals heeft de genesis rune uitgebracht en Wormhole heeft de start van de airdrop claims aangekondigd; De derde fase van het Arbitrum Foundation financieringsprogramma" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: De oprichter van Ordinals heeft de genesis rune uitgebracht en Wormhole heeft de start van de airdrop claims aangekondigd; De derde fase van het Arbitrum Foundation financieringsprogramma</h2><p>De markt is op vrijdag gesloten en er is geen handelsactiviteit voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETFs.</p>
<p>Casey, de oprichter van de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> NFT-protocol Ordinals, heeft het Runes-document uitgebracht, waardoor Bitcoin gegraveerde, geslagen en overgedragen inheemse digitale goederen kan verhandelen. Hoewel elke inie uniek is, is elke eenheid van de rune hetzelfde; ze zijn onderling verwisselbare tokens die geschikt zijn voor verschillende doeleinden.</p>
<p>Hij plaatste op het X-platform waarbij hij aangaf dat een goede eigenschap van runen is dat de terminologie voor het slaan zeer flexibel en expressief is. Naast het maximale aantal slaat, kunnen gebruikers ook de start- en eindtijden specificeren, die absolute blokhoogtes en relatieve bloktellingen zijn na het graveren.</p>
<p>Op 1 april kondigde Casey de release aan van de genesis Rune UNCOMMON•GOODS, die het minten zal openen na halvering tot het volgende halveringsblok, en een onbeperkt aantal runen met beperkte blokken zijn. Deze rune kan eenmaal worden gemint en heeft een scheidbaarheid van nul.</p>
<p>Het cross-chain protocol Wormhole heeft aangekondigd op het X-platform dat de airdrop claims zullen beginnen om 11:30 uur (UTC) op 3 april 2024.</p>
<p>Wormhole is een gedistribueerd en universeel cross-chain informatieoverdrachtsprotocol, met als doel vermogens- en informatieoverdracht tussen blockchain-netwerken te realiseren. Als communicatiemiddel voor blockchain of Rollups biedt dit protocol momenteel meer dan 30 liquiditeits- en gebruikerskanalen op mainstream blockchain-netwerken, die verschillende claimscenario’s bestrijken zoals DeFi, NFT en governance. In 2023 voltooide het een nieuwe financieringsronde met een waardering van $2,5 miljard.</p>
<p>De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Layer2-oplossing, Arbitrum, kan een nieuw financieringsprogramma lanceren. De Arbitrum Foundation heeft aangekondigd dat de tweede fase van haar financieringsprogramma, het Arbitrum Foundations Grants Program, is voltooid, met een deadline voor het claimen van 3 april 2024.</p>
<p>De derde fase staat op het punt te beginnen: nieuwe claims worden geaccepteerd vanaf 15 april 2024 en duren tot het einde van juni. In deze fase zal de stichting zich blijven concentreren op het dApp-gebied, maar zal het meer gestandaardiseerde financieringsmethoden introduceren, voornamelijk gericht op verticale projecten zoals gaming, NFT, social media, DAO, DeFi, enzovoort.</p>
<h2 id="h2-Markttrends20BTCs20horizontale20trend20op20hoog20niveau20het20ecosysteemproject20van20Solana20stijgt20snel474466"><a name="Markttrends: BTC’s horizontale trend op hoog niveau, het ecosysteemproject van Solana stijgt snel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC’s horizontale trend op hoog niveau, het ecosysteemproject van <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> stijgt snel</h2><p>Bitcoin (BTC) blijft boven de $70.000 en de algehele markt vertoont een opwaartse volatiliteitstrend. Op dit moment ligt de marktspeculatie voornamelijk op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en Base ecoen, terwijl er veel on-chain 100x muntprojecten zijn opgekomen. Op macro-economisch vlak was de Amerikaanse aandelenmarkt gesloten vanwege de paasvakantie, terwijl de Amerikaanse PCE (Persoonlijke Consumptie Uitgaven Prijsindex) inflatiegegevens aan de verwachtingen voldeden.</p>
<h3 id="h3-Markt20hotspots871732"><a name="Markt hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots</h3><p>De groei van het ecosysteem van Solana: de SOL-prijzen zijn aanzienlijk gestegen en hebben meer dan $200 bereikt, waardoor valuta’s zoals WIF, BOME, JUP, JTO en RAY voor Solana’s ecosysteemprojecten zijn gestegen. Het is vermeldenswaardig dat de marktwaarde van de Jito- en Jupiter-projecten op de Solana-keten vergelijkbare projecten Lido en overtroffen heeft. <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, in het Ethereum-ecosysteem. Bovendien is het Meme-project op de Solana-keten nog steeds actief, vooral met de opkomst van veel op katten lijkende Memes.</p>
<p>De Base Chain ontving aandacht: De talrijke Meme-projecten op de Base Chain trokken afgelopen weekend het grootste deel van de marktaandacht, waarbij MFER in slechts twee dagen 100 keer steeg. Op dit moment heeft het aantal adressen op de Base chain de 5,5 miljoen overschreden, en ook het transactievolume heeft een historisch hoogtepunt bereikt.</p>
<p>CORE stijging: De prijs van publieke keten CORE is in één week met meer dan 5 keer gestegen en negatieve tarieven tot -0,08% zijn verschenen in het Gate.io exchange contract, wat wijst op een duidelijk bearish sentiment op de markt.</p>
<p>Het stablecoin-protocol LQTY heeft een significante stijging gezien: de prijs van LQTY is in één dag met meer dan 20% gestegen en vanwege de impact van het aankomende ETHNA-project heeft de markt vroege weddenschappen geplaatst op vergelijkbare projecten.</p>
<p>LSDfi’s PENDLE heeft een historisch hoogtepunt bereikt: PENDLE heeft opnieuw een historisch hoogtepunt bereikt en de TVL (Total Value Locked) heeft ook een historisch hoogtepunt bereikt. Het opnieuw inzetten van de track blijft een van de meest opvallende verhalen in deze bullmarkt.</p>
<p>Over het algemeen zijn markt hotspots geconcentreerd in gebieden zoals het Solana-ecosysteem, het Base-ecosysteem en LSDfi. Beleggers moeten deze hotspots nauwlettend in de gaten houden en hun investeringsstrategieën tijdig aanpassen op basis van marktomstandigheden, terwijl ze voorzichtig reageren op marktrisico’s.</p>
<h2 id="h2-Macro20De20paasmarkt20vakantie20heeft20geleid20tot20een20saaie20markt20en20investeerders20wedden20dat20een20beperkt20aanbod20zal20leiden20tot20een20stijging20van20de20olieprijzen47983"><a name="Macro: De paasmarkt vakantie heeft geleid tot een saaie markt, en investeerders wedden dat een beperkt aanbod zal leiden tot een stijging van de olieprijzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De paasmarkt vakantie heeft geleid tot een saaie markt, en investeerders wedden dat een beperkt aanbod zal leiden tot een stijging van de olieprijzen</h2><p>Op 29 maart, als gevolg van meerdere landen die gesloten waren vanwege de Paasvakantie, vertoonde het wereldwijde handelsvolume een zwakke trend. De gegevens die afgelopen vrijdag zijn vrijgegeven door het Bureau voor Economische Analyse van het Amerikaanse ministerie van Handel toonden aan dat de prijsindex voor persoonlijke consumptie-uitgaven (PCE) in februari met 0,3% steeg, lager dan de 0,4% stijging die eerder werd voorspeld door economen die zijn ondervraagd door Reuters.</p>
<p>De Japanse yen bereikte op woensdag een dieptepunt van 151,975 ten opzichte van de Amerikaanse dollar, en herstelde zich iets ten opzichte van de Amerikaanse dollar op maandag, en steeg licht naar 151,315.</p>
<p>De publicatie van PCE-gegevens heeft de marktverwachtingen voor een renteverlaging in juni geconsolideerd, wat heeft geleid tot een relatief stabiele prestatie van de Amerikaanse dollar en de Japanse yen die het middelpunt van de marktaandacht zijn geworden. De USD/JPY-wisselkoers blijft rond 152 zweven, wat handelaren nerveus maakt over mogelijke risico’s voor de USD/JPY-wisselkoers en mogelijk ingrijpen vereist om de situatie te stabiliseren.</p>
<p>Met betrekking tot de Aziatische markt toonde Zuid-Korea in maart een zesde opeenvolgende maand van groei in de export van chips, waarbij de export met 3,1% toenam ten opzichte van dezelfde periode vorig jaar en 4,8% een maand geleden. Dit is ook een manifestatie van het momentum voor wereldwijd economisch herstel, aangezien de positie van Zuid-Korea op het gebied van halfgeleiders en andere hoogwaardige technologische producten het een barometer maakt van de wereldwijde vraag. Tegelijkertijd bekritiseerde China de Verenigde Staten omdat ze de regelgeving voor de export van halfgeleiders hebben aangescherpt, waarbij ze verklaarden dat deze regelgeving meer obstakels voor de handel heeft opgeleverd en meer onzekerheid heeft toegevoegd aan de chipindustrie.</p>
<p>Met betrekking tot grondstoffen worden de meeste recente stijgingen in olieprijzen nog steeds ondersteund door verwachtingen van een beperkt aanbod, aanvallen op Russische raffinaderijen en optimistische Chinese productiedata, ondanks een lichte daling van de olieprijzen op maandag.</p>
<p>De prijzen van Brent ruwe olie daalden met 17 cent, of 0,2%, tot $86,83 per vat, een stijging van 2,4% vorige week. De prijs van medium ruwe olie in West-Texas daalde met 11 cent, of 0,1%, tot $83,06 per vat, na een stijging van 3,2% vorige week.</p>
<p>De Russische vicepremier Alexander Novak verklaarde afgelopen vrijdag dat Rosneft zich in het tweede kwartaal zal richten op het verminderen van de productie in plaats van de export, om de vermindering gelijkmatig te verdelen met andere OPEC+-landen. Analisten wijzen erop dat de geopolitieke risico’s waarmee de levering van ruwe olie en zware grondstoffen wordt geconfronteerd, de sterke vraagfundamenten in het tweede kwartaal van de afgelopen 24 jaar hebben verergerd.</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 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 vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>