RGFnZWxpamtzIG5pZXV3cyB8IHZlcnNjaGlsbGVuZGUgYmVrZW5kZSBBSS1wcm9qZWN0ZW4gb25kZXJnYWFuICd0b2tlbiBzYW1lbnZvZWdpbmcnOyBMaW5lYSB2b2VydCBlZW4gc3RpamdpbmdzYWN0aXZpdGVpdCB1aXQ7IE11bmNoYWJsZXMgSGFja2VyIGtlZXJ0IGdlc3RvbGVuIGZvbmRzZW4gdGVydWc=

2024-03-28, 04:18

<p><img src="https://gimg2.gateimg.com/image/article/17115994531_20.png" alt=""><a href="/price/0x-zrx" rel="nofollow noopener noreferrer" target="_blank">ZRX Crypto</a><br>Laten we eerst de handelsactiviteit van onderzoeken. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens Farside Investor-gegevens bedroeg de uitstroom van Grayscale’s GBTC-fonds op 27 maart $299,8 miljoen; Ondertussen was er een instroom van $1,5 miljoen voor het Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC), een instroom van $201,8 miljoen voor het ARK 21Shares Bitcoin spot ETF (ARKB) en een nettostroom van $1,5 miljoen voor het WisdomTree Bitcoin spot ETF (BTCW).</p>
<p><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L2 Network Linea heeft een nieuwe activiteit aangekondigd genaamd The Linea Voyage Surge, die naar verwachting in april zal worden gelanceerd met als doel liquiditeit aan te trekken voor het netwerk.</p>
<p>De activiteit zal duren 6 maanden, of totdat de TVL $3 miljard bereikt. Surge zal momentum in het ecosysteem brengen door TVL naar het netwerk te brengen en de strategische inzet van activa om te zetten in gamificatie.</p>
<p>Het $7,5 miljard token fusieplan, bestaande uit AI-protocollen SingularityNet, <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a>, en Ocean Protocol, zullen worden goedgekeurd door de gemeenschap bij stemming op 2 april.</p>
<p>Volgens de aankondiging van 27 maart zal elk protocol drie onafhankelijke gemeenschapsstemmen hebben, die allemaal gepland staan ​​om op 16 april te worden voltooid. Als ze worden goedgekeurd, worden SingularityNet’s AGIX-token, Fetch.ai’s FET-token en Ocean Protocol’s OCEAN-token vervangen door nieuwe tokens, namelijk ASI-tokens die toebehoren aan de Artificial Super Intelligence Alliance.</p>
<p>Op 26 maart bedraagt de huidige gecombineerde marktwaarde van deze drie tokens ongeveer $5,3 miljard en zal de volledig verwaterde marktwaarde van de samengevoegde tokens $7,6 miljard bedragen, met betrekking tot 2,631 miljard tokens.</p>
<p>FET zal de reservuta van ASI worden en gebruikers kunnen OCEAN en AGIX tegen een nieuwe vaste wisselkoers omwisselen voor ASI.</p>
<p>“Indien goedgekeurd, kunnen $FET worden ingewisseld voor kunstmatige superintelligentie-tokens in een verhouding van 1:1”, aldus het team. “Als u bijvoorbeeld $ 100 FET bezit, kunt u deze inwisselen voor $ 100 kunstmatige-intelligentietokens.”</p>
<p>Op 26 maart meldde Munchables, een op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> gebaseerd NFT-spel, een hacker aanval waarbij meer dan 17.400 ETH werd gestolen. Munchables, samen met blockchain onderzoekers zoals PeckShield en ZachXBT, begon de bewegingen van gestolen fondsen te volgen in een poging om ze te onderscheppen.</p>
<p>ZachXBT beweert dat de kwetsbaarheid voortkwam uit het feit dat het Munchables-team een Noord-Koreaanse ontwikkelaar inhuurde onder het pseudoniem ‘Werewolves0943’. Op 27 maart bevestigde Munchables dat de hacker een van hun ontwikkelaars was. Na een uur onderhandelen stemde de andere partij ermee in om het geld van de hacker terug te geven.</p>
<p>“De ontwikkelaar van Munchables heeft alle relevante privésleutels gedeeld om te helpen bij het terugvorderen van gebruikersfondsen.” De maker van Blast (pseudoniem Pacman) bedankte ZachXBT voor hun steun en kondigde aan: “De voormalige Munchables-ontwikkelaar koos er uiteindelijk voor om al het geld terug te geven zonder losgeld.”</p>
<h2 id="h2-Markttrends20De20markt20speculeert20over20nieuwe20munten20is20er20een20mogelijkheid20tot20marktaanpassing172613"><a name="Markttrends: De markt speculeert over nieuwe munten, is er een mogelijkheid tot marktaanpassing?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt speculeert over nieuwe munten, is er een mogelijkheid tot marktaanpassing?</h2><p>Gisteren ondervonden BTC-prijzen een scherpe daling nadat ze boven de $71.000 waren gestegen, wat leidde tot een breedgedragen daling op de hele Altcoin-markt. Tegelijkertijd steeg de Amerikaanse aandelenmarkt, maar Nvidia, het toonaangevende AI-bedrijf, ondervond een daling. Dit duidt op een zekere mate van onzekerheid op de markt, met name op de cryptomarkt.</p>
<h3 id="h3-Markt20Hotspots708651"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>GT: Vandaag steeg GT bijna 20%, brak door de $10-grens, nog maar één stap verwijderd van een historisch hoogtepunt. De sterke prestaties van GT worden mogelijk gezocht door marktfondsen.</p>
<p>ETHERFI en AEVO: Beide zagen gisteren een aanzienlijke stijging, waarbij ETHERFI op een gegeven moment doorbrak tot $8,5. De financieringswaardering van Etherfi was twee maanden geleden $200 miljoen en nu is de marktwaarde in de afgelopen twee maanden meer dan 42 keer gestegen. Het negatieve tarief op de AEVO-contractmarkt is zo hoog als -1%, wat wijst op een aanzienlijke bearish trend. Op dit moment speculeert de markt over dit soort nieuwe valuta vanwege de goede chipstructuur en de lage circulatie op de markt. Dit kan een voorbode zijn van een correctie op de markt.</p>
<p>OCEAN, FET en AGIX in de AI-sector: Na de aankondiging van Bloomberg over de fusie van drie projecten, zagen de genoemde tokens een stijging. Het voorgestelde fusieproject kan arbitragemogelijkheden op de markt brengen, maar het is ook nodig om de voortgang van de fusie en de marktreacties nauwlettend te volgen. In april 2021 kondigden Keep Network en Nucyher ook een fusieproject aan, met de naam T voor de samengevoegde token.</p>
<p>Echter vond de fusie eigenlijk 8 maanden later plaats, tijdens een bullmarkt voor de gehele cryptomarkt, en KEEP en NU hebben ook meerdere keren toename ervaren. T is gelanceerd op <a href="http://Gate.io" rel="nofollow noopener noreferrer" target="_blank">Gate.io</a>.</p>
<p>Openbare keten SUI: De prijs van SUI is gestegen en heeft een nieuw hoogtepunt bereikt, en ook de bijbehorende ecosysteemprojecten zijn gevolgd. SUI staat op het punt om op 10 april een conferentie te houden, en de recente subsidie voor het ecosysteem op de keten geeft aan dat de ontwikkelingsdynamiek van het ecosysteem sterk is.</p>
<h2 id="h2-Macro20Wall20Street20steeg20op20woensdag20Aziatische20markten20bleven20stabiel20met20lichte20schommelingen20in20grondstoffen509941"><a name="Macro: Wall Street steeg op woensdag, Aziatische markten bleven stabiel, met lichte schommelingen in grondstoffen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wall Street steeg op woensdag, Aziatische markten bleven stabiel, met lichte schommelingen in grondstoffen</h2><p>Op 28 maart meldde Reuters dat de markt grotendeels vooruitliep op de zeer verwachte gegevens van de Amerikaanse Core Personal Consumption Expenditure (PCE) prijsindex, die de voorkeursinflatie-indicator is van de Federal Reserve. Vanwege het lange paasweekend in veel landen kunnen maar weinig markten nieuwe gegevens verwerken.<br>De onverwachte inflatie dit jaar heeft twijfels opgeworpen of de Federal Reserve aan zijn voorspellingen kan voldoen. Functionarissen van de Federal Reserve wachten af of recente gegevens wijzen op een tijdelijke tegenslag bij inspanningen om de prijsdruk te verminderen. Als dat het g is, kan dit betekenen dat de renteverwachtingen voor dit jaar worden verlaagd.</p>
<p>Tijdens een persconferentie na de beleidsvergadering van vorige week verklaarde voorzitter van de Federal Reserve, Jerome Powell, dat de huidige beleidsrisico’s ‘dubbelzijdig’ zijn.</p>
<p>Onze huidige situatie is dat als we te veel of te snel versoepelen, we een heropleving van de inflatie kunnen zien; Als we te laat versoepelen, kunnen we onnodige schade toebrengen aan de werkgelegenheid en het werk en leven van mensen. Hij voegde eraan toe: “We moeten voorzichtig zijn”, aangezien de sterke economie de Federal Reserve de ruimte geeft om gegevens te observeren voordat ze een beslissing neemt over het rentebeleid.</p>
<p>De Amerikaanse aandelenmarkt steeg op woensdag, waarbij de Dow Jones-index leidend was en de S&amp;P 500-index een sluitingsrecord vestigde. Beleggers kijken uit naar inflatiegegevens en signalen van de Federal Reserve over de koers van de rentetarieven. De Dow Jones Industrial Average steeg met 1,22% tot 39.760,08, terwijl de S&amp;P 500 Index (.SPX) met 0,86% steeg tot 5.248,49; De Nasdaq Composite Index (.IXIC) steeg met 0,51% tot 16.399,52 punten.</p>
<p>Deze groei markeert de grootste dagelijkse procentuele stijging in de Dow Jones-index sinds 13 december.</p>
<p>Op donderdag bereikte de Japanse yen in de Aziatische markt bijna zijn laagste punt in decennia, ondanks de dreiging van interventie van de Japanse autoriteiten waardoor investeerders voorzichtig waren om de valuta tot nieuwe dieptepunten te duwen, en Aziatische aandelenmarkten daalden naar belangrijke inflatieniveaus in de Verenigde Staten.</p>
<p>De daling van de wisselkoers van de Japanse yen is gunstig voor de Nikkei-index (.N225), die tot nu toe met ongeveer 3% is gestegen deze maand. De Nikkei-index (.N225) daalde vorige maand met 1%, maar het is nog steeds niet ver verwijderd van zijn historische hoogtepunt.</p>
<p>In China hebben sterke verkopen door buitenlandse beleggers druk uitgeoefend op de aandelenmarkt, waardoor deze rood kleurde. De blue chip Shanghai en Shenzhen 300 Index (.CSI300) daalden naar een dieptepunt van een maand in de vroege handel, terwijl de Shanghai Composite Index (.SSEC) worstelde om door de psychologische barrière van 3000 punten te breken en met 0,1% daalde.</p>
<p>Vanwege een gebrek aan urgentie om de rentetarieven te verlagen, blijft de Amerikaanse dollar op monetair gebied vooroplopen en plaatsen handelaren grotere weddenschappen op soortgelijke maatregelen van de Europese Centrale Bank en de Bank of England voor de maand. De euro daalde met 0,1% tot $1,0816 ten opzichte van de Amerikaanse dollar, terwijl het pond met 0,12% daalde tot $1,26255. De Nieuw-Zeelandse dollar daalde naar het zwakste niveau in vier maanden, op $0,5981.</p>
<p>De Zweedse centrale bank verklaarde op woensdag dat als de inflatie blijft dalen naar haar doel van 2%, het zeer waarschijnlijk is dat er vanaf mei een reeks renteverlagingen zal beginnen.</p>
<p>“De Amerikaanse dollar wordt nog steeds beïnvloed door de relatieve havikachtigheid van de Federal Reserve, waarbij alle 19 besluitvormers en andere centrale banken die onlangs meer geneigd zijn geweest tot een duifachtige toon,” zei Thierry Wiezmann, een wereldwijde forex- en rentestrategist bij Macquarie.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen licht gestegen, waarbij de prijs van Brent ruwe olie met 36 cent is gestegen naar $86.45 per vat, terwijl Amerikaanse ruwe olie met 44 cent is gestegen naar $81.80 per vat.</p>
<p>Ten slotte voorkwam de versterking van de Amerikaanse dollar opnieuw een sterke opleving van goud, dat licht daalde tot $2.189,81 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 beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>