RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0byBNYXJrZXQgZmx1Y3R1ZWVydCBuYWFyIGJlbmVkZW4sIG1ldCBlZW4gc2NoZXJwZSBkYWxpbmcgaW4gaGV0IGFhbnRhbCBuaWV1d2UgQlRDLXBvcnRlZmV1aWxsZXM7IFRPTiBGb3VuZGF0aW9uIG9uZGVyc3RldW50IGhldCB0b2VzdGFhbiB2YW4gZ2VicnVpa2VycyBvbSBVU0RUIHZpYSBUZWx

2024-05-20, 03:40

<p><img src="https://gimg2.gateimg.com/image/article/17161763931_12.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Het20aantal20nieuwe20Bitcoin20wallets20is20scherp20gedaald20Oobit20heeft20samengewerkt20met20TON20om20gebruikers20in20staat20te20stellen20USDTs20te20verzenden20via20Telegram20Kroma20heeft20de20lancering20van20Spectrum20aangekondigd20en20uitbreidingsplannen566322"><a name="Crypto Dagelijks Overzicht: Het aantal nieuwe Bitcoin wallets is scherp gedaald; Oobit heeft samengewerkt met TON om gebruikers in staat te stellen USDT’s te verzenden via Telegram; Kroma heeft de lancering van Spectrum aangekondigd en uitbreidingsplannen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Het aantal nieuwe <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> wallets is scherp gedaald; Oobit heeft samengewerkt met TON om gebruikers in staat te stellen USDT’s te verzenden via Telegram; Kroma heeft de lancering van Spectrum aangekondigd en uitbreidingsplannen.</h2><p>Allereerst gaan we de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens Farside Investor-gegevens ondervonden Grayscale Bitcoin spot ETF’s (GBTC) op 20 mei nog steeds uitstroom van $276,2 miljoen aan fondsen; Ondertussen was er een instroom van $99,4 miljoen in Fidelity Bitcoin spot ETF (FBTC), een instroom van $20,8 miljoen in Bitwise Bitcoin spot ETF (BITB), een instroom van $10 miljoen in ARK 21Shares Bitcoin spot ETF (ARKB) en een netto instroom van $38,1 miljoen in iShares Trust Bitcoin spot ETF (IBIT).</p>
<p>Het blok meldde dat voorheen, met de ontwikkeling van Bitcoin ecoen zoals spot Bitcoin ETF’s en Ordinals, en de aankomende halvering, het gemiddelde aantal nieuwe Bitcoin-adressen per week bijna het hoogste niveau bereikte sinds het bereiken van een historisch hoogtepunt in december 2017.</p>
<p>Nu, naarmate deze berichten en projecten geleidelijk hun actualiteit verliezen, net zoals in het begin van 2018, is de enthousiasme voor het nieuwe Bitcoin-project vervaagd en is het aantal nieuwe adressen dat zich bij het netwerk voegt sterk afgenomen. Naast de daling van het aantal nieuwe Bitcoin-adressen, zijn ook andere gerelateerde indicatoren een neerwaartse trend vertonen, waarbij de belangrijkste is dat de mijnwerkersinkomsten gemeten naar rekenkracht tot een historisch laag niveau zijn gedaald. Daarnaast zijn ook de kosten van online transacties en de indicatoren voor het volume van on-chain transacties afgenomen.</p>
<p>Ondanks de daling van on-chain metrics, trekken nieuwe protocollen op het Bitcoin-netwerk recordbrekende belangstelling van durfkapitaalbedrijven. Deze tekenen kunnen de basis leggen voor een toekomstige comeback.</p>
<p>Op 17 mei werd aangekondigd dat de mobiele betaalapplicatie Oobit een partnerschap is aangegaan met de TON Foundation om zijn inheemse crypto TON te integreren. <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a>) in zijn platform opnemen, waardoor het gebruik van cryptocurrency als betaalmethode wordt bevorderd. Het team verklaarde dat Toncoin-houders wereldwijd bij meer dan 100 miljoen retailers kunnen Tap&amp;Pay. Deze integratie zal de onlangs aangekondigde samenwerking verder versterken tussen <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> het grootste bedrijf in de digitale activa-industrie, en de TON Foundation.</p>
<p>Volgens een andere persbericht op de Tether-website kunnen gebruikers USDT als een direct bericht op Telegram sturen en dezelfde USDT gebruiken voor directe betalingen met crypto tap op Oobit.</p>
<p>Kroma lanceerde op 14 mei 2024 Spectrum, een geavanceerde protoplast stakingsservice om volledig te veranderen. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Layer 2-landschap. Hoge opbrengsten kunnen worden verkregen door opnieuw in te zetten terwijl stakingstokens worden gebruikt in verschillende spellen en DeFi-ecoen op Kroma. Spectrum biedt gebruikers de mogelijkheid om het potentieel van ETH, stETH en eETH te benutten, waardoor ze meer inkomsten kunnen genereren op het gebied van gedecentraliseerde financiën (DeFi).</p>
<p>Het verschil met traditionele stakingsplatforms is dat Spectrum innovatief een ‘zesvoudige beloning’ heeft gelanceerd, waaronder het jaarlijkse rentepercentage van Ethereum, zware stakingsbeloningen, EigenLayer-punten voor het staken van Ethereum-activa, Etherfi-loyaliteitspunten, KSP (Kroma Spectrum Point) en wemix.e airdrop. Kroma zal 40.000 wemix.e airdroppen aan gebruikers op basis van opgebouwde KSP, wat een nieuw type onderpandbeloning biedt.</p>
<p>Het platform heeft spETH geïntroduceerd, een eigen risicotoken voor het synthetiseren van activa. Gebruikers die spETH gebruiken, kunnen de liquiditeit van hun gestaakte Ethereum-activa maximaliseren en een breed scala aan handelsmogelijkheden krijgen, evenals aanvullende winstkansen binnen de uitgebreide DeFi-protocollen en -toepassingen van het platform.</p>
<p>Spectrum heeft succesvol geïntegreerd met bekende dApps zoals Standard Protocol, Light Bank, Layer Bank, Shoebil, Zapanki Swap, Wellxy, PrixmSwap en iZUMi Finance, en heeft brede lof ontvangen. Deze integratie legt de basis voor verdere uitbreiding, aangezien Spectrum hoopt haar innovatieve inspanningen voort te zetten om meer dApps te integreren.</p>
<h2 id="h2-Markttrends20De20markt20ontbreekt20aan20hete20onderwerpen20en20de20algehele20markt20bevindt20zich20in20een20fluctuerende20neerwaartse20trend83124"><a name="Markttrends: De markt ontbreekt aan hete onderwerpen en de algehele markt bevindt zich in een fluctuerende neerwaartse trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt ontbreekt aan hete onderwerpen en de algehele markt bevindt zich in een fluctuerende neerwaartse trend</h2><p>BTC brak dit weekend kort door $67,500, maar kende daarna een daling en valt momenteel rond de $66,500. Deze daling heeft geleid tot een algemene daling in Altcoins en eerder sterk presterende Meme coins zijn ook begonnen met dalen. De markt ontbeert stimulerende hotspots en het sentiment van investeerders is relatief lauw.</p>
<p>Wat betreft de macro-economie heeft de Amerikaanse aandelenmarkt volatiliteit ervaren en Nvidia zal deze week haar resultaten bekendmaken, wat mogelijk een bepaalde invloed kan hebben op de markt. Beleggers zullen de prestaties nauwlettend volgen om de trends van technologische aandelen en de gehele markt te beoordelen.</p>
<h3 id="h3-Markt20Hotspots662303"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Openbare ketting FTM omhoog: FTM heeft aangekondigd dat het zijn Sonic in het derde kwartaal zal upgraden, en na de upgrade zal het worden vervangen door een nieuwe token S in een verhouding van 1:1. Dit nieuws kan enige koopdruk geven voor FTM-tokens, en investeerders zullen letten op de effecten en marktreacties na de upgrade.</p>
<p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Ecosysteem Oracle Protocol PYTH keldert: Bijna $800 miljoen aan PYTH-tokens zal deze week worden vrijgegeven. Voor en na het vrijgeven van de enorme tokens kunnen er aanzienlijke marktschommelingen zijn, en investeerders moeten de risico’s zorgvuldig ueren.</p>
<p>Nieuwe munten hebben slecht gepresteerd: Onlangs hebben nieuwe munten zoals NOT, BB en REZ doorbraak gemaakt en VC-tokens met hoge marktwaarde zijn, eenmaal gelanceerd, niet langer in trek op de markt. In de afgelopen zes maanden zijn 80% van de tokens in vergelijkbare nieuwe munten gedaald, met een gemiddelde daling van meer dan 20%. Dit geeft aan dat investeerders voorzichtiger worden met nieuwe munten en zorgvuldiger moeten kiezen waarin ze investeren.</p>
<p>Zksync van Layer2 voorspelt een token airdrop: Dit nieuws kan de aandacht trekken van investeerders, die de details en planning van de airdrop nauwlettend zullen volgen.<br>Op de huidige markt heeft BTC een korte daling meegemaakt, wat heeft geleid tot een algemene daling van Altcoins en Meme coins. De markt ontbreekt aan stimulerende hotspots en beleggerssentiment is relatief onverschillig. Beleggers moeten marktrisico’s zorgvuldig ueren, aandacht besteden aan macro-economische en industriële trends, en doelen kiezen die geschikt zijn voor hun beleggingsstrategieën.</p>
<h2 id="h2-Macro20Amerikaanse20aandelenmarkten20kunnen20blijven20stijgen20naar20historische20hoogtes20terwijl20Aziatische20aandelenmarkten20hoger20openen895794"><a name="Macro: Amerikaanse aandelenmarkten kunnen blijven stijgen naar historische hoogtes, terwijl Aziatische aandelenmarkten hoger openen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Amerikaanse aandelenmarkten kunnen blijven stijgen naar historische hoogtes, terwijl Aziatische aandelenmarkten hoger openen</h2><p>Op 17 mei, afgelopen vrijdag, bereikte de Amerikaanse aandelenmarkt een historisch hoogtepunt, wat de optimistische houding van de markt ten opzichte van de economische vooruitzichten aantoont. Tegelijkertijd werden de Aziatische aandelenmarkten ook positief beïnvloed toen ze op maandag openden.</p>
<p>De nieuwe tekenen van economische afkoeling hebben de inflatiezorgen in mei doen afnemen en hebben deze week geholpen om de drie belangrijkste Amerikaanse aandelenindices naar historische hoogtepunten te laten stijgen. De S&amp;P 500-index is dit jaar al met 11% gestegen. Op basis van historische trends suggereren marktstrategen dat de aandelenmarkt vaak momentum vormt bij het herstellen van vergelijkbare terugtrekkingen op dezelfde schaal, en zelfs na het herstellen van verloren terrein, blijft het meestal stijgen.</p>
<p>Investeerders geloven dat de <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> Het verhaal over de economie die op weg is naar een zogenaamde zachte landing is weer opgedoken, en sterke winstverwachtingen stuwen de aandelenmarkt verder omhoog. Investeerders zullen ook letten op de gegevens over duurzame goederen en consumentenvertrouwen van volgende week om te zien of er verdere tekenen zijn dat de economische groei genoeg afkoelt om de renteverlaging van dit jaar te ondersteunen.</p>
<p>Op het gebied van technologieaandelen is de aandelenkoers van de halfgeleidergigant Nvidia gestegen vanwege zijn passie voor kunstmatige intelligentie en zal het woensdag kwartaalresultaten rapporteren.</p>
<p>Ook de Aziatische beurzen lieten bij de opening op maandag positieve signalen zien. China kondigde afgelopen vrijdag een historische maatregel aan om de vastgoedsector te stabiliseren, waarbij de centrale bank extra middelen van 1 biljoen yuan (ongeveer $ 138) verstrekte en de regelgeving voor hypothecaire leningen versoepelde. Lokale overheden bereiden zich ook voor om “enkele” appartementen te kopen. Dit heeft de Hang Seng-index naar het hoogste punt in 9 maanden geduwd.</p>
<p>De Nikkei-index van Japan steeg met 0,9% in de vroege handelssessie. Tegelijkertijd werd de MSCI Asia Pacific-aandelenindex beïnvloed door de vroege winsten op de Australische en Zuid-Koreaanse aandelenmarkten en steeg met 0,25% naar het hoogste niveau in twee jaar.</p>
<p>In de valutamarkt boekte de Amerikaanse dollar vorige week de grootste wekelijkse daling ten opzichte van de euro in twee en een halve maand, maar bleef stabiel tijdens de vroege Aziatische handel op maandag. De euro bleef stabiel op $1.0873 op maandag. De Japanse yen verzwakte iets ten opzichte van de Amerikaanse dollar, op 155.82 yen per dollar.</p>
<p>Met betrekking tot grondstoffen stortte een helikopter met de president van Iran neer in dichte mist, wat de aandacht van handelaren vestigde op het Midden-Oosten. Brent ruwe olie futures bereikten een weekhoogtepunt bij de vroege handel, met een vatprijs van $84.14.</p>
<p>De goudprijzen zweven rond een historisch hoogtepunt van $2,423 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 van dit artikel. Het opnieuw posten van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>