RGFnZWxpamtzIG5pZXV3cyB8IFNFQy12b29yeml0dGVyIG1hYWt0ZSBlZW4gdmVya2xhcmluZyBvdmVyIEJpdGNvaW4gU3BvdCBFVEYnczogQnJhemlsacOrIHZhbiBwbGFuIG9tIGVlbiAxNSUgQ3J5cHRvLWJlbGFzdGluZyB0ZSBoZWZmZW47IGVlbiB3YWx2aXMgaGVlZnQgbWVlciBkYW4gMy42MDAgQlRDJ3Mgb3ZlcmdlYm9la3QgbmE

2023-11-30, 04:04

<p><img src="https://gimg2.gateimg.com/image/article/17013241031_30.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Voorzitter20van20de20SEC20heeft20een20verklaring20afgelegd20over20Bitcoin20spot20ETFs20Brazili20plant20een201520belasting20op20crypto374429"><a name="Crypto Dagelijkse Samenvatting: Voorzitter van de SEC heeft een verklaring afgelegd over Bitcoin spot ETF’s, Brazilië plant een 15% belasting op crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Voorzitter van de SEC heeft een verklaring afgelegd over <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s, Brazilië plant een 15% belasting op crypto</h2><p>Recent bleef SEC-voorzitter Gary Gensler stil toen hem werd gevraagd naar de vooruitzichten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF’s en verklaarde dat hij dit onderwerp niet “zou anticiperen”. Gensler verklaarde in zijn toespraak op de bijeenkomst van de Healthy Markets Association dat hij geen voorspellingen zal doen over de Bitcoin spot ETF-aanvragen die in behandeling zijn. Hij noemde het beoordelingsproces van de instelling ooit een “door de tijd getest proces.”</p>
<p>De cryptosector wacht vol spanning op goedkeuring van de SEC voor de eerste Bitcoin spot-ETF, met vermogensbeheerbedrijven zoals Black Rock en Fidelity die de afgelopen maanden meerdere aanvragen hebben ingediend, maar tot dusver allemaal zijn uitgesteld. Gensler herhaalde zijn overtuiging dat Bitcoin een commodity is en uitte bezorgdheid voor de hele crypto-industrie. De SEC heeft het afgelopen jaar handhavingsmaatregelen genomen tegen crypto-bedrijven, waaronder Coinbase en Binance, de grootste crypto-uitwisseling ter wereld.</p>
<p>Gensler sprak ook zijn steun uit voor Rostin Behnam, voorzitter van de Commodity Futures Trading Commission (CFTC), om de bevoegdheid van derivatenregulerende instanties te vergroten om cryptocurrencies te reguleren.</p>
<p>Bovendien verklaarde de Amerikaanse onderminister van Financiën, Wally Adeyemo, anderzijds dat de regering-Biden het Congres verzoekt om de strengste hervorming van de sanctiebevoegdheid van het ministerie van Financiën sinds de terroristische aanslagen van 2001 te overwegen om te helpen bij de bestrijding van het gebruik van digitale activa in illegale financiën.</p>
<p>Adeyemo zei: “We roepen het Congres op om een secundair sanctiesysteem in te stellen, dat niet alleen een bedrijf zal uitsluiten van het Amerikaanse financiële systeem, maar ook zal blootleggen dat elk bedrijf dat nog steeds zakelijke transacties heeft met gesanctioneerde entiteiten, ook zal worden afgesneden. Op dinsdag heeft het ministerie van Financiën het Congres een reeks aanbevelingen op basis van gezond verstand gegeven om onze macht, tools en middelen uit te breiden om illegale actoren op het gebied van digitale activa te vervolgen.</p>
<p>Volgens Cointelgraph heeft de Braziliaanse Senaat op 29 november nieuwe inkomstenbelastingregels aangenomen, waarin staat dat Braziliaanse burgers binnenkort mogelijk tot 15% belasting moeten betalen over crypto-inkomsten die worden aangehouden op buitenlandse beurzen. Het wetsvoorstel is goedgekeurd door de Tweede Kamer en wordt naar verwachting goedgekeurd door president Luiz Inácio Lula da Silva, aangezien zijn regering een wijziging heeft geïnitieerd in de regels voor de inkomstenbelasting.</p>
<p>Volgens de wet zal elke Braziliaanse burger die meer dan $1,200 (6000 Braziliaanse reals) verdient aan buitenlandse valuta onderhevig zijn aan deze belasting vanaf 1 januari 2024. Maar het inkomen dat vóór 31 december van dit jaar is verkregen, zal worden belast tegen het huidige belastingtarief van 8%.</p>
<p>Arthur Hayes verklaarde in zijn laatste blogpost dat de Chinese autoriteiten mogelijk van plan zijn om een ​​grote hoeveelheid krediet in de economie te injecteren om de Bitcoin en bredere crypto-markten te stimuleren.</p>
<p>Hayes verklaarde dat de Verenigde Staten onlangs “de Amerikaanse dollar hebben verzwakt door meer schatkistpapier uit te geven” en nu de Amerikaanse dollarindex in november daalt, is deze impact nu heel duidelijk. Hij is van mening dat dit gunstigere voorwaarden heeft gecreëerd voor de Chinese autoriteiten om een “groot bedrag” nieuw krediet te verstrekken aan de worstelende vastgoedsector.</p>
<p>Deze wereldwijde valutadynamiek kan ten goede komen aan de Bitcoin en cryptomarkten. Hij zei dat als China geld bijdrukt, deze fondsen de wereldmarkt zullen betreden en de prijsstijging van allerlei soorten risicovolle activa zullen ondersteunen.</p>
<p>Ten eerste kan er geld naar risicovolle activa stromen vanuit het vasteland van China via Hong Kong. Hayes zei dat als er een manier is om op legale wijze geld van het vasteland van China naar Hong Kong over te maken, Bitcoin een van de vele risicovolle activa zal worden die worden gekocht. Ten tweede zal als gevolg van de overvloed aan RMB-krediet de mondiale vraag naar USD-krediet en liquiditeit afnemen.</p>
<p>Aangezien de Amerikaanse dollar de grootste financieringsvaluta ter wereld is, zullen de prijzen van alle vaste aanbodsmiddelen zoals Bitcoin en goud stijgen als de kredietprijzen dalen. Hayes concludeerde dat hij zich, omdat deze voorspelling gunstig is voor risico-activa, wil richten op crypto-investeringen in plaats van te investeren in Amerikaanse staatsobligaties. Hij verklaarde dat hij door zal gaan met het overboeken van fondsen van Amerikaanse schatkistbiljetten naar cryptocurrencies.</p>
<p>Volgens de laatste gegevens van de on-chain browser heeft een Bitcoin-walvisadres dat bijna 4 jaar slapend is geweest, op 30 november om 09:01:48 uur alle 3623 BTC’s overgedragen, wat resulteert in een zwevende winst van ongeveer $100 miljoen op basis van de huidige marktprijzen. Daarvan werden 2000 BTC’s overgedragen naar het adres 1AW1h4us8j5gnJRbhBndgjdx2vkfSe1iV8; 1623,12 BTC’s werden overgedragen naar het adres 1Jo518BnukxJtha4eCJE3kJHp8dxorzVTo.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag368308"><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-BTC20BTC709530"><a name="BTC (BTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC (BTC)</h3><p><img src="https://gimg2.gateimg.com/image/article/1701324157BTC.png" alt=""><br>Zowel BTC probeerde deze week zonder succes boven het niveau van $38.250 te stijgen. Momenteel handelt het net onder de neklijn op $37.980. Op korte termijn is de markt nog steeds in een staat van onbeslistheid tussen stieren en beren. Het is raadzaam om te wachten op een duidelijke richting voordat posities worden ingenomen. Tekenen van een potentieel hoogtepunt op middellange termijn dienen zich aan, en voorzichtigheid is geboden tegen potentiële volatiele marktomstandigheden.</p>
<h3 id="h3-ETH704"><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/1701324177ETH.png" alt=""><br>De vier-uur grafiek toont een doorbraak, stabiliseert de significante neergaande trend. De slotkoersen hebben zich twee dagen boven het weerstandsniveau van $2.000 gehouden. Let op een doorbraak boven $2.135 met een weerstand als doel op $2.317. Fibonacci-reeksen kunnen worden gebruikt om opwaartse bewegingen te meten. Een doorbraak onder het ondersteuningsniveau van $1.957 kan duiden op een verschuiving naar een bearish trend.</p>
<h3 id="h3-OGN58401"><a name="OGN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>OGN</h3><p><img src="https://gimg2.gateimg.com/image/article/1701324197OGN.png" alt=""><br>OGN, een ervaren project, heeft een sterke steun gehandhaafd op $0.0745 en ondanks een gebrek aan significante prijsbewegingen dit jaar, heeft het een abnormaal handelsvolume gezien. Op korte termijn vormt zich een cup and handle patroon en een doorbraak boven $0.1345 kan leiden tot doelen op $0.2247 en $0.2986, met een all-time high op $2.86.</p>
<h2 id="h2-Macro20Het20BBP20overtrof20de20verwachtingen20in20het20derde20kwartaal20Drie20FOMC20stemmende20commissieleden20hebben20verschillende20meningen548975"><a name="Macro: Het BBP overtrof de verwachtingen in het derde kwartaal. Drie FOMC stemmende commissieleden hebben verschillende meningen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Het BBP overtrof de verwachtingen in het derde kwartaal. Drie FOMC stemmende commissieleden hebben verschillende meningen.</h2><p>Op woensdag steeg de Amerikaanse dollarindex van een meer dan drie maanden laagte en testte voortdurend het niveau van 103 op de Amerikaanse markt, maar slaagde er niet in om boven dit niveau te stabiliseren, uiteindelijk met een stijging van 0,10% op 102,84. Het rendement op Amerikaanse staatsobligaties is voortdurend gedaald, waarbij het rendement op 10-jarige Amerikaanse staatsobligaties onder de 4,3% is gedaald en uiteindelijk is gesloten op 4,259%; Het rendement op 2-jarige Amerikaanse staatsobligaties, dat gevoeliger is voor de rentetarieven van de Federal Reserve, is gedaald tot 4,646%.</p>
<p>Spotgoud bleef stabiel boven het niveau van 2.040 en steeg kort boven het niveau van 2.050 in de Aziatische sessie, om uiteindelijk met 0,16% te sluiten op $2.044,17 per ounce; Spotzilver schommelde rond de $25 en sloot uiteindelijk met 0,02% lager op $25,02 per ounce.</p>
<p>Ruwe olie vertoonde een achtbaan trend, met WTI ruwe olie die daalde naar een intraday laag van $75.65 voordat het alle verloren terrein herstelde en hoger draaide, uiteindelijk met 1.52% te sluiten op $77.67 per vat; Brent ruwe olie daalde bijna 1% op een gegeven moment en bereikte de $80 grens, steeg vervolgens sterk naar ongeveer $83 en sloot uiteindelijk met 1.5% op $82.61 per vat.</p>
<p>De drie belangrijkste Amerikaanse aandelenindices openden hoog en sloten laag, met de Dow Jones die 0.04% steeg, de S&amp;P 500 die 0.09% daalde, en de Nasdaq die 0.19% daalde.</p>
<p>De gegevens van gisteravond werden vrijgegeven en het BBP voor het derde kwartaal werd naar boven bijgesteld tot 5,2%, niet alleen boven de aanvankelijke waarde van 4,9%, maar ook boven de marktverwachtingen van 5,0%. Dit is het snelste groeitempo sinds het vierde kwartaal van 2021. Het kan gezegd worden dat de gegevens er echt bullish uitzien, veel hoger dan het niveau van “1,8%” dat volgens de Federal Reserve geen inflatie zal veroorzaken - het zou de marktverwachtingen voor renteverlagingen volgend jaar aanzienlijk moeten verminderen. De situatie is echter niet zo eenvoudig als we ons voorstellen.</p>
<p>Het rapport bevestigt een neerwaartse trend in de inflatie, met de jaar-op-jaar groeisnelheid van de favoriete inflatie-indicator van de Federal Reserve, de PCE-prijsindex, naar beneden bijgesteld tot 2,8% in het derde kwartaal, en de kern-PCE-prijsindex (exclusief voedsel en energie) naar beneden bijgesteld tot 2,3% in het derde kwartaal.</p>
<p>Echter is Wall Street van mening dat dit rapport verleden tijd is en de situatie weergeeft in het derde kwartaal, terwijl de situatie in het vierde kwartaal erg slecht was, vooral in oktober toen de detailhandelsverkopen voor het eerst in zeven maanden daalden. Goldman Sachs heeft gisteravond zijn voorspelling voor het vierde kwartaal van het BBP van de Verenigde Staten verlaagd naar 1,4%.</p>
<p>Bovendien gaven twee functionarissen van de Federal Reserve woensdag redenen om de rente ongewijzigd te houden, terwijl een andere waarschuwde dat het risico van hoge inflatie zou moeten leiden tot het behouden van de mogelijkheid van verdere renteverhogingen.</p>
<p>Cleveland Fed-voorzitter Mester, die dit jaar heeft opgeroepen tot renteverhogingen, heeft verklaard dat het monetair beleid in een goede positie verkeert en hint erop dat ze opnieuw steun geeft aan het handhaven van de huidige rente op de volgende vergadering volgende maand.</p>
<p>De voorzitter van de Atlanta Fed, Bostic, verklaarde dat hij steeds meer overtuigd is dat de neerwaartse inflatietraject zou kunnen voortduren, terwijl de voorzitter van de Richmond Fed, Barkin, verklaarde dat de optie voor renteverhogingen moet worden behouden om te voorkomen dat inflatie hardnekkig wordt.</p>
<p>Bostic en Balgin hebben verschillende opvattingen over het inflatievooruitzicht. Balgin wees erop dat de aanhoudende prijsdruk in de huisvestings- en dienstensectoren een reden tot voorzichtigheid is.</p>
<p>Gisteravond hielden deze drie functionarissen van de Federal Reserve toespraken, waarin ze nog steeds vasthouden aan hun havikenstandpunt. Een persoon pleit voor het ongewijzigd houden van de rente, een ander waarschuwt om de optie voor renteverhoging open te houden, terwijl de ander niet spreekt over het rentepad, maar de verklaring van deze persoon is belangrijker.</p>
<p>Bostic had eerder verklaard dat hij niet geloofde dat er behoefte was aan verdere renteverhogingen. Hij ging ook zijn collega’s voor in het oproepen tot een halt aan renteverhogingen. De Federal Reserve van Atlanta voorspelt dat het inflatiecijfer tegen het einde van 2024 zal dalen tot 2,5% en tegen het einde van 2025 2% zal benaderen.</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 zich alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen, mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>