RGFnZWxpamtzIG5pZXV3cyB8IERyaWZ0IFByb2plY3QgR2VsYW5jZWVyZCAxMDBNIFRva2VuIEFpcmRyb3BzOyBBdmFsYW5jaGUgR2VsYW5jZWVyZCBIRUxPQyBUb2tlbmlzYXRpZSBvcCBkZSBDaGFpbjsgQUdJWCBIb3VkZXJzIEhlYmJlbiBHZXN0ZW1kIG92ZXIgaGV0IFZvb3JzdGVsIHZhbiBBU0k=

2024-04-17, 04:12

<p><img src="https://gimg2.gateimg.com/image/article/171332695417.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Solana20Project20Drift20lanceerde2010020miljoen20token20airdrops20Avalanche20lanceerde20HELOC20tokenisatie20op20de20blockchain20Super20Artificial20Intelligence20Alliance20ASI20voorstel20goedgekeurd20door20AGIX20houders340295"><a name="Crypto Dagelijkse Samenvatting: Solana Project Drift lanceerde 100 miljoen token airdrops; Avalanche lanceerde HELOC tokenisatie op de blockchain; Super Artificial Intelligence Alliance ASI voorstel goedgekeurd door AGIX houders" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Project Drift lanceerde 100 miljoen token airdrops; <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> lanceerde HELOC tokenisatie op de blockchain; Super Artificial Intelligence Alliance ASI voorstel goedgekeurd door AGIX houders</h2><p>Laten we eerst de handelsactiviteit van onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Spot-ETF’s. Volgens Farside Investor-data, op 16 april, stroomden de GBTC-fondsen van Grayscale uit $79,4 miljoen. Ondertussen was de instroom van de Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) $1,4 miljoen en de uitstroom van de ARK 21 Shares Bitcoin spot ETF (ARKB) $12,9 miljoen.</p>
<p>De recente gespannen economische en politieke situatie heeft investeerders doen neigen naar risico-aversie, wat heeft geleid tot een aanzienlijke daling van de cryptomarkt en een overeenkomstige nettostroom van geld uit ETF’s. Maar zelfs als Bitcoin wordt getroffen, blijft het de best presterende cryptocurrency, met de marktdominantie van Bitcoin die zijn hoogste niveau heeft bereikt sinds april 2021.</p>
<p>DEX Drift aan <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> staat op het punt om zijn governance-token DRIFT uit te geven. Drift heeft aangekondigd dat de totale voorraad DRIFT-tokens 1 miljard is, waarvan 10% (of 100 miljoen) zal worden verdeeld via luchtafzet. Deze 100 miljoen tokens zullen worden uitgedeeld op basis van gebruikersactiviteiten op het Drift-platform en naar verwachting 180.000 gebruikers bestrijken.</p>
<p>Drift werd gelanceerd op Solana in 2021 en is een van de vroegste DeFi-projecten op de blockchain. Sindsdien heeft het een cumulatieve transactievolume van meer dan $20 miljard gefaciliteerd. Momenteel is de TVL meer dan $250 miljoen.</p>
<p>Alle DRIFT-tokens worden binnen vijf jaar toegewezen, waarbij meer dan 50% wordt toegewezen aan de gemeenschap. Specifiek zullen gemeenschappen en ecoen 53% van de tokens ontvangen, 25% voor protocolontwikkeling en 22% voor strategische deelnemers.</p>
<p>Er wordt gemeld dat Drift de afgelopen drie jaar meerdere snapshots heeft genomen en uitgebreide activiteitenanalyse heeft uitgevoerd op token-luchtdrops.</p>
<p>Het gecentraliseerde AI-netwerk SingularityNET heeft op het X-platform aangekondigd dat de meeste AGIX-tokenhouders het voorstel van de Artificial Super Intelligence (ASI) Alliance hebben goedgekeurd.</p>
<p>Eerdere rapporten hebben aangetoond dat SingularityNET, <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a>, en Ocean Protocol hebben de oprichting aangekondigd van de Artificial Superintelligence Alliance. Creëer het grootste open-source, gedecentraliseerde netwerk door miljarden tokens samen te voegen.</p>
<p>In deze alliantie zullen de tokens $FET, $OCEAN en $AGIX die worden gebruikt door de drie alliantieledennetwerken worden samengevoegd tot één $ASI-token, dat zal worden gebruikt in het samengevoegde gedecentraliseerde kunstmatige intelligentienetwerk en ongekende schaal en mogelijkheden zal bieden. Volgens het fusieplan wordt verwacht dat de marktwaarde van ASI-tokens na volledige verwatering $7,5 miljard zal bereiken.</p>
<p>Het tokenisatieprotocol voor een Home Equity Line of Credit (HELOC), Homium, heeft aangekondigd dat het een financieringsronde van $10 miljoen heeft afgerond, geleid door Sorenson Impact Group en Blizzard.</p>
<p>Volgens de officiële verklaring is Homeum gebaseerd op de <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a> blockchain, waardoor huiseigenaren kunnen lenen tegen de nettowaarde van hun woning zonder hun maandelijkse schuldenlast te verhogen. Met Homeum kunnen huiseigenaren een deel van de toekomstige waarde van hun woning als onderpand gebruiken voor hun lening in eigen vermogen.</p>
<p>Ondertussen ontvangen investeerders een getokeniseerd bezit dat de prijsstijging van gedeelde huisvestingspools op het Homeum-platform kan bijhouden. De initiële getokeniseerde woningleningdienst zal worden geleverd in Colorado, VS.</p>
<p>Citibank beschrijft tokenisatie als de volgende ‘killer use case’ voor cryptocurrencies, en gelooft dat tegen 2030 de schaal van asset tokenisatie in de echte wereld $5 biljoen zou kunnen bereiken.</p>
<h2 id="h2-Markttrends845640"><a name="Markttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends</h2><p>De markt vertoont een zwakke en volatiele trend, met Bitcoin die gisteravond terugkaatst van $62.000 naar ongeveer $64.000. Minder dan drie dagen verwijderd van het Bitcoin-halveringsevenement, terwijl spot-ETF’s twee opeenvolgende dagen netto-uitstroom hebben gezien. Met betrekking tot de macro-economie heeft de Amerikaanse aandelenmarkt ook volatiliteit ervaren, waarbij de Amerikaanse dollarindex een nieuw hoogtepunt heeft bereikt in bijna een half jaar. Powell’s havikachtige toespraak heeft opnieuw verwachtingen van renteverlagingen aangewakkerd.</p>
<h3 id="h3-Markt20Hotspots496979"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Modulaire blockchain TIA stijgt tegen de trend in: de stakingsgraad van TIA heeft 67% bereikt en de volgende grootschalige ontgrendeling zal in oktober plaatsvinden, zes maanden later. Dit type sub-nieuwe valuta heeft een goede chipstructuur en is gemakkelijk onderhevig aan marktcontrole.</p>
<p>Tokens in the fan coin sector, such as SANTOS, PSG, and OG, are rising. The European Cup football match is about to start, and the market is hyping up related concept tokens.</p>
<p>Vroege sterke valuta compenseerden verliezen: ENA, PENDLE, CKB en andere compenseerden verliezen, met een intraday daling van meer dan 20%. Gisteren heeft het ENA-project meer dan 35 miljoen ENA’s overgedragen aan grote gecentraliseerde beurzen, met duidelijke tekenen van verzending. Het aanvullen van de daling van een sterke valuta kan erop wijzen dat de neerwaartse trend de tweede fase is ingegaan en een verdere daling misschien een meer geschikte tijd is om een bodem te bereiken. Investeerders moeten de markttrends nauwlettend volgen en voorzichtige beslissingen nemen.</p>
<p>Over het algemeen ervaart de markt zwakke schommelingen en moeten beleggers voorzichtig zijn bij het reageren en aanpassen van hun beleggingsstrategieën op basis van markttrends en ontwikkelingen.</p>
<h2 id="h2-Macro20Wall20Street20sloot20lager20Aziatische20markten20zagen20gemengde20ups20en20downs20en20de20wereldeconomie20kan20dit20jaar20een20langzame20en20stabiele20groei20doormaken230198"><a name="Macro: Wall Street sloot lager, Aziatische markten zagen gemengde ups en downs, en de wereldeconomie kan dit jaar een “langzame en stabiele groei” doormaken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wall Street sloot lager, Aziatische markten zagen gemengde ups en downs, en de wereldeconomie kan dit jaar een “langzame en stabiele groei” doormaken</h2><p>Het Internationaal Monetair Fonds kondigde dinsdag aan dat de wereldeconomie nog een jaar van “langzame maar stabiele groei” zal beleven, omdat de kracht van de Verenigde Staten de wereldwijde output zal stimuleren om ongunstige factoren zoals aanhoudende hoge inflatie, zwakke vraag uit China en Europa, en spillovereffecten van twee regionale oorlogen te overwinnen.</p>
<p>Op dinsdag sloten Wall Street-aandelen lager naarmate het rendement van Amerikaanse staatsobligaties steeg tijdens volatiele handel. Beleggers tonen een voorzichtige houding bij het afwegen van de veerkracht van de Amerikaanse economie en de mogelijke impact van aanhoudende inflatie op rentetrends.</p>
<p>Voorzitter van de Federal Reserve, Jerome Powell, verklaarde dat recente inflatiedata beleidsmakers niet genoeg vertrouwen hebben gegeven om snel krediet te verlichten. Hij wees erop dat de Federal Reserve mogelijk de rentetarieven langer op een hoger niveau moet handhaven dan verwacht.</p>
<p>De prestaties van de drie belangrijkste indexen, de Dow Jones-index steeg met 0,17%, de Standard&amp;Poor’s-index daalde met 0,21% en de Nasdaq-index daalde met 0,12%. De Dow werd gestimuleerd door beter dan verwachte prestaties van United Health Group. Vastgoed- en nutsaandelen trokken de S&amp;P 500-index naar beneden, terwijl technologieaandelen de grootste drijvende kracht waren voor de index.</p>
<p>De markt heeft de verwachte renteverlaging dit jaar aanzienlijk verminderd tot minder dan twee keer, een aanzienlijke verandering in vergelijking met de verwachting aan het begin van het jaar. Ondanks een afname van het marktvertrouwen wordt verwacht dat de eerste renteverlaging nog steeds in september zal plaatsvinden.</p>
<p>Op woensdag bereikten de rendementen op Amerikaanse staatsobligaties een hoogtepunt van vijf maanden, steeg de Amerikaanse dollar ten opzichte van andere valuta’s en waren de Aziatische aandelenmarkten gemengd. De MSCI Asia Pacific aandelenindex buiten Japan steeg met 0,2% na een daling van meer dan 4% in de afgelopen drie handelsdagen. De prestaties van Taiwanese aandelen waren beter dan de algehele markt, met een stijging van 1%, terwijl de prestaties van andere markten teleurstellend waren.</p>
<p>De Nikkei-index in Japan daalde met 0,7% naar het laagste niveau in twee maanden. Chinese blue-chip aandelen daalden met 0,1%, terwijl de Hang Seng-index van Hong Kong licht steeg met 0,1%.</p>
<p>Tot nu toe deze week zijn de geopolitieke kwesties gespannen gebleven, maar de olieprijzen zijn gedaald omdat de economische tegenwind de sentimenten van investeerders heeft onderdrukt en de voordelen van geopolitieke spanningen heeft verminderd. De markt maakt zich zorgen over hoe Israël zal reageren op de Iraanse aanval op Israëlisch grondgebied in het weekend.</p>
<p>Brent ruwe olie futures voor levering in juni daalden met 7 cent, of 0,1%, naar $89,16 per vat, terwijl Amerikaanse ruwe olie futures voor levering in mei met 10 cent, of 0,1%, daalden naar $85,26 per vat.</p>
<p>De olieprijzen daalden woensdagochtend als gevolg van het zwakke economische momentum in China en zorgen over de wereldwijde vraag die verzwakt werden door de recente renteverlagingen in de VS, waardoor de zorgen over het aanbod als gevolg van escalerende spanningen in het Midden-Oosten werden overtroffen.</p>
<p>De goudprijs blijft op $2.384,29 per ounce, niet ver van het historische hoogtepunt van $2.431,29.</p>
<div class="blog-details-info"><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 te herdrukken op voorwaarde dat Gate.io wordt genoemd. In alle glen zal er juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>