RGFnZWxpamtzIG5pZXV3cyB8IE1hcmt0IGZsdWN0dWVlcnQsIFNPTCdzIGVjb3N5c3RlZW0gc2NoaXR0ZXJ0IGhlbGRlcjsgSGFuZGVsc3ZvbHVtZSB2YW4gQXJiaXRydW0gVW5pc3dhcCBvdmVyc2NocmlqZHQgJDE1MEI7IE1ldGFNYXNrIGxhbmNlZXJkZSAnc2xpbW1lIGhhbmRlbCcgb20gRVRIJ3MgcHJldmVudGlldmUgaGFuZGVsIHR

2024-05-07, 04:06

<p><img src="https://gimg2.gateimg.com/image/article/17150547471_3.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Het20handelsvolume20van20Arbitrum20Uniswap20overschrijdt2015020miljard20MetaMask20lanceerde20slimme20handel20om20Ethereums20preventieve20handel20tegen20te20gaan225749"><a name="Crypto Daily Digest: Het handelsvolume van Arbitrum Uniswap overschrijdt $150 miljard; MetaMask lanceerde ‘slimme handel’ om Ethereum’s preventieve handel tegen te gaan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Het handelsvolume van Arbitrum <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> overschrijdt $150 miljard; MetaMask lanceerde ‘slimme handel’ om Ethereum’s preventieve handel tegen te gaan</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 gegevens van Farside Investor ontvingen op 6 mei Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) een instroom van $3,9 miljoen aan fondsen; Ondertussen was de instroom van Fidelity Bitcoin spot ETF (FBTC) $99,2 miljoen, de instroom van Bitwise Bitcoin spot ETF (BITB) $2,1 miljoen, en de instroom van ARK 21Shares Bitcoin spot ETF (ARKB) $75,6 miljoen.</p>
<p>Het totale transactievolume van Arbitrum op <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> is de grens van $150 miljard overschreden, waardoor het het eerste Layer 2-protocol is dat de drempel van DEX doorbreekt. Uniswap Labs kondigde maandag in een bericht op sociale media aan dat de cumulatieve transactievolume van Arbitrum begin mei $150,2 miljard had bereikt.</p>
<p>Volgens de blockchaingegevens van DeFiLlama bedraagt de totale waarde vergrendeld (TVL) van Arbitrum $2,64 miljard, waardoor het het grootste Layer 2-protocol is qua TVL, op één na Layer 1’s. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, BSC, Tron, en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>. Volgens de gegevens van DeFiLlama is Uniswap de grootste gedecentraliseerde beurs in termen van TVL, met een waarde van $5,54 miljard op 6 mei.</p>
<p>De belangrijkste medewerker van Arbitrum, Offchain Labs, heeft in maart van dit jaar de nieuwste geüpgradede versie van Layer 2 uitgebracht, genaamd Atlas. Volgens eerdere rapporten van The Block heeft deze upgrade ondersteuning toegevoegd voor bloktransacties om de kosten van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Layer 2-transacties te helpen verlagen.</p>
<p>De meest populaire versleutelde portemonnee van Ethereum, MetaMask, heeft deze week een nieuwe functie gelanceerd om gebruikers te helpen de impact van Maximum Extractable Value (MEV) te vermijden.<br>MEV verwijst naar de extra winsten die blockchain-operators behalen door transacties te bekijken of te herschikken voordat ze in het netwerk worden geschreven. Het lijkt soms op de vervelende praktijk van preventieve handelsorders in traditionele financiële markten. MEV heeft een grote impact op de werking van Ethereum, zoals het verhogen van gebruikersprijzen, het vertragen van transactiesnelheden en zelfs het veroorzaken van transactiefouten onder bepaalde netwerkcondities.</p>
<p>Deze nieuwe functie heet ‘slim handelen’, waarmee gebruikers transacties kunnen indienen bij een ‘virtuele geheugenpool’ voordat ze officieel op de keten staan. Volgens Consensys, het bedrijf achter MetaMask, zullen virtuele geheugenpools beschermen tegen bepaalde MEV-strategieën en achter de schermen transactiesimulaties uitvoeren om gebruikers te helpen lagere kosten te bereiken.</p>
<p>De oplossing van MetaMask vertoont enige overeenkomsten met private geheugenpools, die een steeds populairdere strategie zijn geworden om transactieprivacy te waarborgen en MEV te voorkomen, maar er kunnen risico’s van centralisatie zijn. Linehan, het hoofd van de afdeling Consensys Special Mechanism Group, gelooft dat intelligent handelen een ‘concrete eerste stap’ is naar de bredere visie van MetaMask.</p>
<p>Ondertussen wordt ook reikhalzend uitgekeken naar het voorstel van de Ethereum-gemeenschap, EIP-3074, om portefeuilles te verbeteren, een codeaanpassing gericht op het verbeteren van de bruikbaarheid van versleutelde portefeuilles.</p>
<p>Op dit moment zijn er twee portemonnee-accounts op Ethereum: de meest voorkomende zijn extern beheerde accounts (EOA), zoals MetaMask, en slimme contractaccounts, zoals Argent en Safe. De gebruiker van het EOA-account heeft een paar sleutels (openbare sleutel en privésleutel), terwijl het slimme contractaccount wordt gecontroleerd door code. Het belangrijkste probleem met EOA is menselijke fout; Als je de privésleutel van je EOA-account verliest, is er geen helpdesk of sleutelherstelproces dat je kan helpen om fondsen terug te krijgen.</p>
<p>EIP-3074 is weer een stap in de richting van dergelijke innovatie, omdat het handelsfuncties delegeert naar slimme contracten. Een essentieel onderdeel van dit voorstel is om gebruikers in staat te stellen bulktransacties uit te voeren en ze allemaal tegelijk te ondertekenen. Andere functies zijn onder meer het mogelijk maken van sponsoring van transactiekosten door derden voor gebruikers, zodat gedecentraliseerde applicaties (Dapps) gasvergoedingen voor gebruikers kunnen betalen.</p>
<h2 id="h2-Markttrends20BTC20schommelt20sterk20de20prestaties20van20het20ecosysteem20van20Solana20zijn20indrukwekkend684096"><a name="Markttrends: BTC schommelt sterk, de prestaties van het ecosysteem van Solana zijn indrukwekkend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC schommelt sterk, de prestaties van het ecosysteem van <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> zijn indrukwekkend</h2><p>BTC steeg gisteren tot een hoogtepunt van $65.500 in intraday handel, maar daalde vervolgens terug naar ongeveer $64.000, wat een brede en volatiele markttrend laat zien. Tegelijkertijd heeft Ethereum slecht gepresteerd vanwege een eenjarig dieptepunt in ketengasvergoedingen, wat lagere netwerkgebruikscijfers weerspiegelt. Op macro-economisch niveau is de Amerikaanse aandelenmarkt gestegen en blijven de vroege verwachtingen van renteverlagingen de markt beïnvloeden. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>.</p>
<h3 id="h3-Markt20Hotspots757647"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>De prestaties van het openbare Solana (SOL) blockchain-netwerk: De stijging van de SOL-prijzen heeft meerdere projecten in het Solana-ecosysteem gestimuleerd, waaronder Jupiter (JUP), Wifey (WIF) en Bomberman (BOME). Vooral in Solana’s recent aangekondigde hackathon-campagne, nadat het mijnbouwproject ORE het kampioenschap won, verdubbelde de prijs binnen een dag. ORE maakt gebruik van een lineaire mijnbouwstrategie, waarvan verwacht wordt dat het 40 jaar zal duren om 21 miljoen tokens te delven. Deze langetermijnmijnbouwstrategie kan een blijvende impact hebben op de marktprijzen.</p>
<p>Aanzienlijke stijging van ENA: De prijs van ENA is met 15% gestegen, en de markt speculeert dat de reden hiervoor zou kunnen zijn dat verschillende grote handelsplatformen - als belangrijke investeerders in ENA - mogelijk USDe-handelsparen zullen introduceren om het gebruiksscenario van USDe te vergroten. Deze maatregel zal rechtstreeks de liquiditeit en praktische toepasbaarheid van ENA verbeteren.</p>
<p>De algemene opkomst van AI-concepttokens: Met de verwachte release van ChatGPT 5 in juni en de Apple Developer Conference ook gepland voor juni, hebben AI-concepttokens de laatste tijd een algemene stijging gezien. De significante gebeurtenissen in deze reeks van technologische velden hebben de marktinteresse in AI-gerelateerde tokens gestimuleerd, en de markt kan tijdens deze periode vaak speculeren op deze AI-concepttokens.</p>
<p>De huidige cryptocurrency-markt bevindt zich in een dynamische staat van verandering, vooral met actieve projecten in de AI- en Solana-ecoen. Beleggers moeten letten op aankomende technologieproducten en ontwikkelaarsactiviteiten, die op korte termijn marktsentiment en prijsschommelingen zullen stimuleren. Ondertussen is het ook van vitaal belang om aandacht te besteden aan macro-economische indicatoren en beleidswijzigingen, zoals de renteverlaging van de Federal Reserve, bij het formuleren van beleggingsstrategieën. Beleggers moeten voorzichtig blijven en op gepaste wijze hoogvolatiele activa diversifiëren om potentiële risico’s te beheren.</p>
<h2 id="h2-Macro20Wall20Street20sloot20hoger20Aziatische20markten20bereikten20hoogtepunten20en20wereldwijde20markten20werden20gestimuleerd116162"><a name="Macro: Wall Street sloot hoger, Aziatische markten bereikten hoogtepunten en wereldwijde markten werden gestimuleerd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wall Street sloot hoger, Aziatische markten bereikten hoogtepunten en wereldwijde markten werden gestimuleerd</h2><p>Op 6 mei sloot de Amerikaanse aandelenindex hoger op maandag, steeg voor de derde opeenvolgende handelsdag omdat beleggers bleven hopen op de mogelijkheid van het verlagen van de rente door de Federal Reserve dit jaar. De Dow Jones-index steeg met 0,46%, de Standard&amp;Poor’s-index steeg met 1,03% en de Nasdaq-index steeg met 1,19%.</p>
<p>De markt daalde in april toen inflatie moeilijker bleek te zijn, en sommige investeerders begonnen zich zorgen te maken dat renteverlagingen mogelijk helemaal niet zouden worden bereikt.</p>
<p>Vrijdag bleek echter uit de gegevens dat de vertraging van de werkgelegenheidsgroei in de Verenigde Staten in april de verwachtingen overtrof, waardoor de druk op de Federal Reserve om de rentetarieven langer hoog te houden werd verlicht. Bovendien heeft de onverwachte stijging van het Amerikaanse bedrijfsresultatenseizoen nieuwe positieve momenten gebracht voor beleggers in de afgelopen handelsdagen.</p>
<p>Ondertussen verklaarde de Federal Reserve vorige week dat ze geneigd is om uiteindelijk de leenkosten te verlagen, maar hoopt ‘meer vertrouwen’ te krijgen dat de inflatie zal blijven dalen voordat de renteverlagingen worden doorgevoerd. Beleidsmakers herhaalden deze boodschap op maandag.</p>
<p>De meeste sectoren van de S&amp;P 500 index stegen. Het energie-index was een van de grootste stijgingen, mede door de Amerikaanse aardgasfutures die hun hoogste niveau in 14 weken bereikten.</p>
<p>De Aziatische markt is ook relatief optimistisch. Op 7 mei bereikte de Aziatische aandelenmarkt op dinsdag een 15-maands hoogtepunt omdat het vertrouwen in Amerikaanse renteverlagingen weer opkwam, terwijl handelaren wachtten op een beleidsvergadering die later die dag in Australië zou worden gehouden en nauwlettend de depreciatie van de yen in de gaten hielden.</p>
<p>De MSCI Asia Pacific aandelenindex steeg met 0,3% in de vroege handel. Veel vastelandse beleggers die kochten, stimuleerden de Hang Seng Index, terwijl de Hong Kong aandelenmarkt licht daalde, met meer dan 14% stijging gedurende 10 opeenvolgende dagen, de langste opeenvolgende stijging sinds 2018. De Nikkei spotindex in Japan steeg ‘s nachts met 1%.</p>
<p>De Reserve Bank of Australia kan zich tot haviken wenden: er wordt algemeen verwacht dat de Reserve Bank of Australia (RBA) de rentetarieven ongewijzigd zal handhaven op haar beleidsvergadering later op dinsdag, maar de focus zal liggen op de vraag of het vooruitzicht zal verschuiven om de mogelijkheid van renteverhogingen op te nemen na onverwachte inflatie.</p>
<p>Wat betreft de handel in grondstoffen zijn de olieprijzen licht gestegen, waarbij Brent-ruwe-olie-futures met 0,3% zijn gestegen tot $ 83,58 per vat, en een wapenstilstandsovereenkomst in het Midden-Oosten is moeilijk te bereiken.</p>
<p>Goud steeg ‘s nachts en stabiliseerde zich op $2.325 per ounce op dinsdag.</p>
<p><a href="/how-to-buy/nucypher-nu" rel="nofollow noopener noreferrer" target="_blank">hoe NuCypher te kopen</a> <a href="/how-to-buy/nucypher-nu" rel="nofollow noopener noreferrer" target="_blank">hoe NuCypher te kopen</a> Auteur:<br><strong>Sherry S. &amp; Icing</strong>, Gate.io Onderzoeker<br><a href="/how-to-buy/nucypher-nu" rel="nofollow noopener noreferrer" target="_blank">hoe koop ik NuCypher</a> Vertaler: Joy Z.<br><a href="/how-to-buy/nucypher-nu" rel="nofollow noopener noreferrer" target="_blank">hoe NuCypher te kopen</a><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadviezen.<br><a href="/how-to-buy/nucypher-nu" rel="nofollow noopener noreferrer" target="_blank">hoe NuCypher te kopen</a></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br><a href="/how-to-buy/nucypher-nu" rel="nofollow noopener noreferrer" target="_blank">hoe NuCypher te kopen</a></p>
<div class="blog-details-info"><p></p><br></div>