RGFnZWxpamtzIG5pZXV3cyB8IEJpbmFuY2Uga2FuIGJvZXRlcyBiZXRhbGVuIHZhbiBtZWVyIGRhbiAkNCBtaWxqYXJkLCBkZSBtYXJrdG9tdmFuZyB2YW4gQml0Y29pbiBTcG90IEVURiBrYW4gMTAwIG1pbGphcmQgQW1lcmlrYWFuc2UgZG9sbGFycyBiZXJlaWtlbiwgZGUgUTIgQWlyZHJvcCB2YW4gQmx1ciBpcyBvcGVuIHZvb3IgdmV

<p><img src="https://gimg2.gateimg.com/image/article/17005453901_21.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Binance20kan20een20boete20betalen20van20meer20dan20420miljard20Blurs20Q220airdrop20is20beschikbaar20voor20verzameling764983"><a name="Crypto Daily Digest: Binance kan een boete betalen van meer dan $4 miljard, Blur’s Q2 airdrop is beschikbaar voor verzameling." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Binance kan een boete betalen van meer dan $4 miljard, Blur’s Q2 airdrop is beschikbaar voor verzameling.</h2><p>Volgens Bloomberg is het Amerikaanse ministerie van Justitie op zoek naar meer dan $4 miljard aan boetes van Binance Holdings Limited om jaren van onderzoek naar de beurs te beëindigen en het voortzetten van de activiteiten toe te staan.</p>
<p>Volgens ingewijden omvatten de onderhandelingen tussen het Amerikaanse Ministerie van Justitie en Binance de mogelijkheid dat de oprichter, CZ, strafrechtelijke aanklachten kan krijgen in de Verenigde Staten om onderzoeken naar vermoedelijke witwaspraktijken, bankfraude en schendingen van sancties op te lossen.</p>
<p>De bekendmaking kan vóór het einde van de maand worden vrijgegeven, maar de situatie is nog steeds onzeker. De specifieke tijd en structuur van het voorgestelde schikkingsplan, evenals de specifieke boetes, zijn nog niet duidelijk, maar Coin An kan boetes moeten betalen die meer dan $4 miljard bedragen, wat een van de grootste boetes zal zijn in de geschiedenis van strafzaken in de cryptowereld. Het onderzoek wordt geleid door het team witwassen van geld en vermogensherstel van het ministerie van Justitie, het Nationaal Veiligheidsdepartement en het kantoor van de openbare aanklager van de Verenigde Staten in Seattle.</p>
<p>Volgens Bloomberg Intelligence, met de deelname van bekende zwaargewicht bedrijven zoals Black Rock, Fidelity en Invesco, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De markt voor spot ETF zal waarschijnlijk uitgroeien tot een enorme markt ter waarde van $100 miljard.</p>
<p>Volgens een andere persoon die bekend is met de zaak, heeft Galaxy Digital eerder deze maand samengewerkt met Invesco en een conference call gehouden met ongeveer 300 beleggingsprofessionals om de toewijzing van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> te bespreken naarmate de introductie van Bitcoin spot ETF’s naderde.</p>
<p>De Canadese Autoriteit voor Toezicht op Financiële Instellingen (OSFI) heeft feedback gevraagd aan banken over de komende regels voor het melden van crypto risico’s. OSFI verklaarde in een verklaring dat digitale innovatie de manier waarop transacties, fondsen worden beheerd en waarde wordt bekeken verandert, maar het brengt ook risico’s met zich mee voor het financiële systeem. De recente gebeurtenissen op het gebied van crypto hebben de risico’s van ongereguleerde financiële innovatie benadrukt. Openbaarmaking verhoogt transparantie, vergelijkbaarheid van gegevens en marktdiscipline, wat bijdraagt aan het tot stand brengen van een veiliger financieel systeem. De deadline voor feedback is 31 januari. Naar verluidt zullen de ontwerprichtlijnen in de herfst van 2024 worden gepubliceerd en zullen de definitieve regels het volgende jaar worden aangekondigd.</p>
<p>Santander Private Banking International, een dochteronderneming van de Spaanse financiële dienstverlener Banco Santander, biedt handels- en beleggingsdiensten aan vermogende klanten in Zwitserland, voornamelijk in cryptocurrencies zoals Bitcoin (BTC) en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>(ETH).</p>
<p>In de komende maanden zal Santander Bank meer cryptocurrencies verstrekken die voldoen aan de screeningcriteria van de bank. Santander Bank verklaarde dat de dienst alleen wordt verleend via een klantrelatiemanager op verzoek, met activa die worden aangehouden in een gereguleerde bewaarstand en de bank die privésleutels opslaat in een veilige omgeving.</p>
<p>Wat betreft token airdrops heeft de NFT-markt Blur op 21 november op sociale media aangekondigd dat Seizoen 2 is afgelopen en handelaren in aanmerking komen om Seizoen 2 airdrops te ontvangen en 45 dagen hebben om BLUR aan te vragen. Met het einde van dit seizoen is het derde seizoen al begonnen, dat 6 maanden zal duren en nieuwe beloningen zal bieden voor NFT-handelaren en BLUR-houders. 50% van de beloningen van het derde seizoen zal worden toegekend aan NFT-handelaren via Blur-punten. Handelaren kunnen punten verdienen door NFT-biedingen, vermeldingen en leningen.</p>
<p>Op het gebied van gegevens, volgens blockchain-analysebedrijf Glassnode, steeg de indicator van netto positiemutatie in Bitcoin-transacties, die het aantal tokens meet dat wordt aangehouden door handelsportefeuilles op een specifieke datum in vergelijking met dezelfde datum vier weken geleden, naar 31.382,43 BTC ($1,16 miljard) op zondag, het hoogste niveau sinds 11 mei. Dit brengt het totale saldo dat door de beurs wordt aangehouden op 2,35 miljoen BTC.</p>
<p>Het instromen in de beursportefeuille wordt algemeen beschouwd als de intentie van investeerders om hun bezittingen te liquideren, potentiële verkoopdruk of het inzetten van tokens als marge op de futures- en optiemarkten.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag74910"><a name="Belangrijkste Token Trends van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste Token Trends van vandaag</h2><h3 id="h3-BTC690130"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1700545419BTC.png" alt=""><br>Op de daggrafiek wordt de weerstand op $37.980 voor de derde keer getest, maar voorzichtigheid is geboden, aangezien er op korte termijn een mogelijke divergentie is die wijst op een mogelijke ommekeer. Voorzichtige stieren wordt geadviseerd te wachten op een doorbraak boven $38.000 en zich te blijven richten op $40.500 en $42.015. Het bearish doel is $34.870.</p>
<h3 id="h3-ETH321033"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1700545446ETH.png" alt=""><br>De vier-uur grafiek heeft succesvol de belangrijkste neerwaartse trend doorbroken en de ondersteuning op $1.857 blijft intact. Op korte termijn kan er sprake zijn van voortgezette consolidatie, met een middellangetermijnverwachting van voldoende volume om de weerstand op $2.135 te doorbreken. Eenmaal doorbroken, wordt er een nieuwe piek verwacht over 18 maanden, met een doel van $2.381.</p>
<h3 id="h3-RIO275003"><a name="RIO" class="reference-link"></a><span class="header-link octicon octicon-link"></span>RIO</h3><p><img src="https://gimg2.gateimg.com/image/article/1700545466RIO.png" alt=""><br>Met een zesvoudige stijging in de laatste twee maanden is de dagelijkse grafiekstructuur gestegen van een dieptepunt van $0,1045 naar een doel van $0,6060. Op korte termijn lijkt de opwaartse beweging bevredigend, en wordt een terugtrekking voorgesteld om standvastig te blijven op $0,4650. Langetermijndoelen zijn onder andere $1,22, $5,22 en het hoogste doel van $8,88.</p>
<h2 id="h2-Macro20Met20hoge20inflatiedruk20en20achterblijvende20economische20recessierisicos20is20het20nog20te20vroeg20om20de20rente20onmiddellijk20te20verlagen627417"><a name="Macro: Met hoge inflatiedruk en achterblijvende economische recessierisico’s is het nog te vroeg om de rente onmiddellijk te verlagen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Met hoge inflatiedruk en achterblijvende economische recessierisico’s is het nog te vroeg om de rente onmiddellijk te verlagen.</h2><p>Laten we eerst eens kijken naar de belangrijkste wereldwijde markttrends. Op maandag zette de Amerikaanse dollar index zijn neerwaartse trend voort en daalde naar een nieuw dieptepunt van 103,37 in de afgelopen twee maanden, en sloot uiteindelijk 0,31% lager op 103,49. Eerst daalden en daarna stegen de Amerikaanse obligatierendementen. Het rendement op 10-jarige Amerikaanse staatsobligaties sloot op 4,426%; Het rendement op 2-jarige Amerikaanse staatsobligaties, dat gevoeliger is voor het rentebeleid van de Federal Reserve, stond op 4,9% en sloot uiteindelijk op 4,919%.</p>
<p>De spotgoud daalde eerst en steeg toen, met een intraday dieptepunt van $1965.54 tijdens de Europese sessie. Later herwon het grootste deel van zijn verloren terrein, maar keerde niet terug boven het niveau van 1980, en sloot uiteindelijk 0.14% lager op $1978.05 per ounce; Spotzilver daalde met meer dan 1% op de dag en bereikte kortstondig een intraday dieptepunt van $23.24, om uiteindelijk 1.21% lager te sluiten op $23.44 per ounce.</p>
<p>Vanwege de mogelijkheid dat OPEC deze week de productie vermindert, blijven de twee oliebedrijven herstellen. De prijs van WTI ruwe olie steeg op een gegeven moment met meer dan 2% en keerde terug naar ongeveer $78, maar nam later een deel van de winsten terug en eindigde 1,99% hoger op $77,56 per vat; Brent ruwe olie naderde kortstondig $83 en steeg uiteindelijk met 1,76% naar $81,97 per vat.</p>
<p>De Amerikaanse aandelenmarkt steeg als gevolg van een beter dan verwachte veiling van de 20-jarige Amerikaanse obligaties, en de drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk hoger af. De Dow steeg met 0,58%, de S&amp;P 500 index steeg met 0,74% en de Nasdaq steeg met 1,13%. Microsoft (MSFT.O) en INVIDIA (NVDA.O) bereikten historische slotkoersen, met respectievelijk een stijging van 2% en 2,2%.</p>
<p>Vicevoorzitter van de Federal Reserve, Barr, verklaarde dat de Federal Reserve mogelijk de piekrentetarieven heeft bereikt of benaderd; Voorzitter van de Federal Reserve Bank van San Francisco, Daley, is van mening dat de hoge risico’s en ‘ambigue’ economische omstandigheden betekenen dat de Fed geleidelijkheid moet implementeren; Voorzitter van de Federal Reserve Bank van Boston, Collins, verklaarde dat de huidige gegevens zeer chaotisch zijn en dat de Federal Reserve bereid is geduldig te wachten. De mogelijkheid van verdere renteverhogingen zal niet worden uitgesloten; Voorzitter van de Federal Reserve Bank van Richmond, Barkin, is van mening dat de inflatie hardnekkig hoog blijft, wat een reden is om de rentetarieven langere tijd hoog te houden.</p>
<p>Kortom, de FOMC heeft misschien het verhogen van de rente beëindigd, maar functionarissen hebben nog steeds geen vertrouwen in dit oordeel.</p>
<p>Economen geloven dat de economische recessie mogelijk al is begonnen, maar de inflatie is nog ver verwijderd van de 2% doelstelling van de Federal Reserve, ver genoeg om hen ervan te weerhouden de rentetarieven aanzienlijk te verlagen. Nog ingewikkelder is dat bij economische keerpunten economische activiteitsgegevens vaak een opwaartse trend vertonen, wat betekent dat de Federal Reserve mogelijk pas later zal weten dat de economie inderdaad achteruitgaat. Dit houdt het risico in stand van verdere renteverhogingen of het handhaven van hogere rentetarieven gedurende een langere periode.</p>
<p>Echter heeft de markt het risico van verdere renteverhogingen door de Federal Reserve uitgesloten. De analyse van natuurlijke taalverwerkingsmodellen in buitenlandse media toont aan dat de recente verklaring van het comité nog steeds wijst op een havikachtige bias, hoewel het zich richting neutraliteit verschuift. Dit weerspiegelt voornamelijk de streven van de leden om voorzichtigheid over te brengen en een ‘hogere en langere’ houding naar de markt uit te drukken. Functionarissen hebben nog geen vertrouwen dat de inflatie niet zal terugveren en dat er geen behoefte is aan extra renteverhogingen. De FOMC heeft de rente al verhoogd, maar werkt hard om de boodschap over te brengen dat er geen onmiddellijke renteverlaging zal zijn.</p>
<p>Met de verwachting dat renteverhogingen hun hoogtepunt bereiken, hebben we gezien dat de Amerikaanse dollar verzwakt en dat de valuta van andere landen beginnen te versterken. Deze tekenen geven aan dat renteverhogingen verleden tijd zijn geworden, en volgend jaar zal een grotere schaal van versoepelingsbeleid inluiden. Na renteverlagingen zal er weer een ander feest zijn.</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 is toegestaan mits Gate.io wordt genoemd. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>