RGFnZWxpamtzIG5pZXV3cyB8IFRlbGVncmFtIGxhbmNlZXJkZSBlZW4gbWluaS1wcm9ncmFtbWEgb20gdGUgYmV0YWxlbiB2b29yIGRpZ2l0YWxlIGdvZWRlcmVuOyBkZSBvcGVuYmFhcm1ha2luZyB2YW4gaG9sZGluZ3MgdmFuIFJvYXJpbmcgS2l0dHkgem9yZ2RlIGVydm9vciBkYXQgR2FtZVN0b3Agbm9nIGVlbnMgNDclIHN0ZWVn

2024-06-07, 03:52

<p><img src="https://gimg2.gateimg.com/image/article/17177322361_6-05.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Telegram20lanceerde20Telegram20Stars20om20te20betalen20voor20digitale20goederen20Sandbox20voltooide20een20financiering20van202020miljoen20resulterend20in20een20stijging20van204520in20SAND20Roaring20Kitty20onthulde20een2058620miljoen20GMEpositie20waardoor20de20aandelenkoers20van20GameStop20met204720steeg116902"><a name="Crypto Dagelijks Overzicht: Telegram lanceerde Telegram Stars om te betalen voor digitale goederen; Sandbox voltooide een financiering van $20 miljoen, resulterend in een stijging van 4,5% in SAND; Roaring Kitty onthulde een $586 miljoen GME-positie, waardoor de aandelenkoers van GameStop met 47% steeg" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Telegram lanceerde Telegram Stars om te betalen voor digitale goederen; Sandbox voltooide een financiering van $20 miljoen, resulterend in een stijging van 4,5% in SAND; Roaring Kitty onthulde een $586 miljoen GME-positie, waardoor de aandelenkoers van GameStop met 47% steeg</h2><p>Laten we eerst de handelsactiviteiten van onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor ondervonden Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 6 juni een uitstroom van $37,6 miljoen aan fondsen. Ondertussen bedroeg de instroom van Fidelity Bitcoin spot ETF (FBTC) $3,1 miljoen, de uitstroom van Bitwise Bitcoin spot ETF (BITB) $3,1 miljoen en de uitstroom van ARK 21Shares Bitcoin spot ETF (ARKB) $96,6 miljoen.</p>
<p><strong>Telegram lanceerde het digitale betalingssysteem Telegram Stars voor mini-programma’s</strong><br>Het sociale berichtenplatform Telegram heeft ‘Telegram Stars’ gelanceerd. Het is een nieuwe in-app-token die kan worden gebruikt om digitale goederen en diensten op het platform aan te schaffen.</p>
<p>Op 6 juni verklaarde de CEO van het bedrijf, Pavel Durov, in een Telegram-bericht dat “met Telegram Stars mini-programma’s nu digitale dienstenbetalingen kunnen accepteren op Android en iOS met behulp van de meest handige betaalmethoden.” Ontwikkelaars kunnen ook hun Stars inwisselen voor <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a>(TON) via het Fragment-platform, een platform dat voornamelijk wordt gebruikt voor het verhandelen van Telegram-gebruikersnamen. <a href="/price/toncoin-ton" target="_blank" class="blog_inner_link">Toncoin</a> is een inheemse cryptocurrency die het open netwerk van Telegram ondersteunt. Durov voegde eraan toe: “Ze kunnen ook Sterren gebruiken om hun applicaties verder te promoten op Telegram.”</p>
<p>Daarnaast zal Telegram Stars gebruiken om advertenties te subsidiëren die via Apple en Google zijn gekocht en zal een commissie van 30% in rekening brengen voor de verkoop van digitale producten. Durov is van mening dat dit ontwikkelaars economisch zal stimuleren om digitale producten op Telegram te bouwen.</p>
<p>Op 6 juni verklaarde Telegram in een bericht: ‘Toekomstige updates zullen aanvullende functies en mogelijkheden naar Stars brengen, zoals het verstrekken van geschenken voor content creators, enzovoort.’</p>
<p>Onlangs heeft Telegram een groot succes behaald met Notcoin. Notcoin is een van de meest populaire toepassingen op het platform en heeft in de eerste vijf maanden na de lancering 35 miljoen gebruikers verzameld. Het TON-netwerk heeft ook veel aandacht gekregen. Volgens CoinGecko-gegevens heeft TON onlangs een historisch hoogtepunt van $7,65 bereikt, maar is sindsdien terugglen naar $7,50. De marktkapitalisatie van $18,2 miljard is echter nog steeds $7 miljard lager dan de piek van $25,2 miljard die op 12 april werd bereikt.</p>
<p><strong>Sandbox haalde $20 miljoen op met een waardering van $1 miljard, en SAND steeg met 4,5%</strong> <a href="/price/the-sandbox-sand" rel="nofollow noopener noreferrer" target="_blank">De Zandbak</a> Het metaverse-platform, The Sandbox, heeft $20 miljoen opgehaald tegen een waardering van $1 miljard om zijn door gebruikers gegenereerde multiplayer-gamingplatform te verbeteren. Volgens het persbericht leidden Kingsway Capital en Animoca Brands de financieringsronde, waarbij ook LG Tech Ventures en True Global Ventures deelnamen aan de investering. Twee jaar geleden had <a href="/price/the-sandbox-sand" target="_blank" class="blog_inner_link">The Sandbox</a> het plan om $400 miljoen op te halen tegen een waardering van $4 miljard.</p>
<p>Volgens de gegevens van CoinDesk is de native token SAND van Sandbox met 4,5% gestegen sinds de aankondiging van de financieringsronde en bedraagt de marktkapitalisatie momenteel $1,1 miljard. Een deel van de fondsen zal worden gebruikt voor de ontwikkeling van een gedecentraliseerde metaverse voor mobiele apparaten, die naar verwachting in 2025 zal worden gelanceerd. Sandbox zal ook zijn Game Maker en 3D-editor tools bijwerken.</p>
<p>Sandbox heeft 5,7 miljoen gebruikersaccounts verbonden met cryptowallets en heeft sinds de lancering van de Alfa-versie in november 2023 meer dan 1.000 door gebruikers gegenereerde ervaringen gecreëerd.</p>
<p><strong>Roaring Kitty onthulde een GME-positie van $ 586 miljoen, waardoor de aandelenkoers van GameStop met 47% steeg</strong><br>Keith Gill (bekend als RoaringKitty of DeepF - kingValue) onthulde zijn nieuwste grootschalige weddenschap op GameStop-aandelen. Volgens de screenshot die op Reddit is vrijgegeven, bedragen de aandelen- en optieposities van Gill nu ongeveer $ 586 miljoen. Donderdag kondigde hij aan dat hij vrijdag live zal streamen op YouTube. De aandelenkoers van GameStop sloot 47% hoger.</p>
<p>Deze maatregel heeft ook invloed gehad op de digitale activamarkt. Volgens CoinGecko-gegevens, hoewel de algehele cryptomarkt daalt, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>-gebaseerde meme-token GME is in de afgelopen 24 uur met meer dan 80% gestegen. Hoewel GME-tokens geïnspireerd zijn door GameStop, hebben ze geen connectie met het bedrijf.</p>
<h2 id="h2-Markttrends282250"><a name="Markttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends</h2><p>BTC consolideert boven de $70.000 en de prijs is relatief stabiel. De opleving van de dominantie van BTC wijst op een groter marktvertrouwen in BTC, waarbij geld terugvloeit van Altcoins naar BTC.</p>
<p>ETH zakte gisteravond onder de $3.800, waarbij enige volatiliteit werd getoond.</p>
<p>Altcoins: De meeste altcoins zijn over het algemeen gedaald en presteren slecht.</p>
<p>De actieve prestaties van de Meme-sector hebben mogelijk enkele speculatieve fondsen aangetrokken.</p>
<h3 id="h3-Macroeconomie246179"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>Na een historisch hoogtepunt te hebben bereikt, bevindt de Amerikaanse aandelenmarkt zich momenteel in een volatiele trend.</p>
<p>De Europese Centrale Bank heeft voor het eerst in vijf jaar de rentetarieven verlaagd, en dit beleid kan invloed hebben op de wereldwijde financiële markten.</p>
<h3 id="h3-Markt20Hotspots359990"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>Io.net:</strong><br>Io.net staat op het punt gelanceerd te worden en als toonaangevend project in gedecentraliseerde AI-rekenkracht is de over-the-counter waardering gestegen tot $3,5 miljard. Zes maanden geleden was de waardering tijdens financiering slechts $300 miljoen, een aanzienlijke stijging.</p>
<p>In vergelijking met andere track projecten heeft RNDR een marktkapitalisatie van $5 miljard en heeft AKT een marktkapitalisatie van $1 miljard.</p>
<p><strong>Meme Coins op <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Chain:</strong><br>MOTHER: Uitgegeven door beroemdheid Iggy en ondersteund en gepromoot door bekende cryptogemeenschappen zoals KOL Ansem.</p>
<p>GME: Beïnvloed door de aanzienlijke stijging van GME van dezelfde naam aandelen op de Amerikaanse aandelenmarkt, steeg de GME op het Solana-netwerk met meer dan 100% in één dag.</p>
<p><strong>Het Cross-chain Bridge Protocol W:</strong><br>Het cross-chain brugprotocol W is de afgelopen dagen met 15% gestegen en het projectteam heeft aangekondigd dat het W-staking zal activeren, wat mogelijk kan leiden tot de airdrop van ecosysteemtokens in de toekomst.</p>
<p><strong>De BRETT van Base Chain:</strong><br>De BRETT van de Base Chain is met 30% gestegen, waardoor het de meest waardevolle Meme-munt is die genoteerd staat op de Base Chain. Het huidige marktkapitalisatie is bijna $1,4 miljard en het is gelanceerd op Gate.io.</p>
<p>De consolidatie en opleving van BTC’s dominantie duiden op een sterk marktvertrouwen in BTC. In tijden van macro-economische onzekerheid kan BTC worden beschouwd als een veilige haven asset. De opkomst van nieuwe projecten zoals Io.net en het cross-chain bridge protocol W hebben nieuwe investeringsmogelijkheden naar de markt gebracht. Investeerders moeten echter een gedetailleerd begrip hebben van de achtergrond en de ontwikkelingsvooruitzichten van het project. Over het algemeen bieden de huidige marktvolatiliteit en de actieve prestaties van populaire projecten investeerders diverse investeringskeuzes, maar ze moeten ook waakzaam zijn voor markt- en projectrisico’s.</p>
<h2 id="h2-Macro20De20Europese20Centrale20Bank20heeft20zijn20eerste20renteverlaging20in20de20afgelopen20jaren20aangekondigd20en20de20uitgifte20van20een20nonfarm20payrollrapport20kan20leiden20tot20een20wereldwijde20marktheropleving853632"><a name="Macro: De Europese Centrale Bank heeft zijn eerste renteverlaging in de afgelopen jaren aangekondigd, en de uitgifte van een non-farm payroll-rapport kan leiden tot een wereldwijde marktheropleving" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Europese Centrale Bank heeft zijn eerste renteverlaging in de afgelopen jaren aangekondigd, en de uitgifte van een non-farm payroll-rapport kan leiden tot een wereldwijde marktheropleving</h2><p><strong>Voor de publicatie van Amerikaanse werkgelegenheidsgegevens sloten de S&amp;P 500-index en Nasdaq-index iets lager</strong><br>Volgens Reuters stegen de S&amp;P 500-index en Nasdaq op donderdagochtend en bereikten ze een nieuw intraday hoogtepunt voordat het belangrijke arbeidsmarktrapport werd vrijgegeven. Echter, doordat technologieaandelen daalden, eindigden ze uiteindelijk lager.</p>
<p>De specifieke gegevens zijn als volgt: de Dow Jones steeg met 0,20%, de S&amp;P daalde met 0,02% en de Nasdaq daalde met 0,09%.</p>
<p>Beleggers kunnen het rapport over de Amerikaanse werkgelegenheid buiten de landbouw in de gaten houden, dat op vrijdag zal worden vrijgegeven. Bovendien wijzen de wekelijkse gegevens over de aanvragen voor werkloosheidsuitkeringen die op donderdag worden vrijgegeven op een versoepeling op de arbeidsmarkt, wat de Federal Reserve ertoe kan aanzetten om de rente te verlagen.</p>
<p>De Europese Centrale Bank (ECB) heeft donderdag een renteverlaging aangekondigd, wat de eerste renteverlaging sinds 2019 markeert. Eergisteren werd de Bank of Canada het eerste land in de G7 dat de belangrijkste beleidsrentetarieven verlaagde. Deze twee centrale banken, samen met de Zweedse centrale bank en de Zwitserse centrale bank, zijn begonnen met hun respectievelijke monetaire versoepelingscycli, wat nieuw leven in de wereldwijde risicobereidheid brengt, terwijl de markt steeds meer wedt dat de Federal Reserve de rentetarieven in september zou kunnen verlagen.</p>
<p><strong>Aziatische aandelenmarkten worden verwacht elke week te herstellen als gevolg van renteverlagingen</strong><br>Op 7 juni, in de vroege handel in Azië, gedreven door de renteverlagingscyclus die deze week is ingezet door belangrijke centrale banken, wordt verwacht dat de Aziatische aandelenmarkten vrijdag hun twee opeenvolgende weken van daling zullen beëindigen, en de markt verwacht dat de Federal Reserve binnenkort zal volgen.</p>
<p>De MSCI Asia Pacific aandelenindex volgde de stijging van de wereldwijde aandelenmarkten, met Azië dat 0,3% steeg in de vroege handel en bijna 3% deze week. De Hang Seng Index in Hong Kong steeg ook met 0,14%, terwijl Chinese blue-chip aandelen licht stegen met 0,23%. De markttrend is stabiel omdat handelaren wachten op de publicatie van het Amerikaanse niet-agrarische loonrapport op vrijdag. Verwacht wordt dat het niet-agrarische loon in de Verenigde Staten vorige maand met 185.000 zal toenemen.</p>
<p>Uit vrijgegeven gegevens op vrijdag bleek dat de huishoudelijke uitgaven in Japan in april voor het eerst in 14 maanden zijn gestegen in vergelijking met dezelfde periode vorig jaar. Toch was de groei zwak, wat aangeeft dat consumenten voorzichtig blijven ondanks stijgende prijzen. Volgens gegevens van het Japanse ministerie van Algemene Zaken zijn de consumentenbestedingen in april met 0,5% gestegen ten opzichte van dezelfde periode vorig jaar, iets lager dan de verwachte stijging van 0,6% van de markt.</p>
<p>De Amerikaanse dollar daalde tot bijna het laagste niveau in acht weken ten opzichte van een mandje valuta’s op de geldmarkt, met een wekelijkse daling van ongeveer 0,5%. De euro steeg met 0,05% naar $1,0895, waarbij de kleine winsten van de vorige handelsdag werden voortgezet omdat de Europese Centrale Bank haar inflatieverwachtingen verhoogde en de timing van daaropvolgende renteverlagingen niet bekendmaakte.</p>
<p>Met betrekking tot grondstoffen zijn de olieprijzen licht gedaald. Brent ruwe olie futures daalden met 0,09% naar $79,80 per vat, terwijl West Texas Intermediate ruwe olie futures in de Verenigde Staten met 0,1% daalden naar $75,48 per vat. Spot goud daalde met 0,2% naar $2.370,82 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 visie 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 is toegestaan mits Gate.io wordt vermeld. In alle glen worden juridische stappen ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>