QXByaWwgQ3J5cHRvIE5hcnJhdGl2ZSBPdXRsb29rOiBTaGFwZWxsYSwgTGF5ZXIgMiwgTkZUJ3MgZW4gR2F0ZS5pbyBXZWIzIFBsYXRmb3Jtcw==

2023-04-23, 02:56

<p>April is hier, BTC heeft enigszins zijwaarts gehandeld, en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De Shapella-upgrade van Shapella is net boven de horizon te zien. Maar er is nog veel meer aan de hand, en nieuwe verhalen krijgen aandacht nu we het tweede kwartaal van 2023 ingaan.<br><img src="https://gimg2.gateimg.com/image/article/1682218308img_v2_8ff0f80c-b50b-42cd-98c7-88c157f726ch.jpg" alt=""></p>
<h2 id="h2-Ethereum2020grote20splash433495"><a name="Ethereum  grote splash" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> grote splash</h2><p>Allereerst, Shapella, de meest verwachte <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> upgrade sinds The Merge, staat gepland voor 12 april. Gelanceerd als een combinatie van de Shanghai- en Capella-upgrades, zal het validators in staat stellen hun ingezette ETH onder bepaalde voorwaarden op te nemen.</p>
<p>Hoewel sommigen zich zorgen maken dat de upgrade zal leiden tot massale opnames, is dit waarschijnlijk niet het g. The <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ontwikkelaars hebben een wachtrij-opnamesysteem geïmplementeerd, wat betekent dat alle validators niet massaal kunnen opnemen. Bovendien is het systeem ontworpen om geleidelijk de beloningsgraad te verhogen wanneer validators uittreden, waardoor nieuwe validators worden gestimuleerd om toe te treden.</p>
<p>Bovendien kan de upgrade innovaties in DeFi stimuleren, met name met vloeibare stakingsprotocollen die populair werden vanwege het bieden van een vorm van opneembare ETH-staking. Deze protocollen krijgen nu meer concurrentie met rechtstreeks staken op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en moet zich mogelijk aanpassen.</p>
<h2 id="h2-Arbitrum20staat20voor20nieuwe20uitdagingen724120"><a name="Arbitrum staat voor nieuwe uitdagingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Arbitrum staat voor nieuwe uitdagingen</h2><p>Na een succesvolle airdrop van meer dan $1 miljard aan ARB governance-tokens, werd Arbitrum geconfronteerd met zijn eerste gemeenschapsgovernance-voorstel AIP-1. Wat volgde was een hoop controverse, omdat het voorstel om 750 miljoen ARB-tokens toe te wijzen voor de operationele kosten van Arbitrum Foundation overweldigend werd tegengestemd. Voordat de stemming eindigde, had de Arbitrum Foundation al een klein deel van de 750 miljoen tokens uitgegeven.</p>
<p>De Arbitrum Foundation nam het standpunt in dat de stemming slechts een formaliteit was om de gemeenschap te informeren, waarbij werd aangegeven dat slechte communicatie tot het misverstand had geleid. Aan de andere kant stellen veel ARB-houders de bestuursmogelijkheden van hun ARB-tokens ter discussie. Als het grootste Layer 2-ecosysteem op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Met 65% van het marktaandeel is het interessant om te zien hoe de Arbitrum Foundation en ARB tokenhouders hun relatie kunnen herstellen naarmate we dieper de maand ingaan.</p>
<h2 id="h2-Decentralized20exchanges20krijgen20een20handout898208"><a name="Decentralized exchanges krijgen een handout" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Decentralized exchanges krijgen een handout</h2><p>Op het gebied van gedecentraliseerde financiën, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, ‘s werelds grootste gedecentraliseerde exchange, heeft zijn V3-code gratis beschikbaar gesteld voor andere exchanges om te gebruiken. Bijna onmiddellijk hebben andere gedecentraliseerde exchanges, zoals <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a> (CAKE), lanceerde hun eigen V3-versies gebaseerd op <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> V3. Ondertussen is Trader Joe (JOE), een vergelijkbare concurrent maar niet gebaseerd op de <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> De V3-codebase groeit veel sneller.</p>
<h2 id="h2-De20trend20van20Blur20zet20zich20voort20Yuga20Labs20x20Gucci323196"><a name="De trend van Blur zet zich voort, Yuga Labs’ x Gucci" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De trend van Blur zet zich voort, Yuga Labs’ x Gucci</h2><p>Bij het ingaan van april blijft Blur de nummer één NFT-marktplaats in marktaandeel op basis van volume, met alleen al in maart voor meer dan $2 miljard aan NFT’s verhandeld. Het model van het minimaliseren van kosten en het stimuleren van transacties door middel van beloningen in BLUR-tokens zal waarschijnlijk de NFT-markt blijven domineren.</p>
<p>Yuga Labs, het team achter enkele van de meest populaire NFT-collecties, zoals Bored Ape Yacht Club (BAYC), heeft een nieuwe samenwerking aangekondigd met het luxe megamerk Gucci. De twee zullen de KodaPendants-collectie uitbrengen, waarbij elk van de 3.333 NFT’s wordt gecombineerd met een zilveren Gucci-ketting. KodaPendant NFT’s zullen alleen beschikbaar zijn voor aankoop met <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a>, de inheemse cryptocurrency van Yuga Labs. Dit zou enige positieve aandacht kunnen trekken naar de token. Toch kan dit teniet worden gedaan door de volatiliteit die wordt veroorzaakt door een aankomende ontgrendeling op 17 april van meer dan $60 miljoen aan waarde. <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> in handen van Yuga Labs en zijn team.</p>
<h2 id="h2-Inspanningen20van20Hong20Kong20voor20regelgeving20van20crypto495989"><a name="Inspanningen van Hong Kong voor regelgeving van crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inspanningen van Hong Kong voor regelgeving van crypto</h2><p>Als een van ‘s werelds financiële centra trekt de verschuiving van Hong Kong naar meer crypto-vriendelijke regelgeving blockchain- en cryptobedrijven aan die strijden om de volgende grote vooruitgang in <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> te creëren. Dit heeft ertoe geleid dat in China gevestigde cryptocurrencies zoals Conflux (CFX) dit jaar enorme winsten hebben geboekt. Als we verder in Q2 gaan, kan meer goed nieuws over het streven van Hong Kong om ‘s werelds Web3-hub te worden, leiden tot meer prijsactie.</p>
<h2 id="h2-Web3gereedschappen20om20u20klaar20te20maken20voor20Web3563614"><a name="Web3-gereedschappen om u klaar te maken voor Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Web3-gereedschappen om u klaar te maken voor Web3</h2><p>In lijn met andere bedrijven die hun ontwikkeling in gedecentraliseerde technologie willen opvoeren, <a href="https://www.gate.io/signup/?ch=GM_blog_outlook_20230423&amp;utm_campaign=TR_ARH1Ll0C&amp;utm_content=&amp;utm_medium=ptr&amp;utm_source=CH_sApqy83F&amp;utm_term=" target="_blank">Gate.io</a> heeft dit jaar onlangs twee nieuwe Web3-ready platforms gelanceerd, de <a href="https://www.gate.io/signup/?ch=GM_blog_outlook_20230423&amp;utm_campaign=TR_ARH1Ll0C&amp;utm_content=&amp;utm_medium=ptr&amp;utm_source=CH_sApqy83F&amp;utm_term=" target="_blank">Gate.io</a> Web3-portemonnee en Gate Web3-perpetuals.</p>
<p>Met behulp van zero-knowledge technologie die super snelle en private on-chain eeuwigdurende contracthandel mogelijk maakt, is Gate Web3 Perpetuals een gedecentraliseerde eeuwigdurende exchange die de bekendheid, snelheid en volledige ervaring van gecentraliseerde exchanges naar de blockchain brengt. Als gevolg hiervan profiteren handelaren van een transparante en zelfbeheerde handelservaring met alle beveiliging van blockchain en zero-knowledge rollups.</p>
<p>Als aanvulling op de uitgave van zijn Perpetual DEX, <a href="https://www.gate.io/signup/?ch=GM_blog_outlook_20230423&amp;utm_campaign=TR_ARH1Ll0C&amp;utm_content=&amp;utm_medium=ptr&amp;utm_source=CH_sApqy83F&amp;utm_term=" target="_blank">Gate.io</a> Web3 Wallet is ontworpen en geoptimaliseerd voor multi-device gebruik in de opkomende wereld van Web3. Gebruikers kunnen gedecentraliseerde applicaties navigeren met self-custody crypto en naadloos gegevens overdragen tussen elk apparaat, alles beveiligd door meerdere lagen van versleuteling. De portemonnee ondersteunt een veelvoud aan ketens, waaronder <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain, GateChain, Heco, <a href="/price/cronos-cro" rel="nofollow noopener noreferrer" target="_blank">Cronos</a>, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, en meer.</p>
<p>Auteur: Global Marketing Aaron<br>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br>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 zullen juridische stappen worden ondernomen bij inbreuk op het auteursrecht.</p>