RGFnZWxpamtzIG5pZXV3cyB8IEdlc2NoYXR0ZSBCVEMtcHJpanNjeWNsdXMgVG9wICQxODBLOyBHb29nbGUgb25kZXJzdGV1bnQgaGV0IHpvZWtlbiBuYWFyIG1lZXJkZXJlIG5ldHdlcmtwb3J0ZWZldWlsbGVhZHJlc3NlbjsgRmlsZWNvaW4gTGlxdWlkaXR5IFN0YWtpbmcgUHJvdG9jb2wgR2xpZiBzdGFydCBwdW50ZW5zeXN0ZWVt

2024-03-29, 03:39

<p><img src="https://gimg2.gateimg.com/image/article/17116834461_21.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Nieuwe20BTCprijsvoorspelling20cyclus20top2018000020Google20ondersteunt20het20zoeken20naar20meerdere20netwerkportefeuilleadressen20zoals20BTC20Filecoin20Liquidity20Staking20Protocol20Glif20start20puntenprogramma256752"><a name="Crypto Daily Digest: Nieuwe BTC-prijsvoorspelling cyclus top $180.000; Google ondersteunt het zoeken naar meerdere netwerkportefeuilleadressen zoals BTC; Filecoin Liquidity Staking Protocol Glif start puntenprogramma." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Nieuwe BTC-prijsvoorspelling cyclus top $180.000; Google ondersteunt het zoeken naar meerdere netwerkportefeuilleadressen zoals BTC; <a href="/price/filecoin-fil" target="_blank" class="blog_inner_link">Filecoin</a> Liquidity Staking Protocol Glif start puntenprogramma.</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 Farside Investor-gegevens bedroeg de uitstroom van Grayscale’s <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF GBTC op 28 maart $104,9 miljoen; Ondertussen bedroeg de instroom van Fidelity Bitcoin spot ETF (FBTC) $68,1 miljoen, instroom van Bitwise Bitcoin spot ETF (BITB) bedroeg $67 miljoen, en instroom van ARK 21Shares Bitcoin spot ETF (ARKB) bedroeg $27,6 miljoen.</p>
<p>De BTC-prijs is opnieuw doorgebroken naar $71.000, maar is licht terugglen naar $70.382,9, wat wijst op een algemene zijwaartse aanpassing. Laurent Benayoun, CEO en expert in kwantitatieve handelsstrategieën bij Acheron Trading, zei dat de prijzen van Bitcoin in de huidige bullmarkt cyclus nog eens met 150% kunnen stijgen. Hij gelooft dat op basis van verschillende factoren, waaronder spot Bitcoin Exchange Traded Funds (ETF’s) en de aanstaande halvering van Bitcoin, die het aanbod zal verminderen. BTC-prijzen kunnen een cyclisch hoogtepunt van $180.000 bereiken.</p>
<p>Als we naar de historische prestaties kijken, zullen we merken dat de historische multiplicatoren van elke cyclus afnemen. Daarom, als we deze redenering toepassen, kan het 2 tot 3 keer zijn wat we in eerdere cycli hebben gezien, dus kunnen we zeggen dat elke eenheid ongeveer $120.000 tot $180.000 is.</p>
<p>Benayoun is ook van mening dat het verbeteren van het financieel beleid in de Verenigde Staten zal helpen bij het waarderen van de Bitcoin-prijzen: “De markt heeft de impact van dalende rentetarieven verwerkt, aangezien de rentetarieven stabiel zijn gebleven, dus het is redelijk om te verwachten dat de rentetarieven in de nabije toekomst zullen dalen.”</p>
<p>Google heeft onlangs een nieuwe functie gelanceerd om te zoeken naar blockchain-gegevens over Bitcoin, Arbitrum, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a>, Optimisme, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, en <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> netwerken. De zoekresultaten, bij het invoeren van het portefeuilleadres, zullen het resterende token saldo in elke netwerkportefeuille en de laatste update tijd van het saldo weergeven.</p>
<p>Google wees erop in de zoekresultaten: “Het saldo toont alleen de lokale tokens van elk netwerk. De tijdstempel van de laatste update toont het saldo tot aan de laatste externe transactie. De update is niet onmiddellijk.”</p>
<p>Deze maand begon Google zoekresultaten weer te geven voor portefeuillebalansen voor gebruikers die op zoek zijn naar de <a href="/price/ethereum-name-service-ens" rel="nofollow noopener noreferrer" target="_blank">Ethereum Naam Service</a> (ENS) domein. ENS biedt een leesbare domeinnaam voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Walletadressen, zoals die van Ethereum-ontwikkelaar Vitalik Buterin, vitalik.eth.</p>
<p><a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a> Het liquiditeitsstakingprotocol van Glif heeft een puntensysteem gelanceerd dat 75 miljoen punten zal toewijzen. Glif is het grootste liquiditeitsstakingprotocol in het Filecoin-ecosysteem. Volgens de gegevens van Filfox heeft Glif een totale waarde van meer dan $372 miljoen vergrendeld en een puntensysteem geïnitieerd voordat de token werd uitgebracht.</p>
<p>GLIF verklaarde op donderdag dat punten de eerste stap zijn in gedecentraliseerde protocolbesluitvorming, en beide partijen in het systeem - Filecoin-opslagprovider (SP) en liquiditeitsprovider (LP) - komen in aanmerking om punten te ontvangen. Er wordt toegevoegd dat punten zullen worden toegekend aan historische en toekomstige SP’s en LP’s.</p>
<p>Als een liquiditeitsleaseprotocol maakt Glif het mogelijk voor Filecoin (FIL) tokenhouders om FIL te storten in een liquiditeitspool in ruil voor Glif’s eigen liquiditeitsleasetoken, iFIL. SP verhuurt de gestorte FIL en betaalt huur aan LP en het protocol.</p>
<h2 id="h2-Markttrends20BTC20handelt20horizontaal20op20een20hoog20niveau20nadert20het20Altcoinseizoen514219"><a name="Markttrends: BTC handelt horizontaal op een hoog niveau, nadert het Altcoin-seizoen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC handelt horizontaal op een hoog niveau, nadert het Altcoin-seizoen?</h2><p>Nu Bitcoin stabiel blijft boven de $70.000, vertoont de algehele cryptomarkt een opwaartse trend. Wat betreft macro-economie is de Amerikaanse aandelenmarkt volatiel en wachten investeerders op de publicatie van de PCE-inflatiegegevens.</p>
<h3 id="h3-Markt20Hotspots588136"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De cryptocurrencies van het Meme-concept, zoals DOGE, FLOKI, WIF, BOME, enz., hebben aanzienlijke stijgingen gezien. Vooral met WIF dat op een gegeven moment $4 benaderde, heeft de huidige marktwaarde $3,8 miljard bereikt, wat equivalent is aan 4,5% van de marktwaarde van SOL. Het is vermeldenswaard dat, over het algemeen, de totale marktkapitalisatie van een enkele Meme-munt tot 5% van de openbare keten waarin de token zich bevindt, vertegenwoordigt.</p>
<p>Wormhole heeft aangekondigd dat het de verzameling van airdropped W-tokens zal openen om 19:30 Beijing-tijd op 3 april, en Gate.io zal blijven monitoren. Ondertussen zal Parcl, het RWA-conceptprotocol op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Chain, kondigde zijn airdrop-plan aan. Parcl is een vastgoedindex-investeringsplatform dat eerder een seed-ronde financiering van $ 4,1 miljoen heeft afgerond met investeringsinstellingen, waaronder Dragonfly en <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Ventures.</p>
<p>De openbare keten REI is op dezelfde dag meer dan twee keer zo groot geworden, en er wordt gefluisterd dat het een partnerschap is aangegaan met OpenTaskAI om te transformeren tot een AI openbare keten.</p>
<p>Deze maatregel is vergelijkbaar met de vorige transformatie van Near public chain naar AI public chain. REI is dit jaar met meer dan tien keer gestegen, heeft de prijspiek van 2022 doorbroken en een nieuw historisch hoogtepunt bereikt.<br><img src="https://gimg2.gateimg.com/image/article/17116835011.png" alt=""><br>Bron: Gate.io</p>
<p>Kortom, de cryptomarkt vertoont een opwaartse trend en de concepten van Meme en AI blijven marktaandacht ontvangen. Beleggers moeten de marktsituatie goed begrijpen om verstandige investeringsbeslissingen te nemen.</p>
<h2 id="h2-Macro20Het20eerste20kwartaal20loopt20ten20einde20en20de20drie20belangrijkste20indexen20hebben20een20uitstekende20groei20laten20zien20De20meeste20markten20zijn20gesloten20voor20Pasen75811"><a name="Macro: Het eerste kwartaal loopt ten einde en de drie belangrijkste indexen hebben een uitstekende groei laten zien; De meeste markten zijn gesloten voor Pasen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Het eerste kwartaal loopt ten einde en de drie belangrijkste indexen hebben een uitstekende groei laten zien; De meeste markten zijn gesloten voor Pasen</h2><p>Reuters meldde dat op donderdag alle drie de belangrijkste Amerikaanse indices sterke kwartaalwinsten boekten, waarbij de S&amp;P 500-index met 10,16% steeg, wat de sterkste prestatie in vijf jaar in het eerste kwartaal markeerde. Dit was te danken aan <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> over AI-gerelateerde aandelen en verwachtingen dat de Federal Reserve dit jaar zal beginnen met het verlagen van de rente. Op dit moment verwerken beleggers de nieuwste reeks economische gegevens.</p>
<p>Gegevens tonen aan dat de Amerikaanse economie in het vierde kwartaal sneller groeide dan verwacht, mede vanwege sterke consumentenbestedingen. Een ander rapport wees erop dat het aantal eerste aanvragers van werkloosheidsuitkeringen laag was, wat aangeeft dat de arbeidsmarkt op een solide basis blijft.</p>
<p>Overnight verklaarde Federal Reserve Governor Christopher Waller dat de recente inflatiegegevens niet voldeden aan de verwachte daling, wat de reden bevestigde voor de centrale bank om het verlagen van de kortetermijn-rente doelstellingen uit te stellen, maar het niet uitsluiten van de mogelijkheid van het verlagen van de rente later dit jaar. Volgens CME’s FedWatch-tool verwacht de markt een waarschijnlijkheid van ongeveer 64% dat de Federal Reserve de rentetarieven in juni met minstens 25 basispunten (bps) zal verlagen.</p>
<p>De meeste van de 11 belangrijkste sectoren presteerden goed dit kwartaal, waaronder communicatiediensten, energie, technologie, enz., met alleen de vastgoedsector die daalde.</p>
<p>Het hoogtepunt van de wereldmarkt op vrijdag zijn de Amerikaanse inflatiegegevens over de persoonlijke consumptieve bestedingen (PCE), die na het einde van de Aziatische handelsdagen zullen worden vrijgegeven, terwijl de meeste Europese en Amerikaanse aandelen- en obligatiemarkten gesloten zijn voor Pasen. Het eerste kwartaal loopt ten einde en de herziene Amerikaanse groei- en inflatiegegevens voor het vierde kwartaal op donderdag hebben aangedrongen op een scenario van een “zachte landing” of zelfs “geen landing”, waardoor het wereldwijde sentiment is gestegen.</p>
<p>In de Aziatische markt letten investeerders op een reeks Japanse indicatoren, waaronder werkloosheidscijfers, detailhandelsverkopen, industriële productie en inflatie in Tokio. Er wordt verwacht dat Japanse aandelen zullen herstellen van de daling van 1,5% op donderdag, maar ze kunnen in de problemen komen als de yen verder versterkt.</p>
<p>De wisselkoers van de Japanse yen blijft de focus, en de Japanse premier Fumio Kishida intervenieerde donderdag in het debat en zei: “We zullen de trend van de wisselkoers met grote urgentie volgen en passende maatregelen nemen, zonder enige opties uit te sluiten om om te gaan met overmatige schommelingen in de wisselkoers.”</p>
<p>Met betrekking tot grondstoffen steeg Amerikaanse ruwe olie met 2,04% naar $83,01 per vat, terwijl Brent-ruwe olie steeg naar $87,5 per vat, een stijging van 1,64% op dezelfde dag.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S. &amp; Glazuur</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 juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>