RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBkb29rIG5hIGhldCBvdmVyc2NocmlqZGVuIHZhbiAkNjlLIGVuIGhldCBicmVrZW4gdmFuIGVlbiBuaWV1dyBob29ndGVwdW50OyBEZSBCUklDUy1sYW5kZW4gcGxhbm5lbiBlZW4gYmV0YWxpbmdzc3lzdGVlbSB2b29yIGRpZ2l0YWxlIHZhbHV0YSB0ZSBjcmXDq3JlbjsgV2VyZWxkd2lqZGUgbWF

2024-03-06, 03:52

<p><img src="https://gimg2.gateimg.com/image/article/17096970841_4.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20BTC20dook20snel20na20het20bereiken20van20een20nieuw20historisch20hoogtepunt20BRICSlanden20zullen20betalingsen20creren20op20basis20van20digitale20valuta20De20SEC20beweert20dat20Binance20niet20bereid20is20informatie20te20verstrekken20en20verzoekt20om20gerechtelijke20tussenkomst152025"><a name="Crypto Daily Digest: BTC dook snel na het bereiken van een nieuw historisch hoogtepunt; BRICS-landen zullen betalingsen creëren op basis van digitale valuta; De SEC beweert dat Binance “niet bereid is informatie te verstrekken” en verzoekt om gerechtelijke tussenkomst" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: BTC dook snel na het bereiken van een nieuw historisch hoogtepunt; BRICS-landen zullen betalingsen creëren op basis van digitale valuta; De SEC beweert dat Binance “niet bereid is informatie te verstrekken” en verzoekt om gerechtelijke tussenkomst</h2><p>Laten we eerst eens kijken naar <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Handelsactiviteit van ETF’s. Volgens gegevens van Farside Investor bleven op 5 maart de GBTC-fondsen van Grayscale doorgaan met <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> aanzienlijk gestegen tot $332,5 miljoen; Ondertussen bedroeg de instroom van Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) $125,6 miljoen, de instroom van Bitwise Bitcoin spot ETF (BITB) $3,7 miljoen, de instroom van ARK 21Shares Bitcoin spot ETF (ARKB) $63,7 miljoen, en de netto instroom van WisdomTree Bitcoin spot ETF (BTCW) $6,6 miljoen.</p>
<p>Volgens Bloomberg-analist Eric Balchunas bereikte het dagelijkse transactievolume van 10 Bitcoin spot ETF’s op 5 maart 2021 een historisch hoogtepunt van $10 miljard bij het sluiten van de Amerikaanse aandelenmarkt. BlackRock’s IBIT, Fidelity’s FBTC, Bitwise’s BITB en ARK/21 Shares’ ARKB vestigden allemaal nieuwe records.</p>
<p>Het meest opvallende recentelijk is de prijs van Bitcoin. Bitcoin daalde snel na het bereiken van een historisch hoogtepunt voor het eerst in meer dan twee jaar. Gegevens tonen aan dat BTC het historische record dat vorige week woensdag werd neergezet, heeft gebroken door op 5 maart door de $69.210 te breken, met een totale marktwaarde van meer dan $1,3 biljoen voor Bitcoin. Eerder bereikte Bitcoin verschillende hoogtepunten van $68.999,99 per munt op 10 november 2021. Achtentwintig maanden later vestigde Bitcoin een nieuw record, en sinds 2024 is het met 62,64% gestegen.</p>
<p>Echter was er daarna een aanzienlijke daling in prijzen, met een afname van meer dan $10.000 binnen 24 uur. Volgens CoinGlass-gegevens zijn er in de afgelopen 24 uur 320.000 handelaren geliquideerd, voornamelijk longposities, wat neerkomt op $1,19 miljard. Op het moment van schrijven is de BTC-prijs $62.921,9.</p>
<p>Ed Tolson, CEO en oprichter van Kbit, een cryptohedgefonds, gelooft dat ‘de markt naar verwachting een aanzienlijke correctie zal zien, met een potentieel correctiebereik van 10% -20%. Elke substantiële daling zal leiden tot een cascaderende liquidatie van de crypto eeuwigdurende swapmarkt, waarbij retailbeleggers zich zullen haasten naar geheven longposities en zeer hoge financieringstarieven’.</p>
<p>Het Russische persbureau TASS meldde dat de BRICS-groep, bestaande uit Brazilië, Rusland, India, China en Zuid-Afrika, zich zal inzetten voor het creëren van betalingsen op basis van blockchain en digitale technologie. Deze inspanning maakt deel uit van het versterken van de rol van BRICS-landen in het internationale monetaire systeem dit jaar. De BRICS-groep streeft al lange tijd naar het verminderen van haar afhankelijkheid van de Amerikaanse dollar voor afwikkeling, ook bekend als de-dollarisatie.</p>
<p>“We geloven dat het creëren van een onafhankelijk betalingssysteem een belangrijk doel is voor de toekomst van de BRICS-landen, gebaseerd op de meest geavanceerde tools zoals digitale technologie en blockchain. Het belangrijkste is ervoor te zorgen dat het handig is voor de overheid, het grote publiek en bedrijven, kosteneffectief is, en niet politiek beïnvloed wordt,” zei Kremlin-adviseur Yuri Ushakov in een interview met TASS. “De ontwikkeling van noodreserves zal doorgaan, voornamelijk gebruikmakend van valuta’s anders dan de Amerikaanse dollar.”</p>
<p>Vorige week meldde een ander TASS-rapport dat het Russische ministerie van Financiën, de Russische centrale bank en BRICS-partners een BRICS Bridge multilateraal betaalplatform zullen creëren om het mondiale monetaire stelsel te verbeteren. In februari schreef Klaas Knot, de voorzitter van de Financial Stability Board, die het mondiale financiële systeem nauwlettend volgt, een brief aan de ministers van Financiën van de G20-landen waarin hij verklaarde dat crypto-activa, tokenisatie en kunstmatige intelligentie (AI) prioriteiten blijven.</p>
<p>In haar gezamenlijke statusrapport dat op 5 maart bij de rechtbank van Washington DC werd ingediend, verklaarde de SEC dat BAM Trading Services (opererend onder de naam Binance.US) “niet in staat of niet bereid” was om te reageren op verzoeken om informatie over de bewaring van activa van klanten en verzocht om tussenkomst van de rechtbank om het ontdekkingsproces te versnellen. Aan de andere kant weerlegt Binance.US in het rapport de beschuldigingen en stelt dat het heeft voldaan aan alle “extreem brede” informatievereisten die door regelgevende instanties naar voren zijn gebracht en heeft het de rechtbank verzocht het versnelde proces voor het vrijgeven van bewijsmateriaal te beëindigen.</p>
<p>Het geschil tussen de SEC en Binance heeft eerder veel aandacht getrokken, waarbij het Amerikaanse ministerie van Justitie in november voor $ 4,3 miljard schikte; Overeenkomstig erkent CZ als onderdeel van de schikkingsovereenkomst bepaalde aanklachten en onderging hij een strafrechtelijke veroordelingszitting op 3 april, waarbij hij mogelijk tot 18 maanden gevangenisstraf riskeert.</p>
<h2 id="h2-Markttrends20BTC20bereikte20een20nieuw20hoogtepunt20en20viel20snel20paste20zich20aan20om20beter20te20stijgen965510"><a name="Markttrends: BTC bereikte een nieuw hoogtepunt en viel snel, paste zich aan om beter te stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC bereikte een nieuw hoogtepunt en viel snel, paste zich aan om beter te stijgen</h2><p>De huidige marktsituatie is vergelijkbaar met de verwachtingen van gisteren, maar er hebben zich enkele belangrijke schommelingen voorgedaan. Na een historisch hoogtepunt te hebben bereikt, zijn de BTC-prijzen snel gedaald, resulterend in een dagelijkse daling van maximaal $10.000. Ondertussen vertoont ook de Amerikaanse aandelenmarkt een duidelijke neerwaartse trend en is deze gedaald naar het laagste punt in de afgelopen twee weken. Deze schommeling is geen geïsoleerd fenomeen, maar eerder een aanpassing van de markthitte om zich beter voor te bereiden op toekomstige stijgingen.</p>
<p>BTC spotprijzen kenden een snelle daling nadat ze $69.000 hadden bereikt, daalden vanochtend vroeg tot zo laag als $59.000, met een daling tot wel $10.000, wat heeft geleid tot de liquidatie van hooghefboomcontracten. Deze schommeling heeft de hebzucht van de markt getemperd en investeerders ook herinnerd aan het bestaan van risico’s.</p>
<h3 id="h3-Markt20hotspots852373"><a name="Markt hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots</h3><p>Tegen de achtergrond van BTC die een vorige hoogtepunt bereikt en vervolgens instort, heeft de markt zich gericht op speculeren over de upgrade van Cancun. De tokens in de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De Layer2-sector, zoals STRK, OP, MANTA, etc., is tegen de trend in gestegen, terwijl het <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Domain Name Protocol ENS ook een stijging heeft gezien. De prestaties van het Meme-concepttoken zijn echter niet optimistisch, met toonaangevende Meme-tokens op de… <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Kettingen zoals MYRO en WIF maken intraday schommelingen van ongeveer 50% mee. Tegelijkertijd is de prestatie van AI-concepttokens relatief sterk en hebben tokens zoals AR en FET geen significante daling laten zien. Bijzonder opmerkelijk is dat FET gisteren de lancering van een nieuw project, Fetch Compute, heeft aangekondigd en beloofde $100 miljoen te investeren. Fetch Compute is een cloud computing platform en de lancering van dit project kan nieuwe groeikansen voor FET met zich meebrengen en zijn positie op de markt versterken.</p>
<p>Over het algemeen blijkt uit de analyse dat de markt nog steeds vol zit met schommelingen en veranderingen, en investeerders moeten waakzaam blijven, de marktdynamiek nauwlettend volgen en tijdig hun strategieën aanpassen om betere investeringsrendementen te behalen.</p>
<h2 id="h2-Macro20Aziatische20aandelenmarkten20verzwakten20op20woensdag20technologische20aandelen20brengen20Wall20Street20lager20Goud20is20vergelijkbaar20met20Bitcoin20bereikt20een20nieuwe20historische20hoogte20en20valt20dan20terug911820"><a name="Macro: Aziatische aandelenmarkten verzwakten op woensdag, technologische aandelen brengen Wall Street lager; Goud is vergelijkbaar met Bitcoin, bereikt een nieuwe historische hoogte en valt dan terug." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Aziatische aandelenmarkten verzwakten op woensdag, technologische aandelen brengen Wall Street lager; Goud is vergelijkbaar met Bitcoin, bereikt een nieuwe historische hoogte en valt dan terug.</h2><p>Op de wereldwijde markt zijn handelaren terughoudend om significante inzetten te doen voordat de voorzitter van de Federal Reserve, Jerome Powell, een congresgetuigenis aflegt om te beoordelen of de Fed klaar is om de rentetarieven te verlagen. Volgens de CME FedWatch tool heeft de markt een kans van 68% dat de Federal Reserve in juni begint met het verlagen van de rente. Ze hebben een renteverlaging van 88 basispunten voor dit jaar opgenomen. Dit maakt de verklaring van Powell op woensdag erg belangrijk, maar tot nu toe zijn de meeste mensen geneigd te geloven dat hij zijn eerdere houding van ‘het opschorten van renteverlagingen’ niet zal veranderen.</p>
<p>De MSCI Asia Pacific Stock Index (MIAPJ0000PUS), de meest gebruikte aandelenindex buiten Japan, daalde met 0,21%. De Nikkei Index van Japan (.N225), die deze week een historisch hoogtepunt bereikte, zag investeerders winst nemen en de aandelenkoers daalde met 0,20%. De bluechip Shanghai en Shenzhen 300 Index (.CSI300) daalden met 0,42%, terwijl de Hong Kong benchmark Hang Seng Index met 0,73% steeg.</p>
<p>Reuters meldde dat de gegevens van dinsdag een vertraging in de groei van de Amerikaanse dienstensector lieten zien, met een meer dan verwachte daling van nieuwe fabrieksorders. De gegevens van de werkgelegenheid buiten de landbouw zullen later deze week worden vrijgegeven en worden het volgende aandachtspunt. Het rendement van de benchmark 10-jarige Amerikaanse schatkistobligaties bleef stabiel in Azië, met het laatste rapport van 4,162%. Vanwege zwakke gegevens daalde het op de vorige handelsdag naar een dieptepunt van een maand van 4,112%.</p>
<p>Ondertussen zijn de drie belangrijkste aandelenindexen op Wall Street allemaal met meer dan 1% gedaald, terwijl grote groeibedrijven zoals Apple (AAPL.O) zwak hebben gepresteerd en de chipindustrie de grootste impact heeft gehad op de door technologie gedomineerde Nasdaq Index (.IXIC). Als gevolg van de aanpak van Washington ten aanzien van geavanceerde technologie-export naar Beijing heeft AMD Semiconductor Company obstakels ondervonden bij het verkopen van kunstmatige intelligentiechips die specifiek zijn ontworpen voor de Chinese markt, wat schade heeft toegebracht aan de chipindustrie.</p>
<p>De Dow Jones Industrial Average (.DJI) daalde met 404,64 punten, ofwel 1,04%, naar 38.585,19 punten. Van de 11 belangrijkste industriële indices in de S&amp;P 500-index daalden er 8, technologie-aandelen daalden met 1,2%, en de index van niet-essentiële consumentengoederen (.SPLRCD) daalde met 1,2%. Energie (.SPNY) steeg met 0,7%, met de grootste stijging, gevolgd door een stijging van 0,3% in consumenten essentiële goederen (.SPLRCS).</p>
<p>Vorige week bleek uit de gegevens dat de inflatie in de eurozone in februari licht is afgenomen. Toch bleef de groeisnelheid van de basisprijzen hoog, wat de reden is dat de Europese Centrale Bank de rentetarieven nog enige tijd op historische hoogte zal handhaven voordat ze in de loop van het jaar het beleid versoepelt. De markt verwacht dat de Europese Centrale Bank dit jaar de rente met 90 basispunten zal verlagen.</p>
<p>Op woensdag daalde de Chinese aandelenmarkt mogelijk als gevolg van Beijing die een veel verwachte groeidoelstelling van 5% voor 2024 instelde op de Nationale Volkscongresvergadering de dag ervoor, maar zonder significante stimuleringsmaatregelen. Veel economen geloven dat het uitbreiden van de binnenlandse vraag de meest dringende prioriteit is van China, maar in de samenvatting van prioriteiten van Li Qiang is de belangrijkheid van deze maatregel relatief laag.</p>
<p>Het door het leiderschap voorgestelde motto is ‘Bevrijd nieuwe productiviteit’. Vanaf deze week heeft China provinciale regeringen op de hoogte gesteld om Xi Jinping’s agenda te bevorderen, maar specifieke uitvoering en stimuleringsdetails zijn nog steeds nodig om top-down innovatie te bevorderen.</p>
<p>Ondertussen bereikte de spotprijs van goud op dinsdag een historisch hoogtepunt van $2.141,59 en daalde met 0,1% naar $2.125,36 per ounce.</p>
<p>Amerikaanse ruwe olie daalde met 0,1% naar $78,07 per vat, terwijl Brent ruwe olie met 0,13% daalde naar $81,93 per vat.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S.</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 is 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>