RGFnZWxpamtzIG5pZXV3cyB8IERvIEt3b24ncyBSZWxlYXNlIGJyZWVrdCBMVU5BIHZvb3JiaWogMSBVU0RUOyBEZSB0d2VlZGUgcm9uZGUgdmFuIEV0aGVyRmkgUG9pbnRzLWFjdGl2aXRlaXQgZ2VzdGFydDsgRGUgRVUga2V1cnQgaGV0IHZlcmJvZCBvcCBhbm9uaWVtZSBjcnlwdG8taGFuZGVsIGdvZWQ=

2024-03-25, 04:22

<p><img src="https://gimg2.gateimg.com/image/article/17113405241_17.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Do20Kwons20release20stelde20LUNA20in20staat20om20door20120USDT20te20breken20De20tweede20ronde20van20EtherFipuntenactiviteit20is20begonnen20Europese20Commissie20anonieme20cryptohandel20via20bewaarportefeuilles20is20verboden824115"><a name="Crypto Dagelijkse Samenvatting: Do Kwon’s release stelde LUNA in staat om door 1 USDT te breken; De tweede ronde van EtherFi-puntenactiviteit is begonnen; Europese Commissie: anonieme cryptohandel via bewaarportefeuilles is verboden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Do Kwon’s release stelde LUNA in staat om door 1 USDT te breken; De tweede ronde van EtherFi-puntenactiviteit is begonnen; Europese Commissie: anonieme cryptohandel via bewaarportefeuilles is verboden</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 bleven op 22 maart de GBTC-fondsen van Grayscale doorgaan met <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> namelijk $169,9 miljoen; Ondertussen bedroeg de instroom van het Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) $18,1 miljoen, de instroom van het Bitwise Bitcoin spot ETF (BITB) $16,3 miljoen en de instroom van het ARK 21Shares Bitcoin spot ETF (ARKB) $5,4 miljoen.</p>
<p>Volgens Bloomberg, op 23 maart, <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Medeoprichter Do Kwon en CFO Han Chong-Joon worden op borgtocht vrijgelaten voor 400.000 euro terwijl het Hooggerechtshof van Montenegro uitleveringsverzoeken van de Verenigde Staten en Zuid-Korea in behandeling neemt. Na verdere overweging door de rechtbank is het mogelijk om Do Kwon naar elk land uit te zetten. Volgens de Montenegrijnse autoriteiten zal Do Kwon uit de gevangenis worden vrijgelaten en onder ‘huisarrest’ worden geplaatst tijdens de vertraging in uitlevering. Na dit nieuws steeg LUNA ook boven 1 USDT als reactie.</p>
<p>Super <a href="/price/sushi-sushi" rel="nofollow noopener noreferrer" target="_blank">Sushi</a> Samurai, een lid van het Blast-ecosysteemproject, plaatste op het X-platform dat het probleem van gehackt worden door hackers als gevolg van de ‘verdubbeling van fondsen’ kwetsbaarheid is opgelost. Hij heeft besloten om White Hat-hackers te belonen met een beloning van 5% ETH, die het SSS-team zelf zal verstrekken. De overgebleven fondsen zullen worden overgeboekt naar de volgende multi-handtekeningenadressen onder controle van het SSS-team. Na analyse werd vastgesteld dat er een bug is in het tokencontract en dat het overboeken van het saldo naar zichzelf het saldo zal verdubbelen. De fondsen zijn veilig.</p>
<p>De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het ether.fi-project heeft aangekondigd dat het tweede seizoen van de puntactiviteit, StackRank, zal beginnen van 15 maart tot 30 juni. Gebruikers die langdurig staken zullen een beloning ontvangen, goed voor 5% van het totale aanbod van ETHFI.</p>
<p>De StackRank-activiteit omvat acht niveaus, waarbij deelnemers worden aangemoedigd om op lange termijn te staken. Elke 100 uur staken zal ETH met één niveau worden opgewaardeerd, met een hogere verbeteringssnelheid van loyaliteitspunten voor elk niveau. Het stakingsaldo moet hoger zijn dan 0,1 eETH om te worden opgewaardeerd. Vanaf rang II hebben gebruikers die deelnemen aan het eerste seizoen een upgrade-bereik van 1x tot 2x, terwijl Ether.Fan NFTT-gebruikers automatisch worden opgewaardeerd naar rang III.</p>
<p>Om nieuwe stakers eerlijk te behandelen, zal de accumulatiesnelheid van punten in het tweede kwartaal met tien keer toenemen. Alle ETH en weETH, ongeacht of ze in DeFi-posities worden aangehouden, zullen op gelijke wijze deelnemen aan opnieuw inzetten.</p>
<p>De EU-wet ter bestrijding van witwassen van geld heeft een beperking opgelegd aan cryptocurrencies, waarbij elke waarde van crypto-handel via bewaring van crypto-portefeuilles wordt verboden. Voorafgaand hieraan waren de Europese Raad en het Parlement tijdelijk overeengekomen om enkele van de EU-wetten ter bestrijding van witwassen van geld (AML) en financiering van terrorisme uit te breiden om de cryptomarkt te bestrijken.</p>
<p>Volgens de nieuwe voorschriften zullen anonieme contante betalingen van meer dan 3.000 euro verboden zijn bij commerciële transacties, en contante betalingen van meer dan 10.000 euro zullen volledig verboden zijn bij commerciële transacties. De reactie van de cryptogemeenschap op EU-regelgevende maatregelen is inconsistent. Sommigen geloven dat nieuwe anti-witwaswetten noodzakelijk zijn, terwijl anderen zich zorgen maken dat ze inbreuk kunnen maken op de privacy en economische activiteiten kunnen beperken.</p>
<p>Het decentralisatieprincipe van cryptocurrency stelt veel cryptonetwerken in staat om te werken in een omgeving zonder toestemming, waardoor iedereen crypto-privésleutels kan creëren en onbeperkte anonieme toegang tot het systeem kan hebben. Daarom is de mate van beperking van deze regelgeving relatief duidelijk.</p>
<p>Sound Money Bitcoin podcasthost Daniel ‘Loddi’ Tröster benadrukte de praktische obstakels en gevolgen van recente wetgeving. Hij schetste de impact op donaties en de bredere impact op het gebruik van cryptocurrencies binnen de EU, en uitte bezorgdheid over de mogelijke remmende effecten van deze regels.</p>
<h2 id="h2-Markttrends20De20algemene20markt20herstelt20zich20maar20bevindt20zich20nog20steeds20in20een20volatiel20bereik703096"><a name="Markttrends: De algemene markt herstelt zich, maar bevindt zich nog steeds in een volatiel bereik" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De algemene markt herstelt zich, maar bevindt zich nog steeds in een volatiel bereik</h2><p>Vandaag vertoont de algemene cryptomarkt een opwaartse trend, maar de markt bevindt zich nog steeds in een volatiele fase. Vooral Bitcoin spot ETF’s hebben gedurende vijf opeenvolgende dagen netto uitstroom laten zien. Hoewel Bitcoin ooit historische hoogtepunten bereikte, namen de aankopen van spot ETF’s geleidelijk af, maar de uitstroom nam geleidelijk af, wat aangeeft dat het marktsentiment langzaam stabiliseert. Wat betreft de macro-economie schommelde de Amerikaanse aandelenmarkt, terwijl de Amerikaanse dollarindex tekenen van herstel vertoonde.</p>
<h3 id="h3-Markt20Hotspots6358"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Hong Kong concept tokens zijn gestegen:<br>De hete onderwerpen van vandaag zijn voornamelijk gericht op de opwindende Hong Kong Web3-conferentie, waarbij de Hong Kong conceptserie-tokens veelbelovende groei vertonen. ACH, CFX en andere tokens hebben een uitstekende prestatie geleverd, met nieuws van de april Hong Kong Web3-conferentie. Voor de Hong Kong Web3-conferentie van 2023 hadden Hong Kong concepttokens al indrukwekkende prestaties laten zien, waarbij ACH, CFX, KEY en andere tokens aanzienlijk stegen. Dit geeft aan dat beleggers hoge verwachtingen hebben van de Hong Kong Web3-conferentie en de markt actief de prestaties van gerelateerde tokens heeft gevolgd.</p>
<p>Het concept van een openbare blockchain heeft een goede groei gezien:<br>Het concept van een openbare blockchain is ook een van de populaire onderwerpen op de markt, met tokens zoals ICP, NEAR en RUNE die allemaal een stijging laten zien. Vooral TON steeg met 25% in het weekend, wat de aandacht van de markt trok. Het aantal gebruikers van Telegram is gestegen tot meer dan 800 miljoen, terwijl het aantal actieve adressen van de Ton blockchain slechts 300.000 is, wat aangeeft dat het project enorm potentieel heeft op het gebied van gebruikers. Als gevolg van het nieuws over de mogelijke beursgang van Telegram in de toekomst, is de recente prestatie van Ton Public Chain ook zeer indrukwekkend, met prijzen die in de afgelopen maand verdubbeld zijn. Dit toont de voorkeur van de markt voor openbare blockchainprojecten met sterke achtergrondsteun en investeerders geven dus de voorkeur aan de bijbehorende tokens.</p>
<p>Opkomst van het faillissementsconcept token LUNA:<br>Een ander actueel onderwerp is de opkomst van het faillissementsconcept token LUNA, dat op de 7e met bijna 50% is gestegen. Het nieuws over deze stijgende trend komt voort uit geruchten dat er mogelijk een keerpunt is in de DK-zaak, wat de aandacht van de markt heeft getrokken. Hoewel de specifieke voortgang van de zaak nog niet duidelijk is, heeft de markt een positieve houding getoond ten opzichte van mogelijke goede nieuws, wat heeft geleid tot de stijging van LUNA-tokens.</p>
<p>Over het algemeen heeft de markt vandaag een herstelpatroon laten zien, maar het bevindt zich nog steeds in een volatiele range. Beleggers moeten voorzichtig blijven en de verdere markttrends nauwlettend in de gaten houden om hun beleggingsstrategieën aan te passen op basis van de werkelijke omstandigheden. De hype van de Hong Kong Web3-conferentie, de populariteit van het openbare ketenconcept en de trend van faillissementsconcepttokens zijn allemaal belangrijke factoren die aandacht behoeven.</p>
<h2 id="h2-Macro20De20mogelijkheid20van20ruim20monetair20beleid20neemt20toe20en20de20wereldwijde20markttrend20blijft20stabiel570234"><a name="Macro: De mogelijkheid van ruim monetair beleid neemt toe en de wereldwijde markttrend blijft stabiel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De mogelijkheid van ruim monetair beleid neemt toe en de wereldwijde markttrend blijft stabiel</h2><p>Reuters meldde dat veel markten op vrijdag gesloten zullen zijn vanwege Pasen, en dat de PCE-gegevens dan zullen worden vrijgegeven, dus een uitgebreide reactie moet wachten tot volgende week. Voorzitter van de Federal Reserve Jerome Powell leek vorige week voldoende dovish te zijn en hintte op soepel beleid in juni.</p>
<p>Powell zal de voorzittende bespreking van de beleidsvergadering van vrijdag bijwonen, en de directeuren van de Federal Reserve Lisa Cook en Christopher Waller zullen deze week ook aanwezig zijn. Volgens de FedWatch-tool van CME geloven handelaren dat de kans op de eerste renteverlaging in juni ongeveer 71% is, vergeleken met 56% aan het begin van deze week.</p>
<p>De verwachting van een daling van de wereldwijde leenkosten is positief voor de aandelenmarkt, met de Nikkei-index die daalt en de S&amp;P 500-index futures die onveranderd blijven. De S&amp;P 500-index is dit jaar bijna 10% gestegen. Op maandag bleef de handel in S&amp;P 500-index futures en NASDAQ-futures grotendeels ongewijzigd. Op 22 maart werden de NASDAQ-index en de Semiconductor-index (.SOX) iets hoger afgesloten, en vanwege aanhoudende… <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> over kunstmatige intelligentie steeg ook deze week aanzienlijk. De Semiconductor-index steeg ook aanzienlijk deze week. De Dow Jones-index sloot lager op de dag.</p>
<p>Op het gebied van valuta daalde de Amerikaanse dollar iets ten opzichte van de Japanse yen naar 151,23 yen op maandag en steeg vorige week met 1,6%, waarmee het een piek bereikte van 151,86 yen.</p>
<p>De markt is voorzichtig met het testen van 152,00, omdat dit niveau eerder Japanse interventie heeft veroorzaakt. In feite heeft de Chief Monetary Officer van Japan maandag gewaarschuwd dat de huidige zwakte van de yen niet overeenkomt met de fundamentals en overmatige volatiliteit ongewenst is. Zelfs als de Bank of Japan haar zeer losse beleid opgeeft, kan het de Amerikaanse dollar niet verzwakken, omdat beleggers geloven dat dit niet het begin is van een reeks renteverhogingen.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen gestegen in de vroege Aziatische handel op maandag, vanwege zorgen op de markt dat toenemende conflicten tussen het Midden-Oosten, Rusland en Oekraïne kunnen leiden tot een beperking van het wereldwijde aanbod, terwijl de vermindering van het aantal boorplatforms in de VS ook druk toevoegde aan de stijging van de olieprijzen.</p>
<p>Futures voor Brent ruwe olie stegen met 24 dollarcent naar $85,67 per vat. Futures voor Amerikaanse ruwe olie stegen met 25 dollarcent naar $80,88 per vat. Beide benchmarks vertoonden een verandering van minder dan 1% vergeleken met de vorige week.</p>
<p>Na vorige week een historisch hoogtepunt van $2.217,79 te hebben bereikt, zijn de goudprijzen licht gestegen naar $2.174 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 zich alle rechten voor 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 vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>