RGFnZWxpamtzIE5pZXV3cyB8IFRlbnNvciBGb3VuZGF0aW9uIEdlbGFuY2VlcmQgR292ZXJuYW5jZSBUb2tlbiBUTlNSOyBTb2xhbmEgTmV0d2Vya2Nvbmdlc3RpZSBUcmlnZ2VycyBEZXZlbG9wZXIgUmVhY3RpZTsgQVJDMjAgdGVzdCBtb21lbnRlZWwgZWVuIFRva2VuIFNwbGl0dGluZy1vcGxvc3Npbmc=

2024-04-09, 03:22

<p><img src="https://gimg2.gateimg.com/image/article/17126332619.jpeg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Tensor20Foundation20heeft20het20governancetoken20TNSR20gelanceerd20congestie20in20het20Solananetwerk20zet20ontwikkelaars20aan20tot20actie20ARC2020test20momenteel20een20oplossing20voor20het20splitsen20van20tokens448155"><a name="Crypto Daily Digest: Tensor Foundation heeft het governance-token TNSR gelanceerd; congestie in het Solana-netwerk zet ontwikkelaars aan tot actie; ARC20 test momenteel een oplossing voor het splitsen van tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Tensor Foundation heeft het governance-token TNSR gelanceerd; congestie in het Solana-netwerk zet ontwikkelaars aan tot actie; ARC20 test momenteel een oplossing voor het splitsen van tokens</h2><p>Laten we eerst kijken naar <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Handelsactiviteit van ETF’s. Volgens gegevens van Farside Investor bleven de fondsen van Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (GBTC) op 8 april doorgaan met <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> blijft aanzienlijk groeien en bereikte $303,3 miljoen. Ondertussen bedroeg de instroom van Fidelity Bitcoin spot ETF (FBTC) $6,3 miljoen, de instroom van Bitwise Bitcoin spot ETF (BITB) $40,3 miljoen, de instroom van ARK 21Shares Bitcoin spot ETF (ARKB) $9,3 miljoen en de nettostroom van WisdomTree Bitcoin spot ETF (BTCW) $2,3 miljoen.</p>
<p>De Tensor Foundation heeft de governance-token TNSR gelanceerd. In een bericht dat is geplaatst op het sociale mediaplatform X, verklaarde de Tensor Foundation dat de lancering van TNSR helpt bij de uitvoering van gemeenschapsgovernance, waardoor TNSR-houders Tensor-parameters kunnen beheren en korting op transacties op Tensor kunnen krijgen. Gebruikers moeten hun tokens verzamelen vóór 5 oktober 2024.</p>
<p>De voorraad TNSR-tokens bedraagt 1 miljard. De initiële airdrop is goed voor 12,5% van de tokenvoorraad, waarvan 55% of 550.000.000 TNSR wordt toegewezen aan de gemeenschap. Kernbijdragers zullen 27% van de totale voorraad ontvangen. De overige 18% zal worden toegewezen aan toekomstige fondsenwervingsactiviteiten, investeerders en adviseurs.</p>
<p>Tensor is een NFT-handelsmarkt die bekend staat als ‘Solona’s Blur’. Tensor had eerder aangegeven dat het zijn token een maand geleden zou lanceren, maar de details die destijds werden verstrekt waren beperkt. Dit token kan worden gebruikt in het hele Tensor-protocol, inclusief de Tensor NFT-marktplaats, Tensor automatische marktmaker, Tensor bewaring, enzovoort.</p>
<p>In de afgelopen dagen, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Het netwerk heeft te kampen gehad met congestieproblemen, wat heeft geleid tot aanzienlijke vertragingen bij de verwerking van transacties en een groot aantal transacties die worden verworpen. Gebruikers van Solana’s populaire Phantom wallet en andere toepassingen zijn op de hoogte gebracht van de congestie en geadviseerd om langer te wachten om transacties te voltooien.</p>
<p>Deze congestie is grotendeels te wijten aan de toestroom van spamtransacties, waarbij robots proberen hun activiteiten voorrang te geven boven die van gewone gebruikers. Als gevolg van de scherpe toename van transacties gerelateerd aan de onlangs uitgebrachte memecoin, is er een enorme vraag naar netwerk blokruimte, wat heeft geleid tot veel belemmering van gebruikers toegang en verergering van dit probleem.</p>
<p>Medeoprichter Anatoly Yakovenko verklaarde dat om deze uitdagingen aan te pakken, het ontwikkelingsteam van <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> effectieve oplossingen ontwerpt en softwarepatches al in ontwikkeling zijn, maar het zal enige tijd duren.</p>
<p>“Het Solana-netwerk staat opnieuw voor de test van een grote toestroom van verkeer. Volgende week zal er een foutoplossing worden gelanceerd en de situatie zal beginnen te verbeteren,” benadrukte Austin Federa, strategisch directeur van de Solana Foundation. De congestie kan zich uitbreiden naar de netwerkinfrastructuur, waardoor de mogelijkheid van gebruikers om met blockchain te interacteren wordt beïnvloed.</p>
<p>In dit verband zal Anza, de ontwikkelaar van een van de Solana Agave validator clients, een fix lanceren om specifieke problemen met betrekking tot de QUIC-implementatie aan te pakken. Deze updates zullen de prestaties van de client verbeteren, vooral bij hoge verzoekvolumes. Een andere belangrijke vooruitgang is de geplande 1.18-update die in april zal worden uitgebracht. Deze update zal verbeterde functies introduceren om transactieplanning meer deterministisch te maken, verwerking te vereenvoudigen en knelpunten te verminderen.</p>
<p>Het Atomicals-protocol heeft aangekondigd op het X-platform dat de ARC-20-token-splitsingsoplossing op het punt staat te worden gelanceerd. Via dit plan zal Atomicals het potentieel hebben om tokens te versturen vanaf slechts 1 eenheid en de Bitcoin-stofbeperkingen te overwinnen, terwijl ze nog steeds de belangrijkste kenmerken ondersteunen die door Satoshis worden ondersteund voor alle tokens.</p>
<p>Atomicals is een flexibel protocol dat wordt gebruikt om digitale objecten te creëren, overdragen en bijwerken op blockchains gebaseerd op UTxO-modellen vergelijkbaar met Bitcoin. Haar vlaggenschip token is $Atom.</p>
<p>We kunnen zeggen dat de split van $ATOM is aangekomen, wat een belangrijke mijlpaal vertegenwoordigt in de intrede van Bitcoin in het Atomicals-protocoltijdperk.</p>
<h2 id="h2-Markttrends20De20ETHBTCwisselkoers20versterkt20nadert20het20Altcoinseizoen10423"><a name="Markttrends: De ETH/BTC-wisselkoers versterkt, nadert het Altcoin-seizoen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De ETH/BTC-wisselkoers versterkt, nadert het Altcoin-seizoen?</h2><p>De cryptomarkt vertoont een volatiele opwaartse trend, waarbij de BTC-prijzen boven de $71.000 blijven, wat duidt op marktherkenning van zijn kracht. Tegelijkertijd kan de omkering van de wisselkoers van ETH tegen BTC en de versterking van ETH-prijzen duiden op het begin van het Altcoin-seizoen. ETH, als een van de belangrijke indicatoren van de cryptomarkt, drijft vaak de stijging van andere valse valuta’s aan, wat in het verleden herhaaldelijk is bevestigd in de markt.</p>
<p>Met betrekking tot de macro-economie heeft de Amerikaanse aandelenmarkt ook een volatiele trend laten zien. De markt verwacht dat de waarschijnlijkheid van renteverlagingen in mei zal afnemen tot 0, en het aantal renteverlagingen voor het hele jaar zal ook afnemen tot 2. De eerste renteverlaging kan plaatsvinden in september. Deze factoren zullen ook een zekere invloed hebben op de trend van de cryptomarkt, en het is noodzakelijk om de latere prestaties van de markt nauwlettend in de gaten te houden.</p>
<h3 id="h3-Markt20Hotspots974836"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>BTC-ecosysteemtokens stijgen snel: BTC-ecosysteemtokens zoals CKB en MUBI zijn aanzienlijk gestegen. Met de aanstaande halvering van BTC trekken miners steun aan voor BTC-ecosysteemprojecten om een aanzienlijke daling van het inkomen te voorkomen, wat de stijging van BTC-ecosysteemtokens ondersteunt.</p>
<p>Stablecoin-project Ethena is gestegen: Ethena kondigde aan dat het de mijning APY zou verhogen door ENA te staken, waardoor de stijging van ENA wordt gestimuleerd. Deze duidelijke empowerment-actie injecteert nieuwe vitaliteit in de toekomstige ontwikkeling van het project.</p>
<p>De opkomst van de openbare ketting TON: TON-projecten zijn gestegen en on-chain projecten zoals FISH en STON zijn gevolgd. De markt hypet het nieuws op dat Telegram openbaar gaat, en FISH is het beste Meme-project op de TON-keten, terwijl STON de beste DEX op de TON-keten is. De DEX-platform en Meme-projecten zijn de eersten die profiteren van de stijging in openbare kettingprojecten.</p>
<p>De lancering van Tensor (TNSR): Als een NFT-handelsplatform op de Solana-keten heeft de token TNSR van Tensor sinds de lancering gisteren een trend van hoge opening en lage sluiting laten zien. Het verhandelen van NFT’s op Tensor voor meer dan 5 SOL of meer dan vijf keer handelen kan TNSR-token airdrops opleveren. Deze airdrop-regel heeft ook enige marktaandacht getrokken, maar de prijstrend moet nog worden waargenomen.</p>
<p>Over het algemeen bevindt de cryptomarkt zich momenteel in een volatiele opwaartse trend en hebben de trends van BTC en ETH een significante impact op de gehele markt. Wat betreft de hete plekken op de markt hebben BTC-ecosysteemtokens, ENA, TON en TNSR allemaal veel aandacht gekregen. Investeerders moeten de markttrends nauwlettend volgen, hun investeringsstrategieën redelijk aanpassen en zich wapenen tegen risico’s van marktvolatiliteit.</p>
<h2 id="h2-Macro20Wall20Street20sloot20vlak20Aziatische20markten20stegen20voorzichtig20en20de20aantrekkelijkheid20van20goud20blijft20onveranderd375881"><a name="Macro: Wall Street sloot vlak, Aziatische markten stegen voorzichtig en de aantrekkelijkheid van goud blijft onveranderd." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wall Street sloot vlak, Aziatische markten stegen voorzichtig en de aantrekkelijkheid van goud blijft onveranderd.</h2><p>Op 8 april sloot de Amerikaanse aandelenmarkt maandag relatief vlak, waarbij beleggers wachtten op kritieke inflatiedata en het begin van het kwartaalverslagseizoen. Het rendement van Amerikaanse staatsobligaties bereikte een viermaandelijkse hoogtepunt en de aandelenmarkt werd enigszins ingetoomd. De S&amp;P 500 en Nasdaq-indexen leden de geringste verliezen, met nominale winsten, terwijl de Dow Jones Industrial Average licht daalde.</p>
<p>De Dow Jones Industrial Average (.DJI) daalde met 11,24 punten, of 0,03%, tot 38.892,80 punten. De Standard &amp; Poor’s 500 Index (.SPX) daalde met 1,95 punten, of 0,04%, tot 5.202,39 punten, terwijl de Nasdaq Composite Index (.IXIC) steeg met 5,44 punten, of 0,03%, tot 16.253,96 punten.</p>
<p>Op woensdag zal het Ministerie van Arbeid het CPI-rapport van maart publiceren, met een lichte vertraging in de maandelijkse prijsgroei en een daling in de jaarlijkse kerngegevens.</p>
<p>Wat betreft Aziatische aandelenmarkten blijven de prijzen van industriële metalen stijgen als gevolg van verwachtingen van een wereldwijd herstel van de productiesector. Toch presteerden Aziatische aandelenmarkten relatief voorzichtig voor de publicatie van de Amerikaanse inflatiegegevens en de bijeenkomst van de Europese Centrale Bank deze week. Op 9 april steeg de MSCI, de meest gebruikte Asia Pacific aandelenindex buiten Japan, met 0,2%, terwijl de Nikkei-index in Japan met 0,6% steeg. De Chinese productieactiviteit in maart liet de eerste groei zien in zes maanden.</p>
<p>Wat betreft grondstoffen, liggen de prijzen van Brent ruwe olie onder recente hoogtepunten maar blijven ze boven de $90 per vat, met een afsluiting van $90.62.</p>
<p>Aangestuurd door aankopen van centrale banken en geopolitieke spanningen, bereikten de goudprijzen op maandag een historisch hoogtepunt voor de zevende opeenvolgende handelsdag, ondanks relatief sterke economische gegevens. De aantrekkelijkheid van goud blijft echter sterk.</p>
<p>Spot goud steeg met 0,3% naar $2.336,39 per ounce nadat het een historisch hoogtepunt van $2.353,79 had bereikt. Amerikaanse goud futures sloten 0,2% hoger op $2.351.</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 opvattingen 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 zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>