RGFnZWxpamtzIG5pZXV3cyB8IEFsaXBheSAmIEF2YWxhbmNoZSBsYW5jZWVyZGVuIGVlbiBvcCBXZWIzIGdlYmFzZWVyZCBwbGFuOyBFZW4gaGFuZGVsYWFyIHZlcmRpZW5kZSBiaW5uZW4gZWVuIHV1ciBlZW4gbmV0dG93aW5zdCB2YW4gJDlNIGRvb3IgdGUgaGFuZGVsZW4gaW4gbWVtZXM7IENyeXB0b1B1bmsgaGVlZnQgZGUgb3Agw6n

2024-03-21, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/17109934201_15.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Alipay20en20Avalanche20lanceerden20een20Web3gebaseerd20plan20Een20handelaar20verdiende20binnen20een20uur20een20nettowinst20van20920miljoen20door20te20handelen20in20meme20coins20CryptoPunk20heeft20de20op20een20na20duurste20NFT20in20de20geschiedenis20verkocht479144"><a name="Crypto Dagelijkse Samenvatting: Alipay en Avalanche lanceerden een Web3-gebaseerd plan; Een handelaar verdiende binnen een uur een nettowinst van $9 miljoen door te handelen in meme coins; CryptoPunk heeft de op een na duurste NFT in de geschiedenis verkocht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Alipay en <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> lanceerden een Web3-gebaseerd plan; Een handelaar verdiende binnen een uur een nettowinst van $9 miljoen door te handelen in meme coins; CryptoPunk heeft de op een na duurste NFT in de geschiedenis verkocht</h2><p>Laten we eerst de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens Farside Investor-gegevens bleven op 6 maart de GBTC-fondsen van Grayscale doorgaan. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stromen</a> aanzienlijk toenemen tot $386,6 miljoen; Ondertussen bedroeg de instroom van Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) $12,9 miljoen, de instroom van Bitwise Bitcoin spot ETF (BITB) $18,6 miljoen en de instroom van ARK 21Shares Bitcoin spot ETF (ARKB) $23,3 miljoen.</p>
<p>Het online betalingsplatform Alipay heeft samengewerkt met het smart contract blockchain platform <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a> om een voucherplan te creëren dat wordt ondersteund door Web3-technologie. Op 20 maart kondigde Avalanche aan dat Alipay+D-store, de abonnementsoplossing van Alipay, en zijn coöperatieve e-wallet Avalanche gebruikten om het couponprogramma met ondersteuning voor <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> te implementeren.</p>
<p>Het plan stelt consumenten in staat om vouchers te verkrijgen via mini-games. Na het voltooien van het spel kunnen klanten kortingsbonnen claimen in hun elektronische portemonnee. Er wordt gezegd dat deze kortingsbonnen gebruikers in staat stellen om tot 50% korting te krijgen bij meer dan 500 melktheewinkels.</p>
<p>Deze coupons worden ondersteund door het Avalanche subnet, dat wordt gebouwd en beheerd door AvaCloud. Volgens Avalanche zijn deze coupons ontworpen om Alipay en andere merken in staat te stellen “oplossingen te ervaren die worden ondersteund door Web3-technologie” - “POC zal Alipay, D-store en andere merken in staat stellen Web3-oplossingen te testen, waaronder hoe ze bedrijven kunnen helpen nieuwe vormen van interactie met gebruikers te vestigen, gebruikers te behouden en nieuwe inkomstenbronnen te creëren.”</p>
<p>Daarnaast heeft Avalanche ook gezegd dat het plan Alipay in staat stelt om blockchain-ondersteunde functies en digitale collecties te gebruiken om samen te werken met andere merken.</p>
<p>On-chain data toont aan dat een onbekende handelaar in minder dan een uur een winst van $8,9 miljoen heeft gemaakt door te handelen in Shroom meme munten binnen hetzelfde blok waar de ontwikkelaar de liquiditeit verhoogde.</p>
<p>De Room-token werd op 20 maart gelanceerd op Raydium als een meme-munt met een paddenstoelthema zonder potentieel nut of intrinsieke waarde. Sinds de lancering is de prijs van de token met meer dan 70% gedaald en de huidige marktwaarde is $11,88 miljoen.</p>
<p>De handelaar werd echter beschuldigd van ‘insider trading’ omdat zijn handelstiming te speciaal was en hij gemakkelijk winst maximaliseerde. X gebruiker Blockchain Maxi geloofde: ‘Dit is wat we insider trading noemen. Je kunt nooit winnen met memecoin, probeer het niet eens.’ Anonieme handelaar Bull.Bnb antwoordde op dezelfde post: ‘Dat is de ontwikkelaar zelf.’</p>
<p>Hoe dan ook, memecoin blijft de interesse van particuliere beleggers trekken. Volgens CoinMarketCap-gegevens is de recent gelanceerde Meme-token Book Of Meme (BOME) met meer dan 1.100% gestegen op de wekelijkse grafiek en is het de 130e grootste token geworden met een marktwaarde van $617 miljoen.</p>
<p>Op 20 maart werd de op één na duurste CryptoPunk in de geschiedenis verkocht voor 4.850 ETH, met een waarde van $16,42 miljoen. CryptoPunk #7804 is een van de negen zogenaamde ‘AlienPunks’ tussen de 10.000 NFT-collecties. Het versloeg de veiling van CryptoPunk #3100 op 4 maart voor 4.500 ETH ($16,03 miljoen).</p>
<p>De duurste CryptoPunk is nog steeds CryptoPunk #5822, verkocht op 12 februari 2022 voor 8.000 ETH en gewaardeerd op $23,7 miljoen.</p>
<h2 id="h2-Markttrends20De20Federal20Reserve20handhaaft20een20duifstandpunt20wat20leidt20tot20een20aanzienlijke20stijging20van20de20algehele20markt926339"><a name="Markttrends: De Federal Reserve handhaaft een duifstandpunt, wat leidt tot een aanzienlijke stijging van de algehele markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De Federal Reserve handhaaft een duifstandpunt, wat leidt tot een aanzienlijke stijging van de algehele markt</h2><p>De cryptomarkt is aanzienlijk hersteld, met BTC die terugkeert naar $68.000 en SOL die weer boven $190 uitkomt. Ondertussen zag de Amerikaanse aandelenmarkt ook een aanzienlijke stijging. Voorzitter van de Federal Reserve, Powell, verklaarde dat het mogelijk passend zou zijn om op enig moment dit jaar het beleid te versoepelen, maar het vooruitzicht blijft onzeker. Volgens de voorspelling van het Beleidspad Diagram kunnen er dit jaar drie renteverlagingen zijn, wat de markt aanzienlijk kan stimuleren.</p>
<h3 id="h3-Markt20Hotspots795332"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Met betrekking tot markthotspots zijn POLYX en ONDO in de RWA-sector gestegen. RWA is een relatief nieuw concept in de cryptocurrency-markt dat nog niet breed gehypet is. Ondertussen leidde het Meme-conceptsector de groei van de markt, met aanzienlijke stijgingen van FLOKI en PEPE. In een bullmarkt hebben tokens in de Meme-sector vaak een hoge elasticiteit. Daarnaast zag Runstone ook een aanzienlijke stijging, wat de stijging van BTC-ecosysteemmunten zoals STX en RIF heeft gestimuleerd.</p>
<h2 id="h2-Macro20De20Fed20kondigde20een20renteverlaging20van207520basispunten20aan20en20verkleinde20tegelijkertijd20haar20balans20Positieve20reactie20van20de20wereldwijde20markt976620"><a name="Macro: De Fed kondigde een renteverlaging van 75 basispunten aan en verkleinde tegelijkertijd haar balans; Positieve reactie van de wereldwijde markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Fed kondigde een renteverlaging van 75 basispunten aan en verkleinde tegelijkertijd haar balans; Positieve reactie van de wereldwijde markt</h2><p>Aan de wereldwijde marktzijde heeft de Federal Reserve aangekondigd dat het dit jaar de rentetarieven met 75 basispunten zal blijven verlagen, wat hoger is dan de 50 basispunten waar investeerders op hoopten. De markt heeft positief gereageerd op dit signaal. Het laatste rendement van een tweejarige schatkistobligatie is 4,59%, en dat van een tienjarige schatkistobligatie is 4,26%. De S&amp;P 500-index (.SPX) sloot op een historisch hoogtepunt, waarbij Europese en Amerikaanse futures stegen in Aziatische handel.</p>
<p>Op woensdag sloten de drie belangrijkste Wall Street aandelen 0,9% tot 1,2% hoger, terwijl het rendement van schatkist obligaties en de dollar daalden. Deze combinatie zou een vroege stijging in Azië moeten aangeven.</p>
<p>Voorzitter van de Federal Reserve Jerome Powell zei woensdag dat de Federal Reserve binnenkort zal beslissen om het tempo van de vermindering van de balans te vertragen, wat het mogelijk kan maken om meer obligaties te verminderen dan voorheen.</p>
<p>Powell zei tijdens een persconferentie na de vergadering van het Federal Open Market Committee: ‘Het is passend om zo snel mogelijk het tempo van de uiteindelijke verkiezing te vertragen.’ Hij gaf geen specifieke tijdslijn voor de beslissing, maar gaf alleen aan dat ambtenaren het onderwerp bespraken. Hij merkte op dat de centrale bank blijft proberen haar bezittingen te verminderen, algemeen bekend als kwantitatieve verkrapping (QT).</p>
<p>kwantitatieve versoepeling (QE) heeft ertoe geleid dat de Federal Reserve activa meer dan verdubbeld zijn, en tegen de zomer van 2022 $9 biljoen bedragen. De Federal Reserve begon in maart 2022 haar activa te verminderen en begon in maart 2022 haar activa te verminderen. De sterke renteverhoging heeft tot doel de hoge inflatie terug te brengen naar het streefcijfer van 2%.</p>
<p>Voor de vergadering van het Federal Open Market Committee (FOMC) verwachtte het overgrote deel van de economen dat het QT-verminderingsproces in juni zou beginnen en begin volgend jaar zou eindigen.</p>
<p>Wat betreft grondstoffen bleven de termijncontracten voor Brent ruwe olie stabiel op $86.34 per vat.</p>
<p>Met betrekking tot de goudprijs verlaagt een lagere rente de opportuniteitskosten van het aanhouden van onrendabele goud en legt druk op de Amerikaanse dollar, waardoor goud meer geschikt wordt voor beleggers die andere valuta aanhouden. Spot goud steeg met 0,8% naar $2.203,84 per ounce na een historisch hoogtepunt van $2.222,39 te hebben bereikt. Amerikaanse goud futures stegen met 2,1% naar $2.206,30.</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 op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen wordt juridische actie ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>