RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBibGlqZnQgc2Nob21tZWxlbiw7IFJ1bmVzIGhhbmRlbHNhY3Rpdml0ZWl0IGFhbnppZW5saWprIHZlcm1pbmRlcmQ7IExheWVyIDMgemFsIHRva2VuIGFpcmRyb3BzIHZyaWpnZXZlbjsgV2FsbCBTdHJlZXQgc2xvb3QgaG9nZXI=

2024-05-13, 04:31

<p><img src="https://gimg2.gateimg.com/image/article/17155746671_6-06.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Analisten20geloven20dat20BTC20tot20juni20negatief20zal20blijven20presteren20De20handelsactiviteit20van20het20Runesprotocol20is20aanzienlijk20afgenomen20Layer20320zal20token20airdrops20vrijgeven140896"><a name="Crypto Dagelijkse Samenvatting: Analisten geloven dat BTC tot juni negatief zal blijven presteren; De handelsactiviteit van het Runes-protocol is aanzienlijk afgenomen; Layer 3 zal token airdrops vrijgeven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Analisten geloven dat BTC tot juni negatief zal blijven presteren; De handelsactiviteit van het Runes-protocol is aanzienlijk afgenomen; Layer 3 zal token airdrops vrijgeven</h2><p>Laten we eerst eens kijken naar de handelsactiviteit van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor gingen op 10 mei (afgelopen vrijdag) de Bitcoin-spot-ETF-fondsen van Grayscale door. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> uit $103 miljoen; Ondertussen was de instroom van Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) $5,3 miljoen, de instroom van iShares Trust Bitcoin spot ETF (BITB) $12,4 miljoen, en de netto instroom van WisdomTree Bitcoin spot ETF (BTCW) was $600.000.</p>
<p>In de afgelopen weken is de cryptomarkt in een staat van digitale activaintegratie terechtgekomen, wat een test is voor het vertrouwen van beleggers. Charles Edwards, oprichter van het crypto hedgefonds Capriole Investment, maakte donderdag bekend dat Bitcoin zich momenteel in een ‘verveling tot de dood’ fase bevindt en verwacht dat deze toestand 1 tot 6 maanden zal aanhouden.</p>
<p>Eerder daalde de prijs van Bitcoin met bijna 5% van $63.000 naar iets boven de $60.000 als gevolg van pessimistische verwachtingen over inflatiedata en havikachtige opmerkingen van beleidsmakers van de Federal Reserve. Gegevens over blockchain-activiteit tonen ook een lage participatie, een scherpe daling van het transactievolume op het Bitcoin-netwerk en inflatie in. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p>De huidige marktprestaties lijken op de situatie van april tot september 2023, toen de prijs van Bitcoin zich gedurende zes maanden in het bereik van $25.000 tot $30.000 bevond en de marktprestaties zorgwekkend waren. Uiteindelijk echter heeft de cryptomarkt enkele maanden van groei doorgemaakt en heeft Bitcoin uiteindelijk in maart van dit jaar een historisch hoogtepunt bereikt.</p>
<p>Edwards legde uit dat in deze marktfase de prijs van Bitcoin zal schommelen binnen een lage volatiliteitsrange totdat marktdeelnemers hun geduld verliezen. Hij voegde eraan toe dat het marktsentiment laag kan blijven totdat de consolidatie voorbij is. Het gebrek aan vertrouwen in de markt kan een sterk signaal zijn dat de bodem nadert.</p>
<p>Het ecosysteem van het Runes-protocol ziet er ook niet optimistisch uit. Het Runes-protocol is een oplossing die verschillende tokenstandaarden kan implementeren op de Bitcoin-blockchain. Het maakt gebruik van het UTXO-model van Bitcoin en de OP_RETURN-opcode om een efficiëntere Bitcoin-tokeniseringsoplossing te bieden dan de BRC20-standaard, waardoor het de voorkeurskeuze is voor veel memecoin-handelsactiviteiten op Bitcoin. Onlangs heeft het zijn miljardste transactie verwerkt.</p>
<p>Echter was de daling van het Runes-protocol in de afgelopen twee weken duidelijk zichtbaar; Sinds de lancering van het Runes-protocol op 19 april is het drie weken actief geweest op de blockchain, samenvallend met het meest recente halveringsevenement van Bitcoin. Op dat moment trok Runes veel enthousiaste investeerders aan om het te gebruiken en creëerden Bitcoin-miners extreem hoge transactiekosten. In de eerste week genereerde het Runes-protocol meer dan $135 miljoen aan Bitcoin-transactiekosten.</p>
<p>Volgens het Dune-analyse-dashboard samengesteld door Runes Is, is de handelsactiviteit over het algemeen afgenomen sinds het bereiken van zijn hoogtepunt. Op 10 mei bereikte het activiteitsniveau van het Runes-protocol zijn laagste punt, met het minimum aantal nieuwe munten en portefeuilles dat met het protocol interageert sinds de lancering ervan.</p>
<p>Op basis van de gegevens van The Block werd ook vastgesteld dat de vergoedingen gegenereerd door het Runes protocol gestaag zijn afgenomen, waarbij de totale vergoedingen slechts twee keer in de afgelopen twee weken de $1 miljoen hebben overschreden, wat wijst op een afname van de handels- en etsactiviteit.</p>
<p>De Layer3 Foundation heeft aangekondigd op het X-platform dat het token L3 in het begin van de zomer van dit jaar zal lanceren, met 300 miljoen stuks, waarvan de gemeenschapsverdeling goed is voor 51% van het totale aanbod. De gedetailleerde token economie zal in juni worden vrijgegeven. Tokenhouders kunnen deelnemen aan governance en productvoordelen verkrijgen die zijn opgebouwd op het protocol via staking.</p>
<p>Volgens Layer3 zal ‘de eerste airdrop 5% van de totale L3-voorraad verdelen onder vroege adoptanten en CUBE-minters.’ Het bedrijf verklaarde ook in het bericht dat ‘er meerdere airdrops zullen zijn, en er komen binnenkort meer details’.</p>
<p>Het protocol heeft als doel om de gedecentraliseerde $1 biljoen “aandachtsmarkt” van Layer3 te realiseren. Volgens Layer3 heeft het 96 miljoen interacties gefaciliteerd in meer dan 500 ecoen.</p>
<p>Layer3 verklaarde dat “de mogelijkheden voor het implementeren van crypto-aandacht en identiteitsinfrastructuur enorm zijn.” Het bedrijf heeft als doel “identiteits- en winstinfrastructuur te bieden voor menselijke en kunstmatige intelligentie-agenten, aangezien miljoenen ecoen modellen voor toekenning op basis van tokens adopteren.”</p>
<h2 id="h2-Markttrends20De20algehele20markt20is20volatiel20met20420opeenvolgende20positieve20dagen20op20de20PEPE20wekelijkse20grafiek414826"><a name="Markttrends: De algehele markt is volatiel, met 4 opeenvolgende positieve dagen op de PEPE wekelijkse grafiek" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De algehele markt is volatiel, met 4 opeenvolgende positieve dagen op de PEPE wekelijkse grafiek</h2><p>BTC is nog steeds volatiel, met voortdurende uitstroom van BTC-spot-ETF’s en een gebrek aan aanhoudende hotspots. Momenteel bevindt bijna 80% van de mainstream mining-machines op de markt zich rond de shutdown-prijs. Op macro-economisch gebied stegen de Amerikaanse aandelen en wacht de markt op de CPI-gegevens van 15 mei.</p>
<h3 id="h3-Markt20Hotspots239279"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Het Meme concept leider PEPE blijft stijgen en behaalt vier opeenvolgende positieve dagen op de wekelijkse grafiek. On-chain walvissen blijven PEPE kopen.</p>
<p><a href="/price/gmx-gmx" rel="nofollow noopener noreferrer" target="_blank">GMX</a> steeg na de aankondiging van de migratie naar de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> publieke keten. Deze week overtrof het totale handelsvolume van Solana-keten DEX de som van vijf ketens, waaronder Ethereum, BSC, Arbitrum, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, en Base.</p>
<p>De re-staking trackleider Eigenlayer-token is nu beschikbaar voor verzameling, en de geschatte marktkapitalisatie van de over-the-counter futures is $12 miljard, met de mogelijkheid om aan het einde van september te beginnen met handelen. Daarnaast heeft Puffer Finance aangekondigd dat het staken van EIGEN op hun platform Puffer-punten kan opleveren.</p>
<p>Bouncebit-token BB wordt vandaag om 18:00 uur gelanceerd op Gate.io. BB is een BTC re-staking protocol en ze zijn van plan om een stablecoin te lanceren die vergelijkbaar is met Ethna. Bouncebit’s huidige TVL is $1 miljard en BB heeft in totaal 2,1 miljard uitgegeven. De markt voorspelt dat de waardering rond de $2 miljard zal zijn. Drie maanden geleden werd de VC-ronde-financiering van Bouncebit gewaardeerd op $60 miljoen.</p>
<p>De cryptomarkt ondergaat een volatiele aanpassing en investeerders moeten voorzichtig blijven, vooral bij het omgaan met zeer volatiele activa. Investeerders wordt geadviseerd om de markttrends nauwlettend in de gaten te houden, vooral de prestaties van Meme-munten. Tegelijkertijd moeten gebruikers het risicobeheer versterken, investeringsstrategieën tijdig aanpassen en beslissingen nemen op basis van marktveranderingen.</p>
<h2 id="h2-Macro20Wall20Street20sloot20hoger20voordat20de20inflatiegegevens20werden20vrijgegeven20Aziatische20aandelenmarkten20stijgen20naar20een20hoogtepunt20van201520maanden508445"><a name="Macro: Wall Street sloot hoger voordat de inflatiegegevens werden vrijgegeven; Aziatische aandelenmarkten stijgen naar een hoogtepunt van 15 maanden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wall Street sloot hoger voordat de inflatiegegevens werden vrijgegeven; Aziatische aandelenmarkten stijgen naar een hoogtepunt van 15 maanden</h2><p>Vorige vrijdag sloot Wall Street hoger en was de markt optimistisch over winstverwachtingen. Op 10 mei zag de Amerikaanse aandelenmarkt een lichte stijging toen investeerders opmerkingen van functionarissen van de Federal Reserve analyseerden en uitkeken naar essentiële inflatiedata volgende week. Alle drie de belangrijkste aandelenindices vertoonden een wekelijkse stijgende trend. De S&amp;P 500-index en de Dow Jones-index stegen licht, terwijl de Nasdaq-index in wezen onveranderd bleef. De blue-chip aandelenindex behaalde de grootste wekelijkse stijging sinds half december.</p>
<p>Wat de drie belangrijkste indices betreft, steeg de Dow Jones-index met 0,32%, de S&amp;P-index met 0,16% en de NASDAQ-index met 0,03%. Wat het aanstaande einde van het financiële verslagseizoen van het eerste kwartaal betreft, heeft volgens gegevens van LSEG 77% van de 459 bedrijven in de S&amp;P 500-index die al prestaties hebben aangekondigd, beter gepresteerd dan de marktverwachtingen.</p>
<p>Analisten voorspellen dat het belangrijke CPI-rapport een jaar-op-jaar stijging in de kernprijzen tot 3,6% kan laten zien. Daarnaast toonde een voorlopige beoordeling van het consumentenvertrouwen door de Universiteit van Michigan in mei aan dat het vertrouwen van Amerikaanse consumenten zijn grootste maandelijkse daling heeft meegemaakt sinds augustus 2021, waardoor het een dieptepunt van zes maanden bereikte, terwijl recente en langetermijninflatieverwachtingen zijn gestegen.</p>
<p>Op maandag bereikten Aziatische aandelenmarkten een hoogtepunt van 15 maanden. Zoals eerder vermeld, houdt de markt deze week nauwlettend de inflatiegegevens in de gaten, die de hoop kunnen bepalen dat de Verenigde Staten vroegtijdig de rente zullen verlagen. Tegelijkertijd zullen de economische activiteitsgegevens van China ook het optimistische sentiment van het duurzame herstel van de wereldeconomie testen.</p>
<p>Peking verklaarde dat de inflatie in april is gestegen tot een jaarlijks percentage van 0,3%, wat helpt om zorgen over langdurige deflatie te verlichten. Het wordt verwacht dat de detailhandelsverkopen en industriële productiegegevens voor april die op vrijdag zijn vrijgegeven, verder zullen toenemen.</p>
<p>Bovendien zijn de Chinese autoriteiten van plan om 1 biljoen yuan (ongeveer $138,24 miljard) aan langlopende obligaties te verkopen om binnenlandse stimuleringsuitgaven te ondersteunen. Hoewel een verbeterd sentiment heeft bijgedragen aan het opdrijven van de Chinese blue-chip aandelen naar een zevenmaand hoogtepunt, daalden ze maandag met 0,1% vanwege berichten dat het Witte Huis nieuwe tarieven op Chinese goederen zal aankondigen, wat druk uitoefent op sommige sectoren.</p>
<p>De MSCI Asia Pacific Stock Index staat momenteel iets hoger op 0,2%, en stijgt al drie opeenvolgende weken. De Nikkei-index in Japan bleef onveranderd en staat nog steeds voor de mogelijkheid van verdere renteverhogingen als gevolg van de daling van de yen. Ondertussen heeft de Bank of Japan op maandag de hoeveelheid Japanse staatsobligaties die via routinematige operaties worden gekocht, verlaagd, wat een haviks signaal naar de markt stuurt en de opbrengsten opdrijft.</p>
<p>Volgens een enquête van Reuters verwacht de Bank of India dat de inflatie in het volgende kwartaal terugkeert naar het streefcijfer van 4% en dat zij dan ook de rente zal verlagen. Vanwege de goede economische groei hoopt de Bank of India echter misschien te wachten op de Federal Reserve om de rente te verlagen voordat zij actie onderneemt om te voorkomen dat de wisselkoers van de roepie/dollar naar historische dieptepunten daalt.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen vorige week gedaald als gevolg van een toename van de Amerikaanse benzine- en distillaatvoorraden. De prijs van Brent ruwe olie daalde met nog eens 22 cent tot $82,57 per vat, terwijl de prijs van Amerikaanse ruwe olie met 17 cent daalde tot $78,09 per vat.</p>
<p>De prijs van goud steeg met 2,5% en daalde vervolgens iets naar $2.358 per ounce als gevolg van de vraag van momentumfondsen en geruchten van aanhoudende aankopen uit China.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S. &amp; Glazuur</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 beleggingssuggestie.<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 zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>