RGFnZWxpamtzIG5pZXV3cyB8IERlIGNyeXB0b21hcmt0IGZsdWN0dWVlcnQgZW4gc3Rpamd0OyBOb3Rjb2luIGJldm9yZGVydCBkZSBhZG9wdGllIHZhbiBjcnlwdG8ncyBvcCBURzsgRGUga3dldHNiYWFyaGVpZHNhYW52YWxsZXIgaW4gR2FsYSBHYW1lcyBoZWVmdCAkMjJNIHRlcnVnZ2VnZXZlbg==

2024-05-22, 03:42

<p><img src="https://gimg2.gateimg.com/image/article/17163492481_14.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Notcoin20heeft20de20adoptie20van20cryptocurrencies20op20Telegram20gestimuleerd20Gala20Gamesexploitanten20hebben202220miljoen20teruggegeven20via20Galatokenaanvallen20Het20campagneteam20van20Trump20heeft20de20acceptatie20van20cryptodonaties20uitgesproken41475"><a name="Crypto Dagelijkse Samenvatting: Notcoin heeft de adoptie van cryptocurrencies op Telegram gestimuleerd; Gala Games-exploitanten hebben $22 miljoen teruggegeven via Gala-tokenaanvallen; Het campagneteam van Trump heeft de acceptatie van crypto-donaties uitgesproken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Notcoin heeft de adoptie van cryptocurrencies op Telegram gestimuleerd; <a href="/price/gala-gala" target="_blank" class="blog_inner_link">Gala</a> Games-exploitanten hebben $22 miljoen teruggegeven via Gala-tokenaanvallen; Het campagneteam van Trump heeft de acceptatie van crypto-donaties uitgesproken</h2><p>Laten we de handelsactiviteit van eens nader bekijken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor bedroeg op 21 mei de instroom van Fidelity’s <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) $25,8 miljoen, terwijl de uitstroom van Bitwise’s Bitcoin spot ETF (BITB) $4,2 miljoen was.</p>
<p>De explosieve groei van Notcoin heeft de adoptie van cryptocurrencies op Telegram gestimuleerd</p>
<p>Blockchain games gebouwd op TON trekken miljoenen gebruikers aan op Telegram, met games zoals Notcoin die de weg wijzen. De explosieve groei van Notcoin trok in minder dan twee maanden meer dan 30 miljoen gebruikers aan en vestigde een op het open netwerk gebaseerde crypto wallet.</p>
<p>Met de populariteit van virale spellen zoals Notcoin, heeft de enorme gebruikersbasis van Telegram zich bewezen als een vruchtbare bodem voor crypto-adoptie. Het plaatsingsspel waarbij gebruikers op het scherm klikken om niet-tokens te verdienen, heeft 3% van Telegram-gebruikers aangetrokken om <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> te gebruiken. Vervolgens werd de NOT-token genoteerd op een bekende crypto-uitwisseling, wat onverwachte rijkdom bracht voor casual gamers.</p>
<p>Ook game-ontwikkelaars besteden aandacht aan het TON-ecosysteem. Micha, CEO en oprichter van Elympics, een aanbieder van blockchain-game-infrastructuur, verklaarde dat Web3-games klaar zijn om nieuwe cryptogebruikers aan te trekken.</p>
<p>Dąbrowski vertelde Cointelgraph dat blockchain-gebaseerde infrastructuur de uitdagingen aanpakt waarmee game-ontwikkelaars worden geconfronteerd op het gebied van monetisatiemechanismen, waardoor studio’s crypto-portefeuilles kunnen gebruiken om spelers te stimuleren en aan te trekken. Elympics ziet het enorme potentieel van het TON-ecosysteem, met als doel studio’s en ontwikkelaars te helpen bij het implementeren van Web3-games op deze platforms.</p>
<p>De CEO van Elympics voegde eraan toe dat Web3-functies inactieve soorten games nieuw leven inblazen. De zachte valuta die spelers in het spel verdienen, wordt nu gemonetariseerd, waardoor gebruikers eigendom en waarde kunnen krijgen door het spelen van het spel.</p>
<p>De aanvaller van de Gala Games kwetsbaarheid heeft $22 miljoen teruggegeven</p>
<p>Eerder gemelde kwetsbaarheidsaanvallen gerelateerd aan Gala Games. Een aanvaller sloeg $200 miljoen aan munten uit <a href="/price/gala-gala" rel="nofollow noopener noreferrer" target="_blank">GALA</a> tokens, maar heeft slechts een deel ervan succesvol verkocht. Gala Games heeft nu ongeveer $22 miljoen aan Ether ontvangen.</p>
<p>Op 21 mei keerde de portemonnee van de aanvaller 5913,2 ETH terug, ter waarde van $22,3 miljoen - dicht bij de marktwaarde van de 600 miljoen GALA die ze de dag ervoor verkochten.</p>
<p>Naar aanleiding van deze onverwachte situatie legde Gala Games ook uit op sociale media dat de getroffen portefeuilles bevroren zijn en de nieuwe functie ‘GalaChain’s Block List Protocol’ hebben gebruikt, waardoor effectief 4,4 miljard GALA’s van de 5 miljard GALA’s binnen 45 minuten bevroren zijn. Gala Games heeft nog niet publiekelijk de identiteit of de methode van de aanval op het doel bevestigd, maar sommige gemeenschapsleden geloven dat de aanval afkomstig was van een beveiligingsaannemer die een fout maakte nadat hij geen VPN had gebruikt om verbinding te maken met de portefeuille.</p>
<p>Het campagneteam van Trump heeft aangegeven crypto donaties te accepteren</p>
<p>Voormalig Amerikaans president Donald Trump wordt momenteel geconfronteerd met strafrechtelijke vervolgingen van vier jurisdicties, en in deze situatie heeft hij aangekondigd dat zijn presidentscampagne van 2024 donaties in cryptovaluta zal accepteren.</p>
<p>In een mededeling op 21 mei verklaarde het campagneteam Trump 2024 dat ze een inzamelpagina hebben gelanceerd die platforms zoals Bitcoin accepteert. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, DOGE, SHIB, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, SOL en meer. De verklaring haalt de aanval van senator Elizabeth Warren op cryptocurrencies aan en beweert zonder bewijs dat zij de ‘officiële vertegenwoordiger’ van de Amerikaanse president Joe Biden is in het Congres.</p>
<p>Trump zei dat hij ervoor zal zorgen dat aanwezigen kunnen bijdragen aan zijn campagne in cryptovorm. Minder dan zes maanden voor de verkiezingsdag is Trump de geplande kandidaat voor de Republikeinse Partij als president van de Verenigde Staten in 2024. Hij kan het opnemen tegen de Democratische genomineerde, president Biden.</p>
<p>Hoewel Trump cryptodonaties accepteerde, werd op de pagina ‘Issues’ van zijn campagnewebsite niet specifiek gesproken over digitale activa of blockchain toen deze werd gepubliceerd. President Biden maakt zelden openbare verklaringen over cryptocurrencies, maar hij heeft wel een uitvoeringsbesluit ondertekend om een regelgevend kader voor digitale activa op te stellen in 2022.</p>
<h2 id="h2-Markttrends20De20markt20fluctueert20en20stijgt20en20het20Memeconcept20presteert20sterk922412"><a name="Markttrends: De markt fluctueert en stijgt, en het Meme-concept presteert sterk." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt fluctueert en stijgt, en het Meme-concept presteert sterk.</h2><p>BTC en ETH prestaties: Bitcoin consolideert boven $70.000 en toont sterke ondersteuning. <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> brak ook op een gegeven moment door $3.800, wat wijst op sterke marktvertrouwen in deze belangrijke valuta.</p>
<p>Macroeconomische impact: Amerikaanse aandelen stegen naar een historisch hoogtepunt en dovish toespraken van functionarissen van de Federal Reserve verhoogden de marktverwachtingen voor een renteverlaging in september. Deze factoren kunnen de stijging van de cryptomarkt verder stimuleren.</p>
<h3 id="h3-Markthoogtepunten222806"><a name="Markthoogtepunten:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markthoogtepunten:</h3><p><strong>Meme concept munten:</strong><br>Uitstekende prestaties: Ethereum-gebaseerde Meme munten zoals PEPE, PEOPLE, FLOKI, WOJAK, MOG, etc. hebben uitstekend gepresteerd.</p>
<p>De valuta’s van stagflatie, zoals WIF en MANEKI op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> keten heeft een relatief achterblijvende prestatie laten zien.</p>
<p><strong>Sociale conceptmunten:</strong><br>De valuta die aanzienlijke groei hebben doorgemaakt zijn DEGEN, HIGHER, Only1 en anderen die het goed hebben gedaan.</p>
<p>Investeringsnieuws: Het sociale protocol Farcaster op de Base-keten heeft investeringen ontvangen van a16z en Paradigm, waardoor het marktvertrouwen in sociale conceptmunten verder is versterkt.</p>
<p>De prijs van het Ethereum Domain Name Protocol ENS is aanzienlijk gestegen:</p>
<p>Ondersteuning van Vitalik Buterin: Vitalik Buterin heeft herhaaldelijk ENS genoemd en het aangeduid als een belangrijk instrument voor het verenigen van verschillende Layer2-netwerken in Ethereum, wat ondersteuning biedt voor de langetermijnwaarde van ENS.</p>
<p><strong>Layer2 netwerk:</strong><br>Zksync Airdrop Programma: Zksync is van plan om in juni tokenairdrops uit te voeren, met in totaal 21 miljard tokens en een verwachte marktwaardering van $10 miljard.</p>
<p>Marktwaarderingsvergelijking: Populaire Layer2-netwerken zoals ARB, OP en STRK hebben waarderingen van ongeveer $12 miljard gedurende dezelfde periode, wat wijst op sterke marktinteresse in het Layer2-project.</p>
<p>Futures Market: Aevo voorspelt dat Zksync-futurestokens op de markt zijn genoteerd, met een huidige prijs van $0.69, waardoor beleggers de kans krijgen om vooruit te plannen.</p>
<p>De huidige algemene trend van de cryptomarkt fluctueert en stijgt, gedreven door meerdere positieve nieuwsberichten.<br>Belangrijke valuta’s zoals BTC en ETH presteren stabiel, en verschillende populaire conceptvaluta’s laten ook aanzienlijke stijgingen zien. Vooral de investering en ontwikkeling van Layer2-netwerken en sociale protocollen tonen de hoge aandacht en verwachtingen van de markt voor deze opkomende gebieden aan. Het wordt aanbevolen dat beleggers deze hete gebieden nauwlettend volgen terwijl ze gevoelig blijven voor veranderingen in de macro-economische omgeving, om investeringsstrategieën tijdig aan te passen.</p>
<h2 id="h2-Macro20Amerikaanse20aandelen20sloten20hoger20Aziatische20markten20stegen20licht20en20de20olieprijzen20bleven20dalen555462"><a name="Macro: Amerikaanse aandelen sloten hoger, Aziatische markten stegen licht en de olieprijzen bleven dalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Amerikaanse aandelen sloten hoger, Aziatische markten stegen licht en de olieprijzen bleven dalen</h2><p>Op 21 mei meldde Reuters dat de Amerikaanse aandelenmarkt dinsdag iets hoger sloot, waarbij de S&amp;P 500 en Nasdaq historische hoogtepunten bereikten. Beleggers ueerden de recente opmerkingen van functionarissen van de Federal Reserve om aanwijzingen te vinden over het tijdstip van renteverlagingen, terwijl de kwartaalcijfers van Nvidia dichterbij komen.</p>
<p>Specifiek, de drie belangrijkste indices: de Dow Jones-index steeg met 0,17%, de Standard &amp; Poor’s-index steeg met 0,25%, en de Nasdaq-index steeg met 0,22%.</p>
<p>Nvidia zal zijn resultaten uitbrengen na het sluiten van de handel op woensdag. Als het op twee na grootste bedrijf op Wall Street qua marktwaarde kan deze informatie een belangrijke marktkatalysator zijn en zal het testen of de aanzienlijke stijging van aandelen gerelateerd aan kunstmatige intelligentie kan worden volgehouden.</p>
<p>Volgens gegevens van het optie-analysebedrijf Trade  wordt verwacht dat de opties van Nvidia tegen vrijdag met 8,7% zullen schommelen, of een marktwaarde van $200 miljard. De aandelenkoers van deze chipfabrikant steeg dinsdag met 0,64% en na een stijging van bijna 240% in 2023, is deze tot nu toe dit jaar met ongeveer 93% gestegen.</p>
<p>Beleggers letten ook op de notulen van de laatste beleidsvergadering van de Federal Reserve, die gepland staat voor woensdag, nadat verschillende functionarissen van de Federal Reserve dinsdag de geduldige houding van de Fed voorafgaand aan renteverlagingen hebben versterkt.</p>
<p>Policymakers van de Federal Reserve zeiden dinsdag dat de Federal Reserve nog een paar maanden moet wachten om ervoor te zorgen dat de inflatie daadwerkelijk terugkeert naar het streefniveau van 2% voordat de rente wordt verlaagd.</p>
<p>Aziatische aandelenmarkten stegen lichtjes op woensdag, omdat bezorgde beleggers durfden te hopen dat de kunstmatige intelligentie-reus Nvidia aan zeer hoge verwachtingen kon voldoen, terwijl ze voorzichtig bleven over de rentevooruitzichten in de Verenigde Staten en het Verenigd Koninkrijk. De MSCI Asia Pacific Stock Index steeg met 0,4% en is vier opeenvolgende weken gestegen, waarmee het zijn hoogste punt in twee jaar bereikte. De Nikkei-index in Japan daalde met 0,6%.</p>
<p>De Bank of New Zealand heeft zijn inflatieprobleem geëvalueerd en verklaard dat de rentetarieven langer hoog moeten blijven om te kunnen omgaan met lokale marktschokken. Terwijl de obligatierendementen stegen, steeg de Nieuw-Zeelandse dollar met 0,9% ten opzichte van de Amerikaanse dollar naar een maandelijkse hoogte van $0,6151.</p>
<p>Vanwege de dreiging van Japanse interventie die de opkomst van de USD/JPY belemmert, bleef de wisselkoers van USD/JPY onveranderd op 156.20. De gegevens die zijn vrijgegeven door het Japanse Ministerie van Economie, Handel en Industrie tonen aan dat de depreciatie van de yen de export heeft bevorderd, maar ook invoerinflatie heeft veroorzaakt en het vertrouwen van bedrijven heeft beïnvloed.</p>
<p>De inflatiegegevens van het VK worden later vrijgegeven, wat kan bepalen of de Bank of England al in juni soepel beleid zal implementeren of wacht tot augustus. Verwacht wordt dat de kerninflatie van consumentenprijzen zal afnemen van 4,2% in maart tot 3,6% in april, en een lagere inflatie zal de mogelijkheid van een renteverlaging in juni verminderen en kan druk uitoefenen op het pond.</p>
<p>Wat betreft grondstoffen daalden de olieprijzen voor de derde opeenvolgende handelsdag op woensdag vanwege de marktverwachtingen dat de Federal Reserve de rentetarieven langdurig hoog kan houden vanwege aanhoudende inflatie, wat de brandstofconsumptie in ‘s werelds grootste olieverbruikende land kan beïnvloeden. Brent ruwe olie futures daalden met 43 cent, of 0,5%, tot $82,45 per vat. West Texas Intermediate ruwe olie (WTI) futures in de Verenigde Staten daalden met 50 cent, of 0,6%, tot $78,16. Op dinsdag daalden de olieprijzen met ongeveer 1%.</p>
<p>Na eerder deze week een historisch hoogtepunt van $2.449,89 te hebben bereikt, zijn de goudprijzen op $2.424 per ounce blijven hangen.</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 beleggingsadvies.<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 wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>