RGFnZWxpamtzIE5pZXV3cyB8IENyeXB0byBNYXJrdCBIZXJzdGVsdCwgQUkgU2VjdG9yIEtvbXQgU3RlcmtlciBUZXJ1ZzsgVHJ1bXAncyBTdGV1biB2b29yIENyeXB0byBMZWlkZGUgdG90IGVlbiBUb2VuYW1lIGluIEJpZGVuLVRydW1wIEdlcmVsYXRlZXJkZSBNZW1lcw==

2024-05-10, 03:33

<p><img src="https://gimg2.gateimg.com/image/article/17153119761_6-05.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20steun20van20Trump20voor20cryptocurrencies20leidde20tot20een20toename20in20BidenTrump20gerelateerde20memes20De20kostenstijging20brengt20druk20op20de20Uniswap20frontend20AgriDEX20haalde20520miljoen20op20en20kondigt20plannen20aan20voor20een20airdrop33675"><a name="Crypto Dagelijkse Samenvatting: De steun van Trump voor cryptocurrencies leidde tot een toename in Biden-Trump gerelateerde memes; De kostenstijging brengt druk op de Uniswap front-end; AgriDEX haalde $5 miljoen op en kondigt plannen aan voor een airdrop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De steun van Trump voor cryptocurrencies leidde tot een toename in Biden-Trump gerelateerde memes; De kostenstijging brengt druk op de <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> front-end; AgriDEX haalde $5 miljoen op en kondigt plannen aan voor een airdrop</h2><p>Laten we eerst eens kijken naar de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens de gegevens van Farside Investor kende Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 9 mei nog steeds uitstroom van $43,4 miljoen aan fondsen; Intussen zag Fidelity Bitcoin spot ETF (FBTC) een instroom van $2,7 miljoen, samen met Bitwise Bitcoin spot ETF (BITB) die een instroom van $6,8 miljoen ervoer, en ARK 21Shares Bitcoin spot ETF (ARKB) kreeg een instroom van $2,2 miljoen.</p>
<p>Na opmerkingen van de Republikeinse presidentskandidaat Donald Trump over cryptocurrency presteerden de op politiek geïnspireerde memecoins goed, waarbij de memecoin MAGA die gerelateerd is aan Trump met 78% steeg op 9 mei (verwijzend naar Trump’s populaire politieke slogan “Make America Great Again”). Donald Tremp (TREMP) steeg met 79,5% in zeven dagen en is in de afgelopen 24 uur meer dan 100% gestegen. BODEN (een token dat de naam van Biden parodieert) heeft ook een aanzienlijke prijsstijging gezien.</p>
<p>De populariteit van deze politieke memes was te danken aan Trump’s toespraak tijdens een diner voor NFT-houders in Florida op 8 mei. Hij sprak zijn steun uit voor cryptocurrencies en toen hem werd gevraagd of zijn campagne crypto-donaties accepteert, antwoordde Trump ja en ‘hij zal ervoor zorgen’. Hij wees er ook op dat de huidige Amerikaanse president Biden en zijn regering tegen de crypto-industrie zijn, terwijl hijzelf het steunt. En als hij cryptogeld ondersteunt, zou je op hem moeten stemmen.</p>
<p>Kortom, de tokens die verband houden met deze twee kandidaten hebben aanzienlijke populariteit laten zien en vallen op in de relatief trage cryptomarkt van de afgelopen twee dagen.</p>
<p>De <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> De front-end ondervindt druk, voornamelijk als gevolg van de aanpassing van Uniswap Labs medio april om de wisselkosten op zijn interfaces te verhogen van 0,15% naar 0,25%. Hoewel niet alle gebruikers hierdoor zijn getroffen, heeft deze wijziging nog steeds invloed op de meerderheid van de gebruikers die de Uniswap-netwerkinterface en -portemonnee gebruiken voor transacties.</p>
<p>De tariefaanpassing is te wijten aan Uniswap die een Wells-melding van de SEC heeft ontvangen. In reactie op deze waarschuwing van de SEC is Uniswap Labs van mening dat het gewoon een website exploiteert die mensen toegang geeft tot het Uniswap-protocol - een set slimme contracten en gedecentraliseerde uitwisselingen voor cryptocurrencies die niet onderhevig zouden moeten zijn aan conventionele effectenregulering.</p>
<p>De stijging van de kosten heeft invloed gehad op de populariteit van de Uniswap-interface. In april daalde het aandeel van de Uniswap-frontend in DEX-activiteiten naar 30%, vergeleken met 35,8% in maart.</p>
<p>Hoewel de interface van Uniswap Labs is beïnvloed, zijn er nog steeds andere manieren om Uniswap te gebruiken voor handel, waaronder het gebruik van aggregators, alternatieve gebruikersinterfaces of rechtstreeks handelen via slimme contracten. Ondanks enkele uitdagingen blijft Uniswap een van de meest populaire DEX’en van dit moment.</p>
<p>AgriDex, een platform gebaseerd op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> AgriDex, een netwerk dat zich richt op de tokenisatie van landbouw, heeft aangekondigd dat het succesvol $5 miljoen heeft opgehaald vóór de seedronde. AgriDex, gevestigd in Londen, heeft op donderdag aangekondigd dat durfkapitaalfirma Endeavor Ventures de financieringsronde heeft geleid, terwijl African Crops Limited, Oldenburg Vineyards, evenals voormalige Goldman Sachs en Citadel utives Hank Oberoi ook hebben deelgenomen aan de investeringsrondes.</p>
<p>AgriDex maakt tokenisatie van landbouwproducten mogelijk en ondersteunt de handel in deze getokeniseerde goederen. Op AgriDex wordt elke transactie vastgelegd in de vorm van geslagen NFT’s, die alle product-, prijs-, betalings- en andere gedetailleerde informatie permanent vastleggen. AgriDex is van plan om eerst landbouwproducten zoals suiker, granen en cacao te tokeniseren en te noteren, en heeft aangegeven dat het in de toekomst de notering van meer goederen zal ondersteunen door samenwerking met nieuwe partners en investeerders.</p>
<p>Medeoprichter Duckworth verklaarde dat AgriDex van plan is om zijn platform en token $AGRI in het derde kwartaal van dit jaar te lanceren. De totale voorraad tokens zal 1 miljard zijn, waarvan 50 miljoen zullen worden gebruikt voor luchtdroppings. Het bedrijf is van plan om zijn tokens openbaar te verkopen tegen een prijs van $0.10 per token.</p>
<p>De eerder gemelde aanval op adresvergiftiging heeft verdere vooruitgang geboekt - op 3 mei heeft een gebruiker 1.155 wBTC’s overgemaakt naar een vermoedelijk vergiftigingsadres ter waarde van $ 71 miljoen. Vergiftigde aanvallers maken vaak gebruik van ijdelheidsdiensten of maken een groot aantal digitale portemonnees, waardoor valse adressen erg lijken op de portemonnee van het slachtoffer, waardoor overschrijvingen van het oorspronkelijke doelwit naar het verkeerde adres worden omgeleid.</p>
<p>Op 9 mei was er nieuw progressie in het incident, aangezien de aanvaller contact opnam met het slachtoffer en om hun Telegram vroeg, en meer dan 51 ETH’s (ongeveer $151,600) stuurde. Volgens de blockchain tracking platform Etherscan’s on-chain data stuurde de virusaanval oplichter twee berichten naar het slachtoffer: “Laat alsjeblieft je TG achter, ik zal contact met je opnemen.”</p>
<p>Natuurlijk is het bedrag veel lager dan het verliesbedrag, dus het slachtoffer blijft een terugbetaling van 90% van de andere partij eisen, en de verdere ontwikkeling is nog steeds onduidelijk.</p>
<h2 id="h2-Markttrends20De20markt20is20aanzienlijk20hersteld20en20het20concept20van20AI20blijft20de20belangrijkste20focus133430"><a name="Markttrends: De markt is aanzienlijk hersteld en het concept van AI blijft de belangrijkste focus" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt is aanzienlijk hersteld en het concept van AI blijft de belangrijkste focus</h2><p>BTC presteerde sterk op de markt en steeg op een gegeven moment naar $63.400, wat leidde tot een algemeen herstel van de cryptomarkt, vergezeld van een algemene stijging van Altcoins. Op macro-economisch gebied presteerde de Amerikaanse aandelenmarkt positief, met de laatste werkloosheidscijfers lager dan verwacht, wat de marktverwachtingen voor een recente renteverlaging versterkt.</p>
<h3 id="h3-Markt20Hotspots884932"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Het Ton-ecosysteem en het Notcoin-project zijn gelanceerd: Het Meme-project Notcoin onder het Ton-ecosysteem is onlangs gelanceerd op belangrijke handelsplatforms, waardoor gebruikers tokens kunnen verdienen door op hun telefoons te klikken om te mijnen. Notcoin beweert meer dan 300.000 gebruikers en 50.000 dagelijks actieve gebruikers te hebben. Wanneer het online gaat, is het 100% volledig in omloop, met een verwachte marktwaarde van ongeveer $1 miljard. De snelle lancering van NOT door handelsplatforms kan te wijten zijn aan <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> over zijn uitgebreide gebruikersbestand.</p>
<p>De voortdurende opkomst van AI-concepten: In navolging van de huidige markttrends hebben tokens met kunstmatige intelligentie-thema’s zoals ARKM, RNDR, AR, LPT, AKT en TURBO aanzienlijke prijsstijgingen bereikt. Dit weerspiegelt dat de concepten van AI en Meme blijven domineren op de huidige cryptomarkt.</p>
<p>Politieke gebeurtenissen die de markt beïnvloeden: Onlangs kondigde Donald Trump aan dat zijn presidentscampagne cryptocurrencies zal ondersteunen, wat leidde tot een stijging van de prijzen van Trump-gerelateerde concepttokens zoals TREMP en MAGA. Dit toont aan dat politieke gebeurtenissen en persoonlijke invloed in korte tijd aanzienlijke invloed kunnen hebben op de marktprestaties van specifieke cryptocurrencies.</p>
<p>Met de opkomst van Bitcoin en grote Altcoins is het algemene sentiment op de cryptomarkt relatief optimistisch. Toch moeten beleggers zich bewust zijn van mogelijke marktfluctuaties, vooral wanneer politieke gebeurtenissen en macro-economische gegevens worden vrijgegeven. Het wordt aanbevolen dat beleggers de trends blijven volgen van AI- en Meme-gerelateerde projecten, terwijl ze aandacht besteden aan de mondiale macro-economische omstandigheden en beleidswijzigingen, om tijdig beleggingsstrategieën aan te passen.</p>
<h2 id="h2-Macro20Dow20Jones20steeg20zeven20opeenvolgende20dagen20werkgelegenheidsgegevens20stimuleerden20de20verwachtingen20van20renteverlagingen20en20de20wereldwijde20marktprestaties20waren20optimistisch168497"><a name="Macro: Dow Jones steeg zeven opeenvolgende dagen, werkgelegenheidsgegevens stimuleerden de verwachtingen van renteverlagingen en de wereldwijde marktprestaties waren optimistisch" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Dow Jones steeg zeven opeenvolgende dagen, werkgelegenheidsgegevens stimuleerden de verwachtingen van renteverlagingen en de wereldwijde marktprestaties waren optimistisch</h2><p>Op 9 mei stegen de drie belangrijkste aandelenindices in de Verenigde Staten over de hele linie. De Dow Jones Industrial Average sloot hoger op donderdag en markeerde de zevende opeenvolgende dag van winsten voor de benchmark-index. Het positieve nieuws komt van de wekelijkse werkloosheidsaanvragen, wat nieuwe hoop brengt op renteverlagingen.</p>
<p>Volgens gegevens vrijgegeven door het Amerikaanse ministerie van Arbeid is het aantal eerste aanvragen voor werkloosheidsuitkeringen in de Verenigde Staten gestegen met 22.000 tot 231.000 na seizoensaanpassingen, wat hoger is dan verwacht. De vertraging in de werkgelegenheidsgroei in april en de daling van het aantal vacatures in maart tot het laagste punt in drie jaar hebben beleggers doen anticiperen dat de Federal Reserve dit jaar tweemaal de rente zou kunnen verlagen, terwijl handelaren eerder slechts op één renteverlaging rekenden.</p>
<p>Specifieke prestaties van de aandelenindex: de Dow Jones-index steeg met 0,85%, de Standard &amp; Poor’s-index steeg met 0,51% en de Nasdaq-index steeg met 0,27%.</p>
<p>Op 10 mei stegen de Aziatische aandelenmarkten op vrijdag en wordt verwacht dat ze voor de derde opeenvolgende week zullen stijgen, terwijl de Amerikaanse dollar in het nadeel is. De MSCI Asia Pacific aandelenindex steeg met 0,66% en wordt verwacht bijna 1% te stijgen deze week, waarmee het zijn derde opeenvolgende week van winst behaalt. De Nikkei-index in Japan steeg met 1,6%. Blue chip aandelen op de Chinese aandelenmarkt stegen met 0,14%, terwijl de Hang Seng Index in Hong Kong met 1,4% steeg en in de vroege handel een hoogtepunt van acht maanden bereikte.</p>
<p>De consumptiebestedingen in Japan waren zwak in maart en daalden voor de 13e opeenvolgende maand, en huishoudens vertraagden opnieuw, wat een uitdaging vormt voor beleidsmakers, aangezien zwakke huishoudelijke consumptie een zorg is. Ze hopen sterke loonstijgingen en stabiele consumptiebestedingen te zien die duurzame economische groei stimuleren. Echte loongroei is een voorwaarde voor de centrale bank om de rentetarieven verder te verhogen.</p>
<p>Nadat de Bank of England de rentetarieven al vanaf volgende maand begon te verlagen om de weg vrij te maken, stabiliseerde het pond op $1.2515 en bereikte donderdag een dieptepunt van twee weken van $1.2446. De verwachte veranderingen in de Amerikaanse rentetarieven hebben geleid tot aanhoudende schommelingen in de Amerikaanse dollar, waarbij de euro een overnachtse stijging van 0,3% tegenover de Amerikaanse dollar handhaafde en uiteindelijk sloot op $1.0778. Verwacht wordt dat de eenheidsmunt voor de vierde opeenvolgende week zal stijgen ten opzichte van de Amerikaanse dollar.</p>
<p>De markt zal volgende week nauwlettend toezien op de publicatie van de Amerikaanse producentenprijsindex (PPI) en consumentenprijsindex (CPI) van april, om te kijken of er tekenen zijn dat de inflatie weer een neerwaartse trend vertoont en de doelrente van de Federal Reserve van 2% nadert.</p>
<p>Handelaren verwachten momenteel dat de Federal Reserve de rente dit jaar met 47 basispunten zal verlagen, ver onder hun verwachte 150 basispunten in het begin van 2024.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen gestegen, met Amerikaanse ruwe olie die met 0,63% stijgt naar $79,76 per vat en Brent ruwe olie die met 0,54% stijgt naar $84,33.</p>
<p>Spotgoud steeg met 0,3% naar $2.352,92 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 standpunten 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 zal worden toegestaan, op voorwaarde dat Gate.io wordt genoemd. In alle glen zal juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>