RGFnZWxpamtzIG5pZXV3cyB8IEhhbHZlcmluZyBrb210IGVyYWFuLCBhbmFsaXN0ZW4gdmFuIEpQTW9yZ2FuIHplZ2dlbiAnQlRDIHphbCB6ZWtlciBkYWxlbiBuYSBoYWx2ZXJpbmcnOyBEYXRhIEF2YWlsYWJpbGl0eSBQcm90b2NvbCBBdmFpbCBrb25kaWd0IDYwME0gVG9rZW4gQWlyZHJvcHMgYWFu

2024-04-19, 04:05

<p><img src="https://gimg2.gateimg.com/image/article/171349949219.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Analisten20van20JPMorgan20zeggen20dat20Bitcoin20zeker20zal20dalen20na20de20halvering20gegevensbeschikbaarheidsprotocol20Avail20kondigde2060020miljoen20token20airdrops20aan839946"><a name="Crypto Dagelijkse Samenvatting: Analisten van JPMorgan zeggen dat “Bitcoin zeker zal dalen na de halvering”; gegevensbeschikbaarheidsprotocol Avail kondigde 600 miljoen token airdrops aan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Analisten van JPMorgan zeggen dat “Bitcoin zeker zal dalen na de halvering”; gegevensbeschikbaarheidsprotocol Avail kondigde 600 miljoen token airdrops aan</h2><p>Laten we eerst kijken naar <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Handelsactiviteiten van ETF’s. Volgens gegevens van Farside Investor vloeiden op 18 april de GBTC-fondsen van Grayscale uit met $90 miljoen. Ondertussen stroomde er $37,4 miljoen in de Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC), $12,8 miljoen in de Bitwise Bitcoin spot ETF (BITB), $9,5 miljoen in de ARK 21Shares Bitcoin spot ETF (ARKB) en was er een nettostroom van $6,6 miljoen in de WisdomTree Bitcoin spot ETF (BTCW).</p>
<p>JPMorgan-analisten geloven dat de prijzen van Bitcoin zullen dalen nadat ze gehalveerd zijn, en de markt heeft dit evenement al weerspiegeld. De huidige prijs van Bitcoin is $61,942.3.</p>
<p>Analist Nikolaos Panigrtzoglou wees er in een rapport op woensdag op dat “we niet verwachten dat de Bitcoin-prijzen zullen stijgen na de halvering, omdat de markt dit evenement al heeft ingeprijsd.” Deze visie is vergelijkbaar met hun eerdere meningen. De analist legde uit: “In feite geloven we dat er na halvering om verschillende redenen een neerwaartse trend in de Bitcoin-prijzen kan zijn.”</p>
<p>Een van de redenen is dat Bitcoin nog steeds in een overbought staat verkeert, zoals blijkt uit de analyse van open contracten in Bitcoin futures. Daarnaast wezen ze er ook op dat de prijs van Bitcoin in vergelijking met goud nog steeds veel hoger is dan de aangepaste prijs van JPMorgan van $45.000 en nog steeds hoger is dan de verwachte productiekosten van $42.000 na halvering.</p>
<p>Analisten stellen dat ondanks het herstel van de cryptomarkt, durfkapitaal voor crypto tot nu toe lauw is geweest, wat ook een rem kan zetten op de prijs van Bitcoin na de halvering.</p>
<p>Ondertussen, aangezien onrendabele Bitcoin-mijnwerkers het Bitcoin-netwerk verlaten, wordt verwacht dat hun rekenkracht aanzienlijk zal afnemen en genoteerde Bitcoin-mijnwerkers het marktaandeel zullen domineren. Na halvering overwegen sommige Bitcoin-mijnbouwbedrijven mogelijk om hun investeringen te diversifiëren naar regio’s met lagere energiekosten, zoals Latijns-Amerika of Afrika, om hun inefficiënte mijnbouwapparatuur te hergebruiken en restwaarde te verkrijgen.</p>
<p>“Unification Drop is een verenigende kracht die verschillende gemeenschappen samenbrengt en ontwikkelaars, bestuursleden, technische opvoeders, roll-up gebruikers, toezeggers en andere waardevolle bijdragers uit meerdere blockchaingemeenschappen beloont,” zei Avail op 18 april.</p>
<p>Avail is een Web3-infrastructuurlaag gebouwd met <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> De software-ontwikkelingssuite van zal 600 miljoen inheemse AVAIL-tokens uitkeren aan gebruikers. Avail werd opgericht in 2020 en Avail DA heeft basislaagtransacties verder verbeterd door aggregatie uit te breiden via methoden zoals KZG-toewijding en gegevensbeschikbaarheidssteekproeven.</p>
<p>Avail wordt gebruikt om Avail DA-diensten te verkrijgen, de verenigde laag te beschermen via staking en deel te nemen aan governance. Tokens worden uitgedeeld op basis van de totale tijd, diepte en impact van gebruikerscommitment aan het ecosysteem. Na de lancering van de mainnet zullen 354.605 portefeuilleadressen AVAIL-tokens ontvangen via een airdrop.</p>
<p>Data beschikbaarheid stelt nodes in staat om gebundelde transacties te verifiëren zonder alle gegevens uit het blok te downloaden. Ondertussen maakt de gemeenschappelijke KZG-toezegging in zero-knowledge protocollen het mogelijk om onderliggende gegevens te verifiëren zonder persoonlijke informatie prijs te geven. Ondertussen biedt Avail Nexus gebruikers een cross-chain brug voor activatransacties of uitwisselingen tussen meerdere blockchains. Ten slotte maakt Avail Fusion liquiditeitsstaking mogelijk van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, Bitcoin en andere activa.</p>
<h2 id="h2-Markttrends20BTChalvering20over20minder20dan20een20dag20met20zwakke20marktherstel379492"><a name="Markttrends: BTC-halvering over minder dan een dag met zwakke marktherstel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC-halvering over minder dan een dag met zwakke marktherstel</h2><p>De algehele cryptomarkt heeft een zwak herstel doorgemaakt, waarbij Bitcoin kortstondig boven de $64.000 steeg maar momenteel terugzakt naar ongeveer $61.000. Bitcoin spot ETF’s hebben vier opeenvolgende dagen nettoutstromen gezien. Nog geen dag verwijderd van de halvering van Bitcoin, die zal plaatsvinden op 20 april. Wat betreft de macro-economie heeft de Amerikaanse aandelenmarkt volatiliteit ervaren, waarbij voorzitter van de Federal Reserve, Bostek, verklaarde dat de inflatieniveaus te hoog zijn en wordt verwacht dat de rente niet zal worden verlaagd voor het einde van het jaar.</p>
<h3 id="h3-Markt20Hotspots62892"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Binnenlandse concept tokens zoals ONG, ONT, <a href="/price/neo-neo" rel="nofollow noopener noreferrer" target="_blank">NEO</a>, GAS en <a href="/price/qtum-qtum" target="_blank" class="blog_inner_link">QTUM</a> hebben een indrukwekkende prestatie laten zien in de heropleving van gisteren. Deze projecten zijn allemaal binnenlandse conceptvaluta die meerdere rondes van stieren- en berenmarkten hebben meegemaakt, maar het is de moeite waard om op te merken dat hun aantrekkingskracht niet duurzaam is.</p>
<p>Modulaire publieke ketting Avail kondigt airdrop aan: Avail kondigt airdrop van tokens aan voor testnet gebruikers, MATIC stakers en andere actieve Layer2 gebruikers. Avail’s concurrenten zijn onder andere Celestia en Eigenlayer. Dit nieuws kan meer gebruikers aantrekken om deel te nemen aan het Avail project en invloed hebben op de token prijzen.</p>
<p>Samenvattend is de algehele prestatie van cryptomarktprijzen zwak. Met de BTC-halvering die over minder dan een dag plaatsvindt, kunnen er aanzienlijke marktschommelingen optreden voor en na de halvering. Beleggers moeten markttrends in de gaten houden en tijdig hun investeringsstrategie aanpassen.</p>
<h2 id="h2-Macro20Aanhoudende20spanningen20in20het20MiddenOosten20stijgende20Amerikaanse20dollar20en20aanhoudende20stijging20van20goud20en20ruwe20olie829660"><a name="Macro: Aanhoudende spanningen in het Midden-Oosten, stijgende Amerikaanse dollar en aanhoudende stijging van goud en ruwe olie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Aanhoudende spanningen in het Midden-Oosten, stijgende Amerikaanse dollar en aanhoudende stijging van goud en ruwe olie</h2><p>De Amerikaanse aandelenmarkt sloot donderdag bijna vlak, omdat beleggers nauwlettend de nieuwste financiële verslagen van bedrijven bestudeerden. Economische gegevens en opmerkingen van functionarissen van de Federal Reserve geven aan dat de Fed waarschijnlijk niet op korte termijn de rente zal verlagen. Economische gegevens tonen aan dat de arbeidsmarkt veerkrachtig blijft, met het aantal eerste aanvragers van werkloosheidsuitkeringen per week dat hetzelfde blijft als de vorige week.</p>
<p>De S&amp;P 500-index is voor de vijfde opeenvolgende handelsdag gedaald vanwege de recente moeilijkheden op de aandelenmarkt na een stijging van vijf maanden die begon in november, mede als gevolg van de verwachtingen dat de Federal Reserve de rente in de eerste helft van dit jaar zou kunnen verlagen.</p>
<p>Aan de positieve kant, nadat META en Bernstein hun koersdoel verhoogden van $535 naar $590, steeg de S&amp;P 500 index met 1.54%, de grootste stimulans voor de S&amp;P 500 index.</p>
<p>Er zijn meldingen van een scherpe escalatie van vijandelijkheden in het Midden-Oosten, waarbij Aziatische aandelen- en obligatierendementen op vrijdag daalden, terwijl veilige havenvaluta’s, goud en ruwe olie stegen.</p>
<p>De Aziatische markt wordt verwacht een trage week positief af te sluiten op vrijdag, maar vanwege aanhoudende spanningen in het Midden-Oosten, verslechterend wereldwijd sentiment en onwil om voor het weekend te veel risico te nemen, kan het de opwaartse momentum van de markt beperken.</p>
<p>Belangrijk nieuws uit de mondiale financiële gemeenschap in Washington blijft handelaren zenuwachtig maken, vooral met betrekking tot wisselkoersen en het beleid van centrale banken in relatie tot de steeds meer havikachtige Federal Reserve. De Amerikaanse dollar blijft sterk, met een stijging van 3% in de afgelopen weken, waardoor deze het hoogste niveau sinds november heeft bereikt.</p>
<p>De Amerikaanse obligatierendementen zijn opnieuw gestegen en zullen voor de derde opeenvolgende week stijgen, waarbij het rendement van tweejarige schatkistobligaties is gestegen tot 5%. In de afgelopen weken is het rendement van tweejarige en tienjarige schatkistobligaties gestegen met 40-45 basispunten.</p>
<p>Aziatische aandelenmarkten staan voor hun grootste wekelijkse daling sinds januari, waarbij de MSCI Asia (exclusief Japan) index deze week met 2,3% is gedaald, 5% lager dan vorige week. Dit is de aanscherping van de financiële omstandigheden waar opkomende markten mee proberen om te gaan.</p>
<p>Vanwege zorgen over leveringsproblemen in het Midden-Oosten, stegen de Brent ruwe olie futures met 3% tot $89.74 per vat.</p>
<p>Goud steeg met 1,3% tot $2.409,45 en nadert langzaam het historische hoogtepunt van vorige week van $2.431,29.</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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>