RGFnZWxpamtzIE5pZXV3cyB8IEhvbmcgS29uZyByZWd1bGVlcnQgaGV0IHRvZXppY2h0IG9wIHZpcnR1ZWxlIGFjdGl2YSB2YW4gcHVibGlla2UgZm9uZHNlbjsgU09MLCBBVkFYIGVuIEhOVCBsZWlkZW4gZGUgc3RpamdpbmcgdmFuIGNyeXB0b2N1cnJlbmNpZXMgaW4gMjAyMzsgU09MIGlzIGRpdCBqYWFyIG1ldCBtZWVyIGRhbiA3MDA

2023-12-27, 03:51

<p><img src="https://gimg2.gateimg.com/image/article/17036574771_19.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Hong20Kong20reguleert20het20toezicht20op20virtuele20activa20in20openbare20fondsen20SOL20leidde20de20opkomst20van20valuta20in20het20tijdperk20van202023118161"><a name="Crypto Dagelijkse Samenvatting: Hong Kong reguleert het toezicht op virtuele activa in openbare fondsen, SOL leidde de opkomst van valuta in het tijdperk van 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Hong Kong reguleert het toezicht op virtuele activa in openbare fondsen, SOL leidde de opkomst van valuta in het tijdperk van 2023</h2><p>Onlangs heeft de Hong Kong Securities Regulatory Commission volgens China Fund News een kennisgeving uitgegeven waarin staat dat voor publieke fondsproducten met virtuele activa die meer dan 10% uitmaken, hun managementbedrijven, relevante investeringsstrategieën en productbewaarders aan de overeenkomstige voorwaarden moeten voldoen. Het managementbedrijf moet personeel hebben met ervaring in het beheren van virtuele activa. Volgens de huidige voorschriften mogen instellingen die in het bezit zijn van het nummer 9-licentiebord van de Hong Kong Securities Regulatory Commission over het algemeen niet meer dan 10% van hun fondsportefeuilles in virtuele activa hebben.</p>
<p>In de nieuwste mededeling staat duidelijk dat als het percentage virtuele activa hoger is dan (of naar verwachting hoger is dan) 10%, het beheersorgaan goedkeuring moet aanvragen bij de Hong Kong Securities and Futures Commission voordat de relevante producten aan Hong Kongse beleggers kunnen worden verkocht.</p>
<p>Deze kennisgeving getiteld ‘Erkenning van de Hong Kong Securities and Futures Commission voor beleggingen in virtuele activa’ stelt duidelijk dat bedrijven die virtuele activa beheren (waarbij virtuele activa meer dan 10% van de fondsen vertegenwoordigen) een goede nalevingsgeschiedenis moeten hebben en ten minste één werknemer van het bedrijf ervaring moet hebben in het beheer van virtuele activa of gerelateerde producten. Het managementbedrijf moet voldoen aan de bestaande of nieuwe eisen van de vergunningverlenende toezichthoudende autoriteit voor beheermaatschappijen van virtuele activa.</p>
<p>Gisteren heeft het crypto-onderzoeksbureau Delphi Digital “The Future of DeFi in 2024” uitgebracht. Er wordt vermeld dat het kernliquiditeitsstakingpatroon van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> is moeilijk om enige substantiële veranderingen te ondergaan; RWA wordt stilletjes een van de meest succesvolle gebieden van cryptocurrency in 2023, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> V4, <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> X en andere DEX zullen het thema worden van 2024, Rollups is een verstandige keuze voor verschillende toepassingen, en IRD kan een van de populaire verhalen van cryptocurrency worden.</p>
<p>Onder hen gelooft Delphi Digital dat Atm, pendlefi, Notional Finance en iporio duurzame IRD-protocollen zijn.</p>
<p>Rentederivaten (IRD), ook bekend als rentederivaten, zijn financiële contracten waarvan de waarde is gebaseerd op een referentierentevoet of rentebearing asset. Dit type derivaat omvat rentefutures, opties, swaps, enz. Ze zijn instrumenten die worden gebruikt om risico’s af te dekken of te speculeren op veranderingen in rentetarieven op de markt.</p>
<p>Rente-derivaten kunnen worden onderverdeeld in twee categorieën: lineaire en niet-lineaire. Lineaire derivaten, zoals renteswaps en futures, waarvan de betalingen of rendementen rechtstreeks verband houden met de benchmark rentevoet; Niet-lineaire derivaten, zoals rente-opties, bieden het recht om onder specifieke omstandigheden een bepaald actief te kopen of verkopen, maar geen verplichting.</p>
<p>Op 26 december, volgens CoinDesk, in 2023, Layer-1 blockchain <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> (SOL) nam de leiding in de stijging van de tokenprijs, gevolgd door <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a>(AVAX), <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> (STX) en <a href="/price/helium-hnt" rel="nofollow noopener noreferrer" target="_blank">Helium</a> (HNT).</p>
<p>Solana heeft sinds medio oktober een aanzienlijke stijging gezien, met een groeipercentage van meer dan 700% sinds het begin van dit jaar. GSR senior strateeg Brian Rudick zei: “nadat FTX failliet ging, had <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> inderdaad problemen met overleven. Met de toename van on-chain activiteiten, een nieuw begrip van zijn innovatieve technologie en verschillende high-profile air drops, is het daarentegen tot bloei gekomen.”</p>
<p>Helium’s HNT-token behaalde ook aanzienlijke omzet in 2023, waarvan het merendeel in december. Na de intrede van het bedrijf in de mobiele sector steeg HNT met 500% gedurende het jaar. Voor <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> hebben veel institutionele partners geholpen om de waarde van tokens te verhogen, en AVAX is dit jaar tot nu toe met 300% gestegen. De inheemse token <a href="/price/stacks-stx" target="_blank" class="blog_inner_link">Stacks</a> (STX) van Stacks Network steeg gedurende het jaar met 623%. Met de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Door de gekte rondom rangtelwoorden en de voortdurende groei van TVL op het protocol, zag de token een aanzienlijke stijging in maart. Volgens de gegevens van DeFiLlama is de TVL van Stacks Network ook aanzienlijk toegenomen gedurende het jaar, van $6 miljoen in januari tot $50 miljoen.</p>
<p>Rudick verklaarde dat hij verwacht dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> zullen blijven stijgen in het nieuwe jaar, mede door de mogelijkheid van goedkeuring voor Amerikaanse spot Bitcoin ETF’s en de hulp van kapitaalinstromen. Hij wees er ook op: ‘we zien een nieuwe golf van blockchaingebruikers in gedecentraliseerde identiteiten op basis van plannen of aangekondigde belangen uit China, de Europese Unie, Brazilië en andere landen.’ Martin zei dat naast de focus op ETF’s aan het begin van het nieuwe jaar, ook real-world assets een gebied zullen worden om in de gaten te houden. Sommige gerelateerde stichtingen zijn dit jaar opgericht, maar de mainstream maatschappij heeft dit nog niet bijgebeend.</p>
<p>Op het gegevensniveau laten de statistieken van Coinalyze zien dat het marktaandeel van open posities in Bitcoin-futures in de afgelopen twee maanden is gedaald van 50% naar 38%, het laagste niveau in de afgelopen twee jaar. Het lijkt erop dat marktfondsen zich nu verplaatsen naar Altcoins, wat ook verklaart waarom de dominante positie van BTC in open futures-posities afneemt.</p>
<h2 id="h2-Belangrijkste20trends20van20vandaag20in20tokens26494"><a name="Belangrijkste trends van vandaag in tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends van vandaag in tokens</h2><h3 id="h3-BTC916734"><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/1703657516BTC.png" alt=""><br>De markt kende deze week verschillende terugtrekkingen en de sessie van gisteravond brak opnieuw onder de middellijn. De middellange termijn trend lijkt bearish, met belangrijke ondersteuningsniveaus op $40.280 en $38.399. De maandelijkse sluiting is optimistisch en streeft naar de $40.000 grens.</p>
<h3 id="h3-ETH511004"><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/1703657536ETH.png" alt=""><br>Op de korte termijn toont de vieruursgrafiek een neerwaartse driehoekstrend. Het wordt geadviseerd om te controleren of de weerstand bij $2.381 wordt doorbroken voor een opwaartse beweging. Het bearish doel van gisteren bereikte nauwkeurig het ondersteuningsniveau van $2.180. Als dit niveau standhoudt zonder te breken, wordt verwacht dat er een voortgezette opwaartse trend ontstaat in de vorm van een hoofd en schouders patroon. Als het gebroken wordt, is het volgende doel $2.135 voor het opnieuw testen van de ondersteuning.</p>
<h3 id="h3-INJ752043"><a name="INJ" class="reference-link"></a><span class="header-link octicon octicon-link"></span>INJ</h3><p><img src="https://gimg2.gateimg.com/image/article/1703657553INJ.png" alt=""><br>De daggrafiek vertoont tekenen van een topstructuur, en de gisteren doorbraak onder de steun van $37.54 suggereert een voortdurende test van $32.32. Op middellange tot lange termijn worden positieve vooruitzichten gehandhaafd op $61.084, $97.616 en $117.48. De algehele trend behoort tot de bull markt op middellange termijn, en vasthouden als een primaire strategie wordt geadviseerd.</p>
<h2 id="h2-Macro20Amerikaanse20aandelen20sloten20gezamenlijk20hoger20na20terugkeer20van20de20vakantie20Investeringsbanken20hebben20verschillende20meningen20over20de20renteverlaging20volgend20jaar875440"><a name="Macro: Amerikaanse aandelen sloten gezamenlijk hoger na terugkeer van de vakantie; Investeringsbanken hebben verschillende meningen over de renteverlaging volgend jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Amerikaanse aandelen sloten gezamenlijk hoger na terugkeer van de vakantie; Investeringsbanken hebben verschillende meningen over de renteverlaging volgend jaar</h2><p>Op dinsdag zette de Amerikaanse dollarindex zijn neerwaartse trend voort en daalde naar een intradag dieptepunt van 101,45, om uiteindelijk 0,23% lager te sluiten op 101,47; Het rendement op 10-jaars Amerikaanse staatsobligaties bleef bijna gelijk op 3,897%, terwijl het rendement op tweejaars Amerikaanse staatsobligaties, dat gevoeliger is voor de beleidsrente van de Federal Reserve, sloot op 4,356%.</p>
<p>Dankzij de zwakte van de Amerikaanse dollarindex en de Amerikaanse obligatierendementen bleef spotgoud stijgen en bereikte tijdens de Amerikaanse handel kortstondig een intraday-hoogtepunt van $2069,14, om uiteindelijk met 0,73% te stijgen naar $2.067,97/ounce; Spotzilver steeg met 0,16% en sloot op $24,23 per ounce.</p>
<p>Als gevolg van de enige aanval op Rode Zee schepen, heeft de markt zich zorgen gemaakt over interferentie met de scheepvaart, wat resulteerde in een aanzienlijke stijging van de olieprijzen binnen twee dagen. WTI-ruwe olie steeg in de handelssessie naar een intraday hoogtepunt van $76,14, maar gaf wat van zijn winst prijs in de late handelssessie en sloot uiteindelijk 2,58% hoger op $75,28 per vat; Brent-ruwe olie steeg sterk boven de $80-grens en sloot uiteindelijk 2,23% hoger op $80,63 per vat.</p>
<p>Het lange weekend van de Amerikaanse beurs eindigde en de drie belangrijkste aandelenindices sloten gezamenlijk hoger. De Dow Jones Industrial Average steeg met 0,43%, de S&amp;P 500 Index steeg met 0,42% en naderde daarmee het historische hoogtepunt van januari vorig jaar, en de Nasdaq steeg 0,54%.</p>
<p>Het jaar 2023 is turbulent geweest voor de markt en analisten van investeringsbanken hebben in 2024 gemengde opvattingen over de markt, sommigen zijn optimistisch en anderen hebben een pessimistische houding. Het belangrijkste <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> is dat de Amerikaanse economie zal versterken en de Federal Reserve de rente zal verlagen; Pessimistische mensen geloven dat hoewel de inflatie op dit moment onder controle lijkt te zijn, de zorgen van mensen over inflatie kunnen terugveren in het voorjaar van volgend jaar. De factoren die problemen veroorzaken zijn de rentetarieven zelf, problemen in de toeleveringsketen en hoge prijzen van materialen, goederen en diensten.</p>
<p>Onder hen voorspelt John Stoltzfus, Chief Investment Strategist bij Oppenheimer, dat de Federal Reserve de rente niet zal verlagen tot ten minste de tweede helft van volgend jaar, en als de inflatie hardnekkiger wordt, kan het actie ondernemen uiterlijk in het vierde kwartaal. Sommige marktdeelnemers verwachten een reeks renteverlagingen in het eerste kwartaal. Naar onze mening lijkt de helft van hen overdreven optimistisch. Na 11 renteverhogingen en 3 “stappen,” zal de pauze van de Federal Reserve in renteverhogingen waarschijnlijk langer zijn dan veel mensen hadden verwacht.</p>
<p>Het onderzoeksinstituut BCA is van mening dat als de Federal Reserve de rente snel verlaagt, de aandelenmarkt volgend jaar zo’n scherpe daling kan vermijden, maar de instelling verwacht niet dat de inflatie snel zal dalen. De BCA benadrukte dat “we ons nog steeds in het kamp van de vertragende inflatie bevinden, maar we verwachten niet dat de vertraging snel genoeg zal zijn”, in die mate dat de Federal Reserve en de Europese Centrale Bank niet in staat zijn de rente tijdig te verlagen om een aanzienlijke stijging van de werkloosheidscijfers te voorkomen. Tenzij er een economische recessie op handen is of de inflatie volledig instort, is het onwaarschijnlijk dat de Federal Reserve de rente voor de volgende zomer zal verlagen.</p>
<p>Vorig jaar rond deze tijd wedde de markt erop dat de Federal Reserve de rentetarieven tegen medio 2023 met ongeveer 50 basispunten zou verhogen en sommige verkrappende beleidsmaatregelen tegen het einde van dit jaar zou versoepelen. Als gevolg hiervan heeft de Federal Reserve de rentetarieven twee keer zo veel verhoogd als de markt had verwacht en is het beleid nog niet versoepeld.</p>
<p>Op dit moment lijkt de Amerikaanse economie, met name de arbeidsmarkt, een brede veerkracht te hebben, maar handelaren in rentetarieven geloven nog steeds sterk dat inflatie een ‘decoratie in de achteruitkijkspiegel’ is geworden, dus ze overwegen momenteel veel factoren om het beleid te versoepelen. De Federal Reserve schat dat het beleidsrentetarief in 2024 met 75 basispunten kan worden verlaagd, maar de markt is van mening dat een dubbele versoepeling volledig haalbaar is. We zullen afwachten hoe de markt zich zal ontwikkelen.</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 zal juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>