RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0b3MgZW4gd2VyZWxkd2lqZGUgbWFya3RlbiB2YWxsZW4gc2FtZW47IEZpbmFuY2llcmluZyB2YW4gSW9UZVggdmFuICQ1ME07ICQyNE0gdmFuIHN0U09MIGthbiBuaWV0IHdvcmRlbiBvcGdlbm9tZW4gdmFud2VnZSBkZSBzdGFraW5nc2J1ZyB2YW4gTGlkbzsgT3BlblNlYSBvbmRlcnN0ZXVudCB

2024-04-03, 03:57

<p><img src="https://gimg2.gateimg.com/image/article/17121166243.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20DePIN20blockchain20IoTeX20financiering20van205020miljoen202420miljoen20aan20stSOL20kan20niet20worden20opgenomen20vanwege20een20Lido20staking20bug20OpenSea20ondersteunt20de20ERC721C20standaard254122"><a name="Crypto Dagelijks Overzicht: DePIN blockchain IoTeX financiering van $50 miljoen; $24 miljoen aan stSOL kan niet worden opgenomen vanwege een Lido staking bug; OpenSea ondersteunt de ERC-721C standaard" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: DePIN blockchain <a href="/price/iotex-iotx" target="_blank" class="blog_inner_link">IoTeX</a> financiering van $50 miljoen; $24 miljoen aan stSOL kan niet worden opgenomen vanwege een Lido staking bug; OpenSea ondersteunt de ERC-721C standaard</h2><p>Laten we eerst de handelsactiviteit van onderzoeken. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor bleven op 2 april Grayscale spot ETF’s (GBTC) fondsen doorgaan <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> aanzienlijk terug, met een piek van $110,2 miljoen; Ondertussen bedroeg de instroom van Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) $44,8 miljoen, de instroom van Bitwise Bitcoin spot ETF (BITB) $4,3 miljoen en de uitstroom van ARK 21Shares Bitcoin spot ETF (ARKB) $87,5 miljoen.</p>
<p>Op 2 april, <a href="/price/iotex-iotx" rel="nofollow noopener noreferrer" target="_blank">IoTeX</a>, een <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>-compatibele blockchain geoptimaliseerd voor DePIN, maakte financieringsinformatie bekend. Het project ontving in totaal $50 miljoen aan investeringen van Borderless Capital, Amber Group, Foresight Ventures, FutureMoney Group, SNZ, Metrics Ventures, EV3 en Waterdrop Capital.</p>
<p>Het team verklaarde dat deze investering tot doel heeft te voldoen aan de groeiende vraag naar het verbinden van real-world data en IoT-apparaten met Web3. Ze merkten ook op dat deze investering de groei en adoptie van DePIN-ecoen zal stimuleren door te investeren in langlopende onderpanden $IOTX (DePIN-tokens die IoTeX DePIN beheren en stimuleren) en samen te werken met de IoTeX Foundation en DePINsurf Accelerator Fund om te investeren in op IoTeX gebaseerde DePIN-projecten.</p>
<p>Het SOL-stakingsprotocol van Lido, gewaardeerd op $24 miljoen, is ontoegankelijk voor gebruikers vanwege codekwetsbaarheden; Momenteel zitten meer dan 31.000 portefeuilles met stSOL in de problemen.</p>
<p>Lido kondigde in oktober 2023 aan dat het geleidelijk de ondersteuning zal stopzetten voor <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en verwijder de website waar stSOL-houders hun tokens kunnen inwisselen voor SOL. Toen Lido de webpagina in februari verwijderde, hadden gebruikers nog steeds meer dan 112.000 stSOL’s met een marktwaarde van meer dan $24 miljoen.</p>
<p>Daarnaast kondigde Lido volgens nieuws van oktober vorig jaar aan dat het geen ondersteuning meer zal bieden voor SOL-staking en vanaf 16 oktober geen nieuwe SOL-staking meer zal ondersteunen. Node-operators zullen op 17 november beginnen met terugtrekken. Vanaf 4 februari 2024 wordt Lido, ondersteund door de <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> front-end, beëindigd en kan het annuleren van de staking alleen nog maar via de command-line interface (CLI) worden gedaan. Lido verklaarde dat stSOL-houders nog steeds staking beloningen kunnen ontvangen tijdens deze periode.</p>
<p>Lido heeft hier nog niet op gereageerd.</p>
<p>Het NFT-handelsplatform OpenSea heeft ondersteuning toegevoegd voor de ERC-721C-standaard, waarmee makers programmeerbare en uitvoerbare maker-voordelen op de keten kunnen bereiken.</p>
<p>ERC-721C werd in mei vorig jaar uitgevonden door het blockchain game bedrijf Limit Break. Het lost het probleem van het schudden in NFT-transacties op door de tokenoverdrachtsvoorwaarden (zoals royalties) te standaardiseren via alle kanalen. Voor hun uitvinding konden gebruikers NFT’s overdragen via zelfbewaarde wallets of andere NFT-markten die niet voldeden aan de vereisten voor makersroyalty’s, waardoor ze efficiënt de royaltycommissies van de maker konden omzeilen in de secundaire markt.</p>
<p>Volgens OpenSea-ontwikkelaars werd de compatibiliteit met ERC-721C pas ingeschakeld in de Dencun-upgrade van het Ethereum-netwerk op 13 maart. Het platform verklaart: ‘Als je de bovenstaande stappen volgt om je makerinkomsten uit te voeren, worden verkopen alleen ondersteund in OpenSea en andere markten die worden aangedreven door de betaalprocessors van LimitBreak.’ Na implementatie van het ERC-721C-contract op OpenSea kunnen makers hun digitale kunstwerken handmatig vermelden in andere markten. OpenSea zal echter ook de minimale royalty’s die door de makers op verschillende platforms zijn ingesteld, evenaren.</p>
<p><a href="/how-to-buy/cusdt-cusdt" rel="nofollow noopener noreferrer" target="_blank">waar cusdt te kopen</a><br>Vanochtend daalde BTC kortstondig onder de $64.500 en momenteel is de prijs weer gestegen tot rond de $66.000. De dagelijkse gemiddelde prijs is echter doorbroken. Tegen de achtergrond van de daling van BTC heeft de hele markt over het algemeen een scherpe daling doorgemaakt. Bovendien vertonen BTC-spot-ETF’s opnieuw een staat van nettostromen. Er wordt vermoed dat de markt wordt beïnvloed door de verkoop van bijna $2 miljard aan eerder in beslag genomen Bitcoin door de Amerikaanse overheid.</p>
<p>Op macro-economisch vlak kende de Amerikaanse aandelenmarkt een aanzienlijke daling als gevolg van de verwachte afname van de renteverlagingen, terwijl de Amerikaanse dollarindex een nieuw hoogtepunt bereikte in vier maanden. Het rendement van de 10-jarige staatsobligatie bereikte 4,2%.</p>
<h3 id="h3-Markt20Hotspots586243"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>ENA is gestegen: Na de lancering op Gate.io gisteren is ENA met 80% gestegen en geprijsd op $0,83, met de waarde van de stad die $12 miljard bereikt heeft. USDe kan verbinding maken met Pendle Finance op de Mantle keten via de Stargate cross-chain brug voor mining, wat gas kosten bespaart in vergelijking met het opereren op de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> main chain.</p>
<p>RWA-sector: Ondanks de algemene marktdaling blijven de prijzen van tokens zoals POLYX en PENDLE sterk.</p>
<p>Gate.io zal vandaag om 12:00 uur (UTC) het Wormhole-token W lanceren, dat naar verwachting een belangrijke hotspot op de markt zal worden.</p>
<p>Over het algemeen is de marktsentiment vaak pessimistisch en moeten investeerders voorzichtig reageren. Houd de stijgende trend van ENA en RWA sector tokens en de aankomende lancering van Wormhole token W op Gate.io in de gaten. Ondertussen nauwlettend marktrisico’s in de gaten houden en voorzichtige beleggingsstrategieën hanteren.</p>
<h2 id="h2-Macro20Mondiale20daling20van20de20aandelenmarkt20een20storm20kan20toeslaan20Stijgende20prijzen20van20ruwe20olie20en20goud603111"><a name="Macro: Mondiale daling van de aandelenmarkt, een storm kan toeslaan; Stijgende prijzen van ruwe olie en goud" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Mondiale daling van de aandelenmarkt, een storm kan toeslaan; Stijgende prijzen van ruwe olie en goud</h2><p>Op dinsdag daalde de Amerikaanse aandelenmarkt toen beleggers de mogelijkheid van de Federal Reserve om renteverlagingen uit te stellen afwogen. Tegelijkertijd kondigde de fabrikant van elektrische voertuigen Tesla zijn eerste kwartaalafleveringsdaling in bijna vier jaar aan, wat leidde tot een daling van de aandelenkoersen. De belangrijkste indicatoren zijn als volgt: de Dow Jones-index daalde met 1,00%, de S&amp;P 500-index daalde met 0,72% en de Nasdaq-index daalde met 0,95%.</p>
<p>De rendementen op Amerikaanse 10-jarige staatsobligaties zijn gestegen tot 4,40%, het hoogste niveau van dit jaar. Tesla heeft aangekondigd dat de kwartaalafleveringen voor het eerst in bijna vier jaar zijn gedaald, waarbij de aandelenkoers met 5% is gedaald. De markt overweegt nog steeds het risico van vertraging in renteverlagingen vóór de publicatie van Amerikaanse gegevens en vóór het optreden van de centrale bankpresident later op die dag. De olieprijzen blijven stijgen en de goudprijzen hebben opnieuw een historisch hoogtepunt bereikt.</p>
<p>De Aziatische aandelenmarkten daalden woensdag, samen met Wall Street, voornamelijk omdat het rendement van de Amerikaanse staatsobligaties in de buurt van een hoogtepunt van vier maanden bleef en de krachtige aardbeving in de regio zorgen baarde over mogelijke verstoringen in belangrijke chipfabricage-industrieën. De MSCI Asia Pacific aandelenindex, de meest gebruikte buiten Japan, daalde met 0,7%. Na een aanzienlijke stijging van 20% in het eerste kwartaal daalde de Nikkei-index in Japan woensdag met 1%.</p>
<p>De stijging van obligatierendementen, paniek onder Wall Street-bedrijven en aanhoudende prijsdruk lijken het vooruitzicht voor de Aziatische markt op woensdag nog somberder te maken. Beleggers vragen zich af of dit het begin van een diepere correctie markeert.</p>
<p>Enkele belangrijke publicaties op de Aziatische economische kalender zullen voornamelijk gebaseerd zijn op de gegevens van de inkoopmanagersindex van de dienstensector van China en Japan, maar de stemming van de markt op woensdag kan worden beïnvloed door de recente aanscherping van de mondiale financiële omstandigheden.</p>
<p>Ondertussen toonde een bedrijfsonderzoek aan dat de activiteit in de dienstensector van Japan in maart op zijn snelste tempo in zeven maanden uitbreidde, gesteund door sterke vraag, vooral voor inkomend toerisme. De dienstensector is altijd een drijvende kracht geweest voor de recente economische groei van Japan, en heeft geholpen om de druk van zwakke mondiale vraag op de productiesector te compenseren.</p>
<p>Volgens gegevens die zijn vrijgegeven door de index, steeg de AU Jibun Bank Services Purchasing Managers Index (PMI) van 52,9 in februari naar 54,1 in maart, wat de 19e opeenvolgende maand van stijging markeert.</p>
<p>Wat betreft bulkgoederen, stegen de olieprijzen voor de vierde dag op rij. De escalatie van geopolitieke spanningen zorgde voor zorgen over een krap aanbod voorafgaand aan de OPEC+ vergadering. De organisatie zal naar verwachting haar productiebeleid niet wijzigen. Brent ruwe olie daalde met 0,2% tot $87,18 per vat, terwijl Amerikaanse ruwe olie met 0,3% daalde tot $83,21 per vat.</p>
<p>Op woensdag bleven de goudprijzen hun recordbrekende stijging voortzetten. Spot goud bereikte een historisch hoogtepunt van $2.288,09 per ounce eerder in de handelssessie, gevolgd door enige winstneming, en bleef uiteindelijk onveranderd op $2.277,99.</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 zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>