RGFpbHkgTmV3cyB8IEJsYWNrUm9jayBkaWVudCBFVEYgYnVpdGVubXV1cnJlY2xhbWUgaW4gYmlqIFNFQzsgMjEzIG1pbGpvZW4gWFJQIGdlc3RvbGVuIHZhbiBSaXBwbGU7IEhvbmcgS29uZyBvbmRlcnpvY2h0IFdvcmxkQ29pbjsgRlRYIGxhYXQgaGVyc3RhcnQgdmFsbGVu

2024-02-01, 04:27

<p><img src="https://gimg2.gateimg.com/image/article/17067616171_0.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Digest2021320miljoen20XRP20gestolen20van20Ripple20Hong20Kong20Onderzocht20WorldCoin532399"><a name="Crypto Dagelijkse Digest: 213 miljoen XRP gestolen van Ripple, Hong Kong Onderzocht WorldCoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Digest: 213 miljoen <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> gestolen van Ripple, Hong Kong Onderzocht WorldCoin</h2><p>Op 1 februari plaatste Bloomberg ETF-analist James Seyfhart op sociale media dat op de 14e handelsdag van spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s, BITB instroom was $18 miljoen en ARKB instroom was $15 miljoen. Daarnaast had GBTC een uitstroom van $188 miljoen, wat de minste uitstroomdag was, behalve de eerste handelsdag op 11 januari.</p>
<p>Volgens het dagelijkse positierapport van Grayscale, per 31 januari 2024, bedroeg het bezit van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> 487.025,986, een daling van 5086.4674 ten opzichte van de 492.112,4534 van gisteren. Bovendien bedroeg per 31 januari de vermogensbeheerschaal (niet-GAAP) van GBTC ongeveer $20.708 miljard, met een afname van het aantal uitstaande aandelen tot 545 miljoen en een bezit van ongeveer 0,00089353 BTC per aandeel. Daarnaast bedroeg het fondsuitstroom van Grayscale GBTC op de 14e handelsdag volgens BitMEX Research data monitoring ongeveer $188 miljoen, lager dan de $220 miljoen van de vorige dag.</p>
<p>Bovendien verklaarde Arthur Hayes gisteren op zijn sociale mediaplatform dat de onverwachte verliezen van de New York Community Bank als gevolg van voorzieningen voor kredietverliezen een verkoopgolf van aandelen kunnen veroorzaken, dus de Federal Reserve kan binnenkort beginnen met geld printen. Het wordt verwacht dat Bitcoin een lichte neergang zal ervaren. Als community banken in New York worden verkocht, zullen regelgevers onmiddellijk hulp bieden en Bitcoin zal de trend van maart vorig jaar repliceren (Bitcoin steeg met 22,96% in maart 2023).</p>
<p>Op 1 februari, volgens CryptoSlate, stelde BlackRock een plan voor in een document dat op 31 januari bij de SEC werd ingediend om reclame te maken voor zijn Bitcoin spot ETF aan de zijkant van gebouwen. Het document beschrijft kort het plan van BlackRock, waarin staat: “De IBIT-reclame is een animatie die is ontworpen om te projecteren op de buitenmuren van voormalige financiële instellingen in New York, Miami en Los Angeles. Dit storyboard gebruikt onze Miami buitenkant als sjabloon.”</p>
<p>De IBIT-code wordt blootgesteld tijdens de meeste animatieruns en de advertentie toont de tijdlijn van gebeurtenissen van BlackRock vóór de lancering van de Bitcoin ETF in januari van dit jaar. De scènesegmenten omvatten beschrijvingen van de lancering van de eerste Amerikaanse aandelenmarkt in 1790, de eerste Amerikaanse ETF in 1993, de lancering van Bitcoin in 2009 en de lancering van het eerste Bitcoin-futurescontract in 2017. De uiteindelijke prominente reclameslogans zijn onder andere ‘Een nieuw tijdperk van toetreding’ en ‘De komst van spot Bitcoin ETF’s’. Zoals hierboven vermeld, is BlackRock van plan om advertenties te plaatsen op voormalige bankgebouwen.</p>
<p>Het is momenteel onduidelijk of het bedrijf van plan is dit alleen op eigen terrein te doen of van plan is eigendommen van andere bedrijven te huren. Het gebouw op de display lijkt een gedeeld gebouw te zijn gelegen aan 360 Rosemary Avenue in West Palm Beach, Florida. BlackRock heeft eerder op 14 januari een meer traditionele advertentie uitgebracht voor IBIT. In vergelijking met concurrerende advertenties van bedrijven zoals Hashdex, VanEck, Bitwise, enz., wordt deze advertentie erkend vanwege de eenvoudige, duidelijke en informatieve aanpak. Ondertussen heeft privé-investeerder Fred Krueger opgemerkt dat sommige websites online advertenties zijn begonnen te tonen voor BlackRock IBIT-fondsen.</p>
<p>Op 31 januari plaatste mede-oprichter van Ripple, Chris Larsen, op sociale media waarin hij verklaarde dat zijn persoonlijke <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Het account (niet officieel) werd gisteren gehackt en het probleem werd snel ontdekt. Hij heeft de handelsplatform op de hoogte gebracht om het getroffen adres te bevriezen en wetshandhavingsinstanties hebben ingegrepen. Eerder werd gemeld dat on-chain detective ZachXBT eerder vandaag op sociale media plaatste dat het Ripple had gedetecteerd dat verdacht werd van het stelen van 213 miljoen XRPs (ongeveer $112 miljoen) door hackers.</p>
<p>Volgens de laatste marktgegevens van Gate.io daalde XRP op korte termijn bijna 4% als gevolg van dit nieuws en wordt nu aangeboden voor $0.497.</p>
<p>Gisteren heeft Hong Kong volgens Orange News een onderzoek ingesteld naar de vermeende illegale verzameling van klantirisinformatie door WorldCoin. Volgens een gerechtelijk bevel hebben de Hong Kong autoriteiten zes locaties in Hong Kong doorzocht, waaronder Yau Ma Tei, Kwun Tong, Wan Chai, Cyberport, Central en Causeway Bay, voor WorldCoin World Coin. Het Hong Kong Public Office roept burgers op om waakzaam te zijn en niet zomaar biometrische persoonlijke informatie te verstrekken.</p>
<p>Volgens The Block verklaarde FTX-advocaat Andrew Dietderich tijdens een hoorzitting op woensdag dat hij plannen om de beurs opnieuw op te starten heeft laten varen, maar dat hij voormalige klanten volledig zal terugbetalen. Dietderich verklaarde dat we momenteel verwachten voldoende middelen te hebben om alle toegestane vorderingen van klanten en crediteuren volledig te betalen. Maar FTX heeft niet de intentie om het platform opnieuw op te starten. Het bedrijf, dat voor honderden miljoenen dollars is overgenomen door FTX, heeft weinig waarde en er zijn geen investeerders geïnteresseerd in het investeren van de benodigde middelen om de beurs opnieuw op te starten.</p>
<p>De advocaat verklaarde ook dat er in februari een openbaarmakingsverklaring zal worden ingediend. Volledige compensatie is gebaseerd op de waarde van de claims op de aanvraagdatum. Tijdens de daaropvolgende hoorzitting heeft de rechter een verzoek van de FTX-schuldenaar goedgekeurd om digitale activaclaims om te zetten in Amerikaanse dollars. Op 1 februari, volgens de marktgegevens van Gate.io, steeg FTT op korte termijn met meer dan 20% en is nu met 38,49% gedaald, met een huidige prijs van $1,63.</p>
<p>Qua gegevensschommelingen, volgens de laatste gegevens van The Block, is het totale handelsvolume van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het openstaande <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> optiecontract in januari is gestegen tot bijna $20 miljard (momenteel $19,99 miljard), waarvan ongeveer $15 miljard afkomstig is van het Deribit-derivatenhandelsplatform. Volgens gegevens van Deribit zijn de meeste (ongeveer 74.548) openstaande Ethereum optiecontracten callopties met een uitoefenprijs van $2.500, die vrijdag 23 februari aflopen.</p>
<p>Bovendien is de voorraad stablecoins sinds het vierde kwartaal van 2023 toegenomen en deze trend heeft zich voortgezet in 2024. Op dit moment is de totale voorraad stablecoins in de afgelopen 30 dagen met ongeveer 3,5% gestegen, terwijl de stablecoin voorraad ratio (SSR) is gedaald van 4,13 eind oktober vorig jaar naar het bereik van 0,74, wat aangeeft dat stablecoins meer koopkracht hebben om BTC te kopen. Daarentegen vertoont de huidige voorraad Bitcoin een dynamische trend als gevolg van de lancering van Bitcoin spot ETF’s, en nemen institutionele fondsenstromen toe in de handelsvolume op de keten.</p>
<h2 id="h2-Macro20ADPwerkgelegenheidsgegevens20vielen20tegen20Powell20verklaarde20dat20het20onwaarschijnlijk20is20dat20de20rente20in20maart20wordt20verlaagd432312"><a name="Macro: ADP-werkgelegenheidsgegevens vielen tegen, Powell verklaarde dat het onwaarschijnlijk is dat de rente in maart wordt verlaagd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: ADP-werkgelegenheidsgegevens vielen tegen, Powell verklaarde dat het onwaarschijnlijk is dat de rente in maart wordt verlaagd</h2><p>ADP-werkgegevens vrijgegeven: in januari is het aantal ADP-banen in de Verenigde Staten gestegen met 107.000, wat minder is dan de verwachte 150.000. Echter, de groeisnelheid in december vorig jaar werd neerwaarts herzien naar 158.000. Dit komt overeen met de geleidelijke afkoeling van de arbeidsmarkt.</p>
<p>Na de publicatie van onverwachte ‘kleine niet-landbouw’ gegevens zakte de Amerikaanse dollar index kort onder de 103-markering. Later keerde het zijn intraday-daling om vanwege de directe klap van voorzitter van de Federal Reserve Powell op de verwachtingen van een renteverlaging in maart, en sloot uiteindelijk met een stijging van 0,121% op 103,52; Het Amerikaanse ministerie van Financiën gaf aan dat het de omvang van de kwartaalbondveilingen niet verder zou verhogen tot volgend jaar, wat de vraag naar Amerikaanse staatsobligaties stimuleerde. Het rendement van 10-jarige Amerikaanse obligaties daalde en brak voor het eerst in twee weken door de 4%-grens, om uiteindelijk te sluiten op 3,918%; Het rendement van 2-jarige Amerikaanse staatsobligaties, dat gevoeliger is voor het rentebeleid van de Federal Reserve, sloot op 4,209%.</p>
<p>Als gevolg van de marktverwachting van renteverlagingen die als een achtbaan rijden onder invloed van ‘kleine niet-landbouw’ gegevens en Powell’s ‘havik-release’, ervoer spotgoud onverwacht een omgekeerde V-ommekeer in de handel, waarbij het dagelijkse dieptepunt werd doorbroken tot $2.030,74 en bijna $25 daalde van het dagelijkse hoogtepunt. Het veerde uiteindelijk iets op en slaagde er uiteindelijk in om met 0,12% te stijgen tot $2.039,32/ounce. Spotzilver sloot uiteindelijk 0,96% lager op $22,94 per ounce.</p>
<p>Internationale ruwe olie hervatte zijn neerwaartse trend, omdat het koude weer Amerikaanse producenten aanzette tot een verhoogde productie, wat leidde tot een onverwachte toename van de ruwe olievoorraden. Ondanks de steeds gespannen situatie in het Midden-Oosten slaagden de twee oliebedrijven er toch in om hun eerste maandelijkse stijging te realiseren sinds september vorig jaar. WTI-ruwe olie daalde met 2,48% naar $75,75 per vat; Brent-ruwe olie sloot 2,35% lager op $80,91 per vat.</p>
<p>De drie belangrijkste Amerikaanse aandelenindexen zijn onder druk gesloten. De Dow Jones Industrial Average daalde met 0,83%, wat de grootste dagelijkse daling sinds 20 december vorig jaar markeerde; De S&amp;P 500 index daalde met 1,6%, wat de grootste dagelijkse daling sinds 21 september vorig jaar markeerde; De Nasdaq daalde met 2,2%, wat de grootste dagelijkse daling sinds 25 oktober vorig jaar markeerde.</p>
<p>De Federal Reserve heeft haar eerste renteresolutie voor 2024 aangekondigd, waarbij de rente voor de vierde achtereenvolgende vergadering ongewijzigd blijft. In de verklaring van het FOMC van de Federal Reserve werd de formulering “kan het beleid verder worden aangescherpt” geschrapt en werd gesteld dat de rentetarieven niet zullen worden verlaagd totdat er meer vertrouwen is dat de inflatie richting 2% blijft evolueren. Federal Reserve-voorzitter Powell: Het is onwaarschijnlijk dat de rentetarieven in maart zullen worden verlaagd, en er is wijdverbreide onenigheid onder functionarissen over het tempo van de renteverlagingen. De kwestie van de snelheid van de renteverlagingen zal in maart in detail worden besproken. Na de toespraak van Powell verminderden handelaren in rentefutures hun weddenschappen op de renteverlaging van de Fed in maart aanzienlijk.</p>
<p>Volgens Coindesk kunnen financiële markten te optimistisch zijn over de snelheid en het tempo van het beleid van de Federal Reserve om dit jaar de rentetarieven te verlagen. Het macrostrategieteam van JPMorgan, onder leiding van Shrenick Shah, verklaarde dat de belangrijke gebieden van inflatie die nauwlettend worden gevolgd door de Federal Reserve nog geen duidelijke tekenen van deflatie hebben laten zien.</p>
<p>Ze verklaarden dat het engagement van de Federal Reserve om potentiële inflatierebound te bestrijden nog steeds onderschat wordt, waardoor de deur openstaat voor aanpassingen in risicovolle activa. Eerder, met de inflatie die daalde in 2023 en de Federal Reserve die hintte op renteverlagingen tijdens haar vergadering in december, zijn de verwachtingen van renteverlagingen wijdverspreid geworden. Volgens gegevens van de federale fondsen en futuresmarkt verwachten handelaren dit jaar een renteverlaging van 140 basispunten, bijna twee keer zo hoog als de renteverlaging die blijkt uit de rentevoorspellingsgrafiek van de Federal Reserve in december (ook bekend als de beleidspadgrafiek).</p>
<p>Op 1 februari, volgens CME Federal Reserve waarneming, is de waarschijnlijkheid dat de Federal Reserve de rentetarieven handhaaft in het bereik van 5,25% - 5,50% in maart 64,5%, en de waarschijnlijkheid van een renteverlaging van 25 basispunten is 35,5%. De waarschijnlijkheid dat de rentetarieven ongewijzigd blijven in mei is 5,4%, de waarschijnlijkheid van een cumulatieve renteverlaging van 25 basispunten is 62,1%, en de waarschijnlijkheid van een cumulatieve renteverlaging van 50 basispunten is 32,5%.</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 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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>