RGFpbHkgTmlldXdzIHwgQlRDIGhlZWZ0IGVlbiBrYW5zIHZhbiAyMCUgb20gZGUgJDcwSyB0ZSBvdmVyc2NocmlqZGVuIHRlZ2VuIGhldCBlaW5kZSB2YW4gYXByaWw7IERhZ2VsaWprc2UgYWN0aWV2ZSBnZWJydWlrZXJzIHZhbiBkZSBXb3JsZCBBUFAgb3ZlcnNjaHJlZGVuIDEgbWlsam9lbjsgTWVlciBkYW4gJDQwME0gYWFuIEFWQVg

2024-02-19, 06:54

<p><img src="https://gimg2.gateimg.com/image/article/17083254871_12.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Honduras20verbiedt20cryptohandel20AVAX20ID20en20DYDX20tokens20zullen20deze20week20in20grote20hoeveelheden20worden20vrijgegeven277688"><a name="Crypto Dagelijkse Samenvatting: Honduras verbiedt cryptohandel, AVAX, ID en DYDX tokens zullen deze week in grote hoeveelheden worden vrijgegeven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Honduras verbiedt cryptohandel, AVAX, ID en <a href="/price/dydx-dydx" target="_blank" class="blog_inner_link">DYDX</a> tokens zullen deze week in grote hoeveelheden worden vrijgegeven</h2><p>Volgens Reuters heeft de National Bank and Securities Commission van Honduras aangekondigd dat het land’s financiële systeem verboden is om cryptocurrencies en vergelijkbare virtuele activa te verhandelen vanwege fraude- en witwasrisico’s. De resolutie treedt onmiddellijk in werking en is gepland voor aankondiging op vrijdag, hoewel de formele aankondiging pas volgende week maandag zal plaatsvinden. De resolutie verbiedt instellingen onder toezicht om ‘cryptocurrencies, crypto activa, virtuele valuta’s, tokens of enige vergelijkbare virtuele activa die niet zijn uitgegeven of geautoriseerd door de centrale bank’ te ‘handhaven, investeren, bemiddelen of verhandelen’.</p>
<p>Op dit moment is er geen regulering van crypto-activa onder de Hondurese wet, hoewel platforms voor de handel in crypto-activa wel actief zijn in het land. Toezichthoudende autoriteiten wijzen erop dat vanwege het feit dat veel van deze platforms geregistreerd zijn in meerdere rechtsgebieden, de Hondurese wet geen controle over hen kan uitoefenen en dat zij mogelijk ‘deelnemen aan frauduleuze, witwas- en financieringsactiviteiten voor terroristische doeleinden’. De Centrale Bank van Honduras heeft gewaarschuwd dat zij niet verantwoordelijk is voor dergelijke transacties en geen enkele garantie kan bieden voor dergelijke transacties.</p>
<p>Eerder in januari werd gemeld dat de Prospera Special Economic Zone in Honduras erkend werd. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> als rekeneenheid. Het is momenteel onduidelijk wat voor invloed het nieuwe beleid zal hebben op deze speciale economische zone.</p>
<p>Pixels heeft aangekondigd dat het in totaal 20 miljoen PIXEL-tokens zal airdroppen naar RON-stakers, te verdelen in twee fasen: de eerste batch van 10 miljoen tokens is al begonnen en de tweede batch zal binnen een maand worden verdeeld. De snapshotdatum is vastgesteld op 8 februari om 10:00 uur. Op basis van het aantal RON’s dat gebruikers inzetten, worden ze ingedeeld in vier niveaus, en het totale aantal PIXEL-beloningen dat voor elk niveau wordt verkregen, is als volgt: 1 RON: 183,34 PIXEL verkregen; 55 RON: 675,75 PIXEL verkregen; 684,64 RON: 2315,77 PIXEL verkregen; 8317,4 RON: 3955,11 PIXEL verkregen.</p>
<p>Het bovenstaande bedrag vertegenwoordigt het totale bedrag dat voor elk niveau kan worden geclaimd, en gebruikers kunnen vandaag de helft ervan claimen. Om het tweede deel van de beloning te ontvangen, moeten gebruikers het overeenkomstige niveau van geschiktheid behouden. Let op dat de geldigheidsperiode voor twee claims 3 maanden is vanaf de datum van eerste geschiktheid. De PIXEL-beloning wordt naar het game-e-mailadres van de gebruiker gestuurd, en het claimproces kan tot 1 uur duren.</p>
<p>Volgens DeBank-gegevens is de huidige totale waarde van de Layer 2 Network Blast contractadres gelanceerd door Blur-oprichter Pacman meer dan $1,8 miljard, en bereikt $1.801.943.043. Ongeveer $1,64 miljard aan ETH is gestort in het Lido-protocol, $158.785.614 aan activa is gestort in het Maker-protocol, en $7.798.249 aan activa wordt aangehouden in de portefeuille.</p>
<p>Volgens de dagelijkse gegevens van Ark Invest heeft Cathie Wood’s ARK Invest op 16 februari 499.149 aandelen COIN (Coinbase Global Inc) verkocht. Daarvan heeft ARKK Fund 397.924 aandelen verkocht; ARKW Fund heeft 45.433 aandelen verkocht; en ARKF Fund heeft 55.792 aandelen verkocht. Berekend tegen een slotkoers van ongeveer $180 per aandeel op die dag, bedraagt de totale waarde ongeveer $90 miljoen.</p>
<p>De officiële post van Worldcoin verklaarde dat het aantal dagelijkse actieve gebruikers van de World App deze week de 1 miljoen heeft overschreden. Eind vorig jaar werd gemeld dat het aantal WorldAPP-gebruikers de 5 miljoen had overschreden, met meer dan 2,7 miljoen mensen die World ID’s bezitten.</p>
<p>Volgens gegevens van Coinglass bedraagt de huidige open positie in Bitcoin-futurescontracten op het netwerk 458.600 BTC’s (ongeveer $ 23,72 miljard). De Chicago Mercantile Exchange (CME) heeft een recordhoogte van 130.710 BTC’s (ongeveer $ 6,75 miljard) aan openstaande Bitcoin-futurescontracten, en staat op de eerste plaats; De open positie van het Binance Bitcoin-contract is 112.950 BTC’s (ongeveer $ 5,84 miljard), en staat op de tweede plaats.</p>
<p>Volgens gegevens van Lyra, het DeFi-optieprotocol, geloven crypto-handelaren dat de kans dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> eind april de $70.000 doorbreekt 20% is. Lyra heeft onlangs opties gelanceerd die op 26 april aflopen, waardoor handelaren kunnen speculeren over prijstrends voor en na de halvering van de Bitcoin-beloningen. Bitcoin is de afgelopen drie weken met 35% gestegen en bereikte $52.000, het hoogste niveau sinds het einde van 2021, wat een sterke opwaartse trend laat zien.</p>
<p>Volgens de gegevens van Token Unlocks zullen tokens zoals AVAX, ID en DYDX deze week eenmalig een grote ontgrendeling ervaren, met een totale release waarde van meer dan $400 miljoen. Daaronder:</p>
<p>Om 0:00 (UTC) op 22 februari, AVAX ( <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a>) zal 9,54 miljoen tokens ter waarde van ongeveer $383 miljoen ontgrendelen, wat overeenkomt met 2,6% van de circulerende voorraad;</p>
<p>Om 0:00 (UTC) op 22 februari zal SPACE ID 18,49 miljoen GAL-tokens ter waarde van ongeveer $10,73 miljoen ontgrendelen, wat overeenkomt met 4,29% van de circulerende voorraad;</p>
<p>Om 15:00 (UTC) op 20 februari DYDX ( <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a>) zal 575.000 tokens ter waarde van ongeveer $1,78 miljoen ontgrendelen, wat overeenkomt met 0,19% van de circulerende voorraad; In totaal zijn er deze week 2,16 miljoen tokens ontgrendeld, ter waarde van $682, wat overeenkomt met 0,72% van de circulerende voorraad.</p>
<p>Daarnaast ACA (Acala) en <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1duim</a> (1INCH) zal deze week ook tokens ter waarde van honderdduizenden dollars ontvangen. STRK (Starknet) zal token vrijgeven/verdelen om 8:00 uur op 20 februari.</p>
<h2 id="h2-Macro20PPI20overtreft20verwachtingen20met20een20waarschijnlijkheid20van209020dat20de20rente20in20maart20niet20wordt20verlaagd846409"><a name="Macro: PPI overtreft verwachtingen, met een waarschijnlijkheid van 90% dat de rente in maart niet wordt verlaagd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: PPI overtreft verwachtingen, met een waarschijnlijkheid van 90% dat de rente in maart niet wordt verlaagd</h2><p>Het marktthema van de afgelopen week is gebleven bij de verzwakking van de verwachtingen voor renteverlagingen. Nadat gegevens hadden aangetoond dat de Amerikaanse inflatie niet zo snel afkoelde als investeerders hadden gehoopt, werden handelaren gedwongen om hun weddenschappen op de snelle renteverlaging van de Federal Reserve voort te zetten, waarbij de verwachting van de eerste renteverlaging werd uitgesteld tot juni. De renteswap laat zien dat de huidige marktprijzen voor de renteverlaging van de Federal Reserve in 2024 minder dan 90 basispunten bedragen, dicht bij het gemiddelde van 75 basispunten voorspeld door beleidsmakers, in vergelijking met de verwachting van 150 basispunten begin februari.</p>
<p>Beleggers zullen door de notulen van de vergadering van het Federal Open Market Committee (FOMC) op donderdag verder inzicht krijgen in de visie van beleidsmakers over de weg van rentedalingen. Op dezelfde dag zal de Europese Centrale Bank ook de notulen van haar rentevergadering vrijgeven. Daarnaast zal er deze week een dichte release zijn van PMI-gegevens uit verschillende landen.</p>
<p>Afgelopen vrijdag overtroffen alle PPI-indicatoren de verwachtingen, waarbij de Amerikaanse PPI in januari op jaarbasis met 0,9% en op maandbasis met 0,3% steeg, beide hoger dan verwacht. De mogelijkheid van de Federal Reserve om de rentetarieven in mei en juni te verlagen, is afgenomen in de prijzen van swapcontracten. Dit betekent dat de PCE-gegevens over twee weken ook waarschijnlijk zullen herstellen, waardoor de verwachting wordt versterkt dat de Federal Reserve de rentetarieven niet snel zal verlagen, aangezien beleidsmakers bezorgd zijn dat een voortijdige renteverlaging een opleving van de inflatie kan veroorzaken.</p>
<p>Ian Lyngen van BMO Capital Markets wees erop dat de PPI een ‘verontrustende gegevens’ is die de toon bevestigt die is gezet door de kern-CPI. Voormalig minister van Financiën Lawrence Summers verklaarde dat de schijnbaar aanhoudende inflatiedruk in de laatste gegevens suggereert dat de volgende beleidsmaatregel van de Federal Reserve waarschijnlijker een renteverhoging dan een rentedaling is.</p>
<p>Sinds de laatste vergadering hebben de meeste functionarissen van de Federal Reserve geduld getoond met rentewijzigingen en gewaarschuwd tegen vroegtijdige renteverlagingen gezien het sterke momentum van de Amerikaanse economie. Als de notulen van de vergadering een soortgelijke toon met meer beleidsmakers weergeven, kan de Amerikaanse dollar meer opwaartse momentum krijgen. Naarmate de verwachtingen van renteverlagingen vervagen, is de Amerikaanse dollarkoers dit jaar tot nu toe met 3% gestegen.</p>
<p>Als gevolg van de verzwakking van de verwachtingen voor een renteverlaging door de Federal Reserve als gevolg van de PPI-inflatiegegevens, bereikte de Amerikaanse dollarkoers tijdens de handel een intraday hoogste punt, maar herstelde snel alle winsten voordat hij uiteindelijk sloot op 104.275. Het benchmark rendement op 10-jaars Amerikaanse staatsobligaties bereikte kortstondig de 4,3%-grens en daalde vervolgens, om uiteindelijk te sluiten op 4,281%; het rendement op de rentegevoelige 2-jaars Amerikaanse staatsobligaties steeg kortstondig met meer dan 10 basispunten, waarmee het een hoogtepunt voor het jaar bereikte. De winsten aan het einde van de dag waren iets hoger en eindigden uiteindelijk op 4.644%.</p>
<p>De prijs van spotgoud daalde bijna $10 op korte termijn na de publicatie van de PPI-gegevens van januari in de Verenigde Staten, veerde vervolgens op en sloot uiteindelijk 0,44% hoger op $2013,23 per ounce, maar noteerde toch twee opeenvolgende negatieve wekelijkse cijfers; Spotzilver steeg sterk na stabilisatie op het niveau van 23, om uiteindelijk 2,14% hoger te sluiten op $23,42 per ounce.</p>
<p>Bovendien hebben de escalerende spanningen in het Midden-Oosten de afnemende hoop op renteverlagingen en het sombere vraagperspectief voor dit jaar verhuld, terwijl de internationale ruwe olie twee opeenvolgende weken is gestegen en bijna drie weken lang een nieuw hoogtepunt heeft bereikt. WTI-ruwe olie steeg met 0,81% tot $78,16 per vat; Brent-ruwe olie steeg met 0,58% tot $83,22 per vat. De drie belangrijkste Amerikaanse aandelenindexen sloten iets lager. Bij sluitingstijd daalde de Dow Jones Industrial Average met 0,37%, daalde de Nasdaq met 0,82% en daalde de S&amp;P 500-index met 0,49%.</p>
<p>Onlangs hebben verschillende functionarissen van de Federal Reserve hun standpunten geuit, waarbij voorzitter Bostic van de Atlanta Fed verklaarde dat hij geneigd is om in de zomer de rente te verlagen en nog steeds verwacht dat er twee renteverlagingen zullen plaatsvinden in 2024; voorzitter Barkin van de Richmond Fed is van mening dat de CPI-gegevens de reden bevestigen waarom de Federal Reserve meer vertrouwen nodig heeft in renteverlagingen.</p>
<p>Daarnaast verklaarde de voorzitter van de San Francisco Fed, Daley, dat drie renteverlagingen een redelijke maatstaf zijn voor dit jaar, en ook de voormalige ‘hawkish supporter’ Brad van de Fed is van mening dat renteverlagingen in maart verstandig zijn.</p>
<p>Volgens de Federal Reserve Watch van CME is de waarschijnlijkheid dat de Federal Reserve de rentetarieven handhaaft in het bereik van 5,25% - 5,50% in maart 90%, en de kans op een renteverlaging van 25 basispunten is 10%. De waarschijnlijkheid dat de rentetarieven onveranderd blijven tot mei is 61,6%, de waarschijnlijkheid van een cumulatieve verlaging van 25 basispunten is 35,2%, en de waarschijnlijkheid van een cumulatieve verlaging van 50 basispunten is 3,2%.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening 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 zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>