RGFnZWxpamtzIG5pZXV3cyB8IFNPTC1wcmlqcyBicmVla3QgJCAyMDAsIG1hcmt0a2FwaXRhbGlzYXRpZSBzdGlqZ3QgbmFhciBUT1A0OyBFdGhlci5maSBrb25kaWd0IGFpcmRyb3AgYWFuOyBNaW5kZXIgZGFuIDUuMDAwIGJsb2trZW4gb3ZlciB2YW4gQml0Y29pbiBIYWx2aW5n

2024-03-18, 04:12

<p><img src="https://gimg2.gateimg.com/image/article/17107351131_12.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20SOL20brak20door20200U20en20de20marktwaarde20steeg20naar20TOP420Etherfi20kondigde20een20airdrop20aan20van20het20opnieuw20staken20protocol20Minder20dan20500020blokken20over20tot20de20halvering20van20Bitcoin38001"><a name="Crypto Dagelijks Overzicht: $SOL brak door 200U en de marktwaarde steeg naar TOP4; Ether.fi kondigde een airdrop aan van het opnieuw staken protocol; Minder dan 5000 blokken over tot de halvering van Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: $SOL brak door 200U en de marktwaarde steeg naar TOP4; Ether.fi kondigde een airdrop aan van het opnieuw staken protocol; Minder dan 5000 blokken over tot de halvering van Bitcoin</h2><p>Laten we eerst eens kijken naar de handelsactiviteit van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor had Grayscale’s <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF op 15 maart (afgelopen vrijdag) een GBTC-uitstroom van $139,4 miljoen; Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een instroom van $155,6 miljoen, Bitwise Bitcoin spot ETF (BITB) een instroom van $20,5 miljoen, en WisdomTree Bitcoin spot ETF (BTCW) een nettostroom van $3,3 miljoen.</p>
<p>De actieve en sterke aanwezigheid op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De keten heeft de prijzen opgedreven. Volgens DeFiLama-gegevens overtrof het transactievolume van DEX op de Solana-keten op 16 maart $3,8 miljard, en de meme-munt BOME kreeg veel aandacht omdat PEPE-kunstenaars het hebben gemaakt. Op 14 maart, de dag dat BOME werd gelanceerd, piekte het aantal actieve adressen op het Solana-netwerk bijna een maand lang, ongeveer 1,2 miljoen, met de hoogste stijging van meer dan 100% in actieve adressen binnen een maand.</p>
<p>Daarom is het aantal nieuwe memes dat door <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Network is uitgegeven, de afgelopen twee dagen enorm gestegen. De prijs van het native token SOL is ook dienovereenkomstig gestegen, waarbij Solana (SOL) door de $ 200 breekt en de marktwaarde meer dan $ 88 miljard bedraagt. Volgens gegevens van Coingecko bereikte de marktwaarde van Solana een historisch hoogtepunt van $ 90.355 miljard. Momenteel heeft de marktwaarde van Solana de overtroffen <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> is gestegen in de ranglijst en staat nu op de vierde plaats.</p>
<p>Ether.fi, het grootste liquiditeits-herstakingsprotocol op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, kondigde zijn bestuurlijke token ETHFI aan en details van airdrops die beginnen op 18 maart.</p>
<p>De token heet ETHFI, met een totale voorraad van 1 miljard munten en een initiële circulatie van 115,2 miljoen munten. De eerste fase van de airdrop zal 6% van de totale tokenvoorraad vrijgeven, die activiteiten voor 15 maart zal dekken. Het tweede seizoen zal 5% van de resterende tokens vrijgeven, die activiteiten van 15 maart tot ongespecificeerde toekomstige data zal dekken. Volgens de token-economieverdeling van het protocol zullen de overgebleven tokens worden verdeeld onder investeerders, partners, kernbijdragers en de afdeling protocolfinanciën.</p>
<p>Ether.fi biedt verschillende criteria voor deelname aan airdrops, waaronder het bezitten van eETH, het aanbevelen van vrienden om het protocol te gebruiken, of deelnemen aan het vroege adoptieprogramma van het protocol. Volgens de aankondiging van Ether.fi moet de Whale Wallet drie maanden wachten om tokens te verzamelen, terwijl kleinere wallets deze direct kunnen verzamelen.</p>
<p>Bovendien ontdekten gemeenschapsleden na de bekendmaking dat het omstreden was. <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> oprichter Justin Sun ontving bijna 3,5 miljoen tokens uit de oorspronkelijke 60 miljoen tokenverdeling nadat hij twee dagen geleden 20.000 ETH had gestort. Het projectteam is van mening dat dit de vastgestelde regels niet zal veranderen.</p>
<p>Volgens de gegevens van DeFi Llama heeft Ether.fi met de steun van het herfinancieringsprotocol EigenLayer een totale waarde van meer dan $3 miljard vastgezet, wat meer is dan twee keer zoveel als de dichtstbijzijnde concurrent.</p>
<p>De gegevens tonen aan dat de hoogte van Bitcoin blokken naar verwachting minder dan 33 dagen verwijderd is van de tijd van ‘halvering van blokbeloningen’. Elke 210.000 blokken zal een halvering ervaren, dus de volgende halvering van de Bitcoin blokbeloning wordt verwacht in april 2024. Wanneer de blokhoogte 840.000 bereikt, zal de blokbeloning afnemen van 6,25 BTC naar 3,125 BTC.</p>
<h2 id="h2-Markttrends20BTC20herstelt20zich20na20een20scherpe20daling20en20de20markt20staat20op20het20punt20om20een20frenzy20van20Altcoinseizoen20in20te20luiden857682"><a name="Markttrends: BTC herstelt zich na een scherpe daling, en de markt staat op het punt om een ​​frenzy van Altcoin-seizoen in te luiden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC herstelt zich na een scherpe daling, en de markt staat op het punt om een ​​frenzy van Altcoin-seizoen in te luiden</h2><p>Vorige week maakte de markt een scherpe daling mee en herstelde zich vervolgens. BTC is voor het eerst sterk gedaald na het doorbreken van een historisch hoogtepunt, wat vaak wordt gezien als een signaal voor het begin van het Altcoin-seizoen, terwijl de markt blijft hypen rond het Solana-ecosysteem, AI-concepten en Meme-concepten.</p>
<p>Op macro-economisch vlak kende de Amerikaanse aandelenmarkt deze week een aanzienlijke daling, wat leidde tot een terugval in de verwachtingen voor renteverlagingen. Over het algemeen verwacht de markt dat de Federal Reserve de kwantitatieve verkrapping zal vertragen vanaf mei en eindigt in februari volgend jaar. Deze periode komt overeen met de optimale dividendperiode voor de investeringsmarkt, en beleggers moeten de impact van macro-economische factoren op de markt nauwlettend volgen.</p>
<h3 id="h3-Markthoogtepunten959571"><a name="Markthoogtepunten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markthoogtepunten</h3><p>Solana Ecosysteem blijft de markt leiden: SOL-prijzen zijn ooit boven de $ 200 uitgestegen en hebben een nieuw hoogtepunt bereikt sinds december 2021. Tegelijkertijd hebben tokens zoals WIF, MYRO, JUP, RAY, enz. in het Solana-ecosysteem ook een aanzienlijke stijging laten zien. Het Solana-ecosysteem heeft BTC’s uitstroom van Altcoin-fondsen aangetrokken en de marktverwachtingen zijn dienovereenkomstig toegenomen. Musk’s release van Green Hat Dog Twitter kan nieuwe aandacht brengen voor WIF en WIF zal terugkeren naar een prijs van $ 3.<br>De AI-sector heeft duidelijke hype: AI-concepttokens zoals RNDR, NEAR, FET, AGIX, AR, enz. zijn gestegen. De NVIDIA AI-conferentie nadert en de belangrijkste teamleden van RNDR en NEAR zullen op de conferentie presenteren, waarbij de steeds duidelijker wordende markthype wordt benadrukt.</p>
<p>De prestaties van Solana op chain Meme-projecten zijn gedifferentieerd: de Solana op chain Meme-projecten, geleid door BOME en SNAP, kenden een terugval na een aanzienlijke stijging. Er is een marktvisie dat BOME slechts een voorproefje is van het Solana-me-seizoen in deze bullmarkt.</p>
<p>De MASK- en CYBER-projecten hebben uitstekend gepresteerd. Beide projecten hebben hun plannen voor tokenstaking aangekondigd, en het staken van MASK en CYBER kan tokenairdrops opleveren van hun respectievelijke ecosysteempartners, wat de marktenthousiasme voor deze twee projecten stimuleert.</p>
<p>Tijdens het algemeen verwachte Altcoin-seizoen moeten investeerders voorzichtig blijven en veranderingen in markt hotspots en macro-economische factoren nauwlettend volgen. Tegelijkertijd is het noodzakelijk om aandacht te besteden aan marktrisico’s, activa op een redelijke manier te diversifiëren en op zoek te gaan naar langetermijnwaarde. Voor de komende NVIDIA AI-conferentie en andere belangrijke gebeurtenissen moeten beleggers hun beleggingsstrategieën snel aanpassen, investeringskansen grijpen en goed risicobeheer doen.</p>
<h2 id="h2-Macro20Wereldwijde20aandelenindex20daalt20inflatiedata20benvloedt20verwachte20renteverlagingen251482"><a name="Macro: Wereldwijde aandelenindex daalt, inflatiedata beïnvloedt verwachte renteverlagingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wereldwijde aandelenindex daalt, inflatiedata beïnvloedt verwachte renteverlagingen</h2><p>Reuters meldde dat op 16 maart wereldwijde aandelenindices daalden, waarbij de S&amp;P 500-index met 0,13% daalde, de Dow Jones-index met 0,02% daalde en de Nasdaq-index met 0,73% daalde. De MSCI Global Stock Index (.MIWD00000PUS) daalde met 5,07 punten, of 0,66%, naar 767,58.</p>
<p>Dit zal zeven opeenvolgende weken van winstbreuk betekenen, terwijl verwacht wordt dat de Amerikaanse dollar zijn sterkste week sinds medio januari zal beleven. De Amerikaanse inflatiedata blijft van invloed op de richting van verwachte renteverlagingen.</p>
<p>In februari stegen de invoerprijzen in de Verenigde Staten licht als gevolg van de stijgende kosten van aardolieproducten, gedeeltelijk gecompenseerd door lichte stijgingen in andere regio’s, wat wijst op een verbetering van de inflatiesituatie.</p>
<p>Hoewel verwacht wordt dat de Federal Reserve geen rentemaatregelen zal nemen, waren de producenten- en consumentenprijsgegevens van de VS van vorige week warmer dan verwacht, waardoor handelaren hun weddenschappen op toekomstige renteverlagingen verminderden. Volgens de CME FedWatch-tool verwachten handelaren momenteel dat de rente dit jaar met 72 basispunten wordt verlaagd, met een kans van 56% op een eerste renteverlaging.</p>
<p>De focus is verschoven naar de vraag of beleidsmakers de voorspelling voor de renteverlaging van dit jaar zullen wijzigen of bijstellen.</p>
<p>De Federal Reserve verwacht 75 basispunten, of drie renteverlagingen, in december 2024 door te voeren. Strategen bij NatWest suggereren dat het inflatierapport van vorige week de Federal Reserve in een “afwachtende” modus kan zetten.</p>
<p>De Amerikaanse dollar bleef stabiel op maandag, waarbij handelaren uitkeken naar een week gedomineerd door vergaderingen van centrale banken wereldwijd. De Bank of Japan lijkt een einde te maken aan negatieve rentetarieven en de marktaandacht is gericht op het aantal toekomstige renteverlagingen.</p>
<p>Ondanks de daling op vrijdag stegen beide benchmarkoliecontracten vorige week bijna 4%. Gedurende het grootste deel van de vorige maand schommelden de olieprijzen binnen een bereik, maar het optimistische vraagrapport van donderdag van het Internationaal Energieagentschap duwde de olieprijzen naar het hoogste niveau sinds november.</p>
<p>Wat grondstoffen betreft, stegen de futures op ruwe Brent-olie voor levering in mei met 3 cent tot $ 85,37 per vat. Het aprilcontract voor West Texas Intermediate (WTI) ruwe olie in de Verenigde Staten steeg met 10 cent tot $ 81,14.<br>De goudprijs zweeft momenteel op $ 2.153 per ounce, een daling van 1% vorige week, ver van historische hoogtepunten.</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 opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>