RGFnZWxpamtzIG5pZXV3cyB8IFJ1bmUgc3BlY3VsYXRpZSB2ZXJob29ndCBCVEMgaGFuZGVsc2tvc3RlbjsgV29ybGRjb2luIGxhbmNlZXJ0IEwyLW5ldHdlcmsgV29ybGRDaGFpbjsgSnVwaXRlcidzIHR3ZWVkZSByb25kZSB2YW4gTEZHIExhdW5jaHBhZCBzdGVtbWVuIGJlZ2ludA==

2024-04-18, 04:20

<p><img src="https://gimg2.gateimg.com/image/article/171341398418.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Rune20speculatie20drijft20BTC20handelskosten20omhoog20Worldcoin20lanceerde20een20Layer220netwerk20World20Chain20Jupiters20tweede20ronde20van20LFG20Launchpad20stemming20begint642333"><a name="Crypto Dagelijks Overzicht: Rune speculatie drijft BTC handelskosten omhoog; Worldcoin lanceerde een Layer-2 netwerk World Chain; Jupiter’s tweede ronde van LFG Launchpad stemming begint" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Rune speculatie drijft BTC handelskosten omhoog; Worldcoin lanceerde een Layer-2 netwerk World Chain; Jupiter’s tweede ronde van LFG Launchpad stemming begint</h2><p>Laten we eerst de handelsactiviteit van onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens Farside Investor-gegevens had Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 6 maart een uitstroom van $133,1 miljoen. Ondertussen was er een instroom van $18,1 miljoen voor iShares Trust Bitcoin Spot ETF (IBIT), een uitstroom van $7,3 miljoen voor Bitwise Bitcoin Spot ETF (BITB), een uitstroom van $42,7 miljoen voor ARK 21Shares Bitcoin Spot ETF (ARKB), en een netto instroom van $6,6 miljoen voor WisdomTree Bitcoin Spot ETF (BTCW).</p>
<p>Runes is een nieuw protocol voorgesteld door Bitcoin ontwikkelaar Casey Rodarmor. Het belangrijkste idee is om alternatieve token transacties te implementeren op het Bitcoin netwerk. Net als BRC-20 heeft Runes tot doel om nieuwe tokens verhandelbaar te maken op het Bitcoin netwerk. Runes zal het UTXO-model gebruiken, wat betekent dat het een effectievere implementatie van token uitgifte zou moeten zijn om netwerkcongestie te verminderen.</p>
<p>Volgens gegevens van CryptoSlam heeft de Rune Expectations-markt groot succes geboekt, waarbij de PUPS-token (momenteel BRC-20) deze maand in miljoenen dollars per dag wordt verhandeld. Dit is de op een na meest NFT/BRC-20-serie in de afgelopen zeven dagen. Elke BRC-20 PUPS-token zal eigendom hebben van de PUPS Runes-token, die wordt omgezet zodra Runes wordt geactiveerd.</p>
<p>Al deze rune-hype-activiteiten hebben natuurlijk de transactiekosten van Bitcoin opgedreven. Het 7-daags voortschrijdend gemiddelde van de gemiddelde online transactiekosten is gestegen van $4,11 aan het begin van deze maand naar de huidige $12,17.</p>
<p>Worldcoin staat op het punt zijn eigen L2 te lanceren: World Chain. Worldcoin streeft ernaar het grootste financiële en identiteitsnetwerk te worden. Kort voor de bètaversie van Worldcoin in juli 2023 geloofde het team dat de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> roll-up was volwassen genoeg en migreerde naar het OP-mainnet, inclusief ongeveer 2 miljoen gebruikers van wereldmunten.</p>
<p>Echter, na de daadwerkelijke lancering gelooft Worldcoin dat er nog vele gebieden zijn die verbetering behoeven. Hoewel Worldcoin de eerste grootschalige toepassing was die werd gelanceerd op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> L2 (nog steeds de grootste toepassing tot op heden), bevindt het L2-ecosysteem zich nog in de beginfase voor grootschalige toepassingen.</p>
<p>The World Chain is een OP Stack-keten met als voornaamste doel de schaal ervan uit te breiden. In de nabije toekomst is het doel om de Gaslimiet van Layer 2-blokken aanzienlijk te verhogen. Worldcoin is van mening dat L2 een nieuwe ruimte voor compromissen kan bieden en hoopt actief te onderzoeken hoe Reth kan worden gebruikt als een ‘native L2’-uitvoeringsclient om snel de prestaties in grootschalige productieomgevingen te verbeteren.</p>
<p>Naast verbeteringen in de uitvoeringslaag onderzoekt World Chain ook andere gegevensbeschikbaarheidslagen (DA), waaronder DA vergelijkbaar met Plasma.</p>
<p>De DeFi-aggregator Jupiter op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> wordt gestemd over de volgende reeks kandidaat-projecten voor LFG Launchpad, en de projecten die de stemming doorstaan zullen worden gelanceerd in mei en juni. Er zijn zes projectkandidaten, waaronder het liquiditeitsaggregatieprotocol Sanctum, het gedeelde netwerk UpRock, het gedecentraliseerde energienetwerk Srcful, het geïntegreerde DEX-project MonkeyDex, het AAA-niveau spel Nyan Heroes, en het on-chain reputatiesysteem <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> ID. Deze stemronde eindigt op 21 april.</p>
<p>Stemmen om het beste project te selecteren om op Jupiter te lanceren is cruciaal, aangezien deelname aan DAO-governance 0,75% van de tokenvoorraad zal opleveren, ongeacht voor welk project gebruikers stemmen of dat het uiteindelijk wordt gelanceerd.</p>
<h2 id="h2-Markttrends20BTC20zakte20ooit20onder20de20206000020minder20dan20twee20dagen20verwijderd20van20de20Bitcoinhalvering805141"><a name="Markttrends: BTC zakte ooit onder de $ 60.000, minder dan twee dagen verwijderd van de Bitcoin-halvering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC zakte ooit onder de $ 60.000, minder dan twee dagen verwijderd van de Bitcoin-halvering</h2><p>Gisteren daalde Bitcoin kortstondig onder de $60.000, terwijl BTC-spot-ETF’s gedurende drie opeenvolgende dagen netto uitstroomden. Ondertussen daalde de wisselkoers van Altcoins niet mee met de daling van Bitcoin en was hun relatieve prestatie relatief sterk. Minder dan twee dagen verwijderd van de halvering van Bitcoin.</p>
<p>Wat betreft de macro-economie heeft de Amerikaanse aandelenmarkt een aanzienlijke daling meegemaakt, waarbij technologieaandelen de daling leidden. De markt is aanzienlijk beïnvloed door de verzwakkende verwachting van de renteverlaging door de Federal Reserve.</p>
<h2 id="h2-Markt20Hotspots283775"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h2><p>Gate.io heeft een nieuwe munt gelanceerd, OMNI: Na de lancering van OMNI is de prijs met 50% gedaald. Omini is een cross Rollup interoperabiliteitsprotocol gebouwd op het Ethereum re-staking protocol EigenLayer, met als doel de liquiditeit van verschillende Layer2 te integreren. In de context van een algemene daling op de gehele markt, neemt ook de on-chain handel af.</p>
<p>Openbare blockchain SUI steeg sterk: Volgens marktnieuws leidde de samenwerking tussen Sui Network en zijn dochteronderneming ByteDance tot een sterke stijging van de prijzen van de openbare blockchain-token SUI.</p>
<p>GHST van de GameFi sector is gestegen: Volgens officieel nieuws zal GHST een Base Chain lanceren en zijn eigen Layer3-netwerk ontwikkelen, waardoor de GHST-prijzen aanzienlijk stijgen.<br>Samengevat toont de algehele markt een neerwaartse trend, maar sommige hete sectoren en projecten laten nog steeds een opwaartse trend zien. Investeerders moeten de markttrends nauwlettend volgen en voorzichtige beslissingen nemen.</p>
<h2 id="h2-Macro20Hoge20rentetarieven20blijven20een20bedreiging20vormen20voor20de20wereldwijde20markt20De20Verenigde20Staten20Japan20en20ZuidKorea20lanceerden20een20trilateraal20protocol20inzake20valutainterventie143376"><a name="Macro: Hoge rentetarieven blijven een bedreiging vormen voor de wereldwijde markt; De Verenigde Staten, Japan en Zuid-Korea lanceerden een trilateraal protocol inzake valuta-interventie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Hoge rentetarieven blijven een bedreiging vormen voor de wereldwijde markt; De Verenigde Staten, Japan en Zuid-Korea lanceerden een trilateraal protocol inzake valuta-interventie</h2><p>Op 18 april bleef de politieke situatie en de hoge rente de markt onder druk zetten, waarbij investeerders geloofden dat de Amerikaanse rente op de lange termijn hoog zou blijven op 4%. Vanwege de onzekerheid over rentetarieven en winsten bleef het sentiment van investeerders laag. Op dinsdag hebben Amerikaanse centrale bankfunctionarissen, waaronder voorzitter van de Federal Reserve Powell, niet langer aangegeven wanneer de rentetarieven zouden worden verlaagd, maar verklaarden dat het monetair beleid langere beperkingen vereist.</p>
<p>Op 17 april onderging de Amerikaanse aandelenmarkt een volatiele daling op woensdag als gevolg van investeerders die de rentestand van de Federal Reserve en een reeks zwakke financiële rapporten aan het begin van het kwartaalcijferseizoen ueerden. De Amerikaanse dollar daalde lichtjes ‘s nachts, terwijl er een “drielandenprotocol” werd bereikt tussen de Verenigde Staten, Japan en Zuid-Korea, waarin werd overeengekomen “nauwe raadplegingen” te houden over de valutamarkt in de eerste drielanden financiële dialoog, waarin zorgen van Tokio en Seoul werden erkend over de recente aanzienlijke depreciatie van hun valuta.</p>
<p>Het driepartijenprotocol zal waarschijnlijk de deur openen voor interventiemaatregelen om de stijging van de Amerikaanse dollar in Azië af te remmen.</p>
<p>De prestaties van de drie belangrijkste indexen zijn als volgt: de Dow Jones-index daalde met 0,12%, de S&amp;P 500-index daalde met 0,58% en de Nasdaq-index daalde met 1,15%.</p>
<p>Volgens de Brown Book Economic Activity Survey van de Federal Reserve is de economische activiteit tussen eind februari en begin april licht toegenomen, maar bedrijven maken zich zorgen dat de vooruitgang bij het verminderen van de inflatie zal stagneren.</p>
<p>De FedWatch-tool van CME laat zien dat de markt begint de verwachtingen van een renteverlaging door de Federal Reserve in juni grotendeels te verwerken, waarbij de verwachting van een renteverlaging van minstens 25 basispunten daalt tot 16,8% en de verwachting van een renteverlaging in juli daalt tot 46%.</p>
<p>Als gevolg van de sterke veiling van 20-jarige schatkistobligaties daalde het rendement van schatkistobligaties verder van de hoogste stand van de vorige dag in verschillende maanden, en herstelde de aandelenmarkt zich van zijn daling, waarbij de laatste prijs van 10-jarige schatkistobligatie ongeveer 4,59% was.</p>
<p>Op donderdag stegen Aziatische aandelenmarkten lichtjes in gemengde handel, terwijl de Amerikaanse dollar een adempauze nam toen investeerders de rentevooruitzichten heroverwogen en de obligatiemarkt stabiliseerde. De MSCI Asia Pacific aandelenindex, de meest gebruikte buiten Japan, steeg met 0,4%, maar de regionale trend is ongelijk. De Nikkei-index in Japan daalde met 0,4% en is deze week met 4,3% gedaald, mogelijk de grootste wekelijkse daling sinds december 2022.</p>
<p>Wat betreft grondstoffen, stegen de futureprijzen voor Brent ruwe olie met 10 cent, of 0,11%, tot $87,39 per vat, terwijl de futureprijzen voor Amerikaanse ruwe olie met 2 cent stegen tot $82,71 per vat. Als gevolg van zorgen over de vraag daalden de twee benchmark indices met 3% op de vorige handelsdag. Een deel van de reden hiervoor is het wegebben van zorgen over de oliesancties tegen Iran en het uitblijven van een duidelijke reactie van Israël of de Verenigde Staten op de aanvallen van Iran in het weekend.</p>
<p>De prijs van goud ligt iets onder het historische hoogtepunt van vorige week van $2.366 per ounce.</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 mening 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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>