RGFnZWxpamtzIG5pZXV3cyB8IFJ1c2xhbmQgZ2FhdCB3ZXRnZXZpbmcgaW52b2VyZW4gdm9vciBjcnlwdG9jdXJyZW5jaWVzOyBPUkRJIGVuIDEwMDBTQVRTIHphZ2VuIGVlbiBkYWdlbGlqa3NlIHN0aWpnaW5nIHZhbiBtZWVyIGRhbiA0MCU7IEJsYXN0IGVuIFN1aSBOZXR3b3JrIFRWTCBiZXJlaWtlbiBuaWV1d2UgaG9vZ3RlcHVudGV

2023-12-26, 04:03

<p><img src="https://gimg2.gateimg.com/image/article/17035744251_18.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Rusland20wordt20verwacht20begin20volgend20jaar20wetgeving20voor20cryptocurrencies20te20gaan20invoeren20ORDI20zag20een20dagelijkse20stijging20van20meer20dan2040946557"><a name="Crypto Dagelijkse Samenvatting: Rusland wordt verwacht begin volgend jaar wetgeving voor cryptocurrencies te gaan invoeren, ORDI zag een dagelijkse stijging van meer dan 40%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Rusland wordt verwacht begin volgend jaar wetgeving voor cryptocurrencies te gaan invoeren, ORDI zag een dagelijkse stijging van meer dan 40%</h2><p>Gisteren zei Anatoly Aksakov, voorzitter van het Comité Financiële Markten van de Russische Doema: “Vanwege de aanzienlijke omvang van de Russische cryptomarkt hopen de belangrijkste deelnemers aan cryptomining en -circulatie deze te reguleren, en ze zijn bereid om belasting te betalen. Daarom verwacht ik dat de cryptowetgeving in de eerste helft van 2024 wet zal worden.”</p>
<p>Gedreven door factoren zoals de mogelijke goedkeuring van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Analisten geloven dat institutionele beleggers meer positieve interesse zullen tonen in de cryptosector in 2024, vanwege spot ETF’s, verwachte renteverlagingen door de Federal Reserve en verhoogde regelgevende transparantie. Financiële instellingen kunnen hun activiteit op de cryptomarkt vergroten.</p>
<p>Sinds oktober 2023 is de handelsactiviteit van institutionele beleggers toegenomen. Luuk Strijers, Chief Business Officer van Deribit, verklaarde dat deelnemers uit traditionele markten in 2024 meer betrokken zullen raken bij de cryptomarkt.</p>
<p>Bitfinex-analisten geloven dat de belangrijkste drijfveer voor traditionele financiële instellingen om meer deel te nemen aan de cryptomarkt de goedkeuring van Bitcoin-spot-ETF’s is. Dit zal institutionele beleggers een gereguleerde manier bieden om te wedden op de prijs van ‘s werelds grootste cryptocurrency.</p>
<p>Analisten van Bitfinex suggereren dat mogelijke renteverlagingen in 2024 institutionele beleggers zullen aanmoedigen om risico’s te nemen. Deze grotere voorkeur voor risicovolle activa kan uiteindelijk van invloed zijn op Bitcoin. Bitfinex-analisten voegden eraan toe: ‘Renteverlagingen kunnen risicovolle activa zoals <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> aantrekkelijker maken voor institutionele beleggers die hogere rendementen zoeken in een omgeving met een lage rente.’</p>
<p>Volgens Bitfinex zullen investeerders worden aangemoedigd door meer regelgevende transparantie in het komende jaar. Analisten van Bitfinex zeggen dat het belangrijkste aspect van regelgevende transparantie de goedkeuring van Bitcoin spot ETF’s is, die ‘een gereguleerd en gemakkelijker verkrijgbaar beleggingsinstrument zullen bieden voor retail- en institutionele beleggers’.</p>
<p>Volgens de recente analyse van Glassnode is de rol van stablecoins in marktdynamiek aanzienlijk veranderd in vergelijking met de vorige cyclus, en ze zijn de voorkeursquotuta geworden voor handelaren en de belangrijkste bron van marktliquiditeit. Bovendien markeerde oktober de eerste uitbreiding van de stablecoin-voorraad sinds maart 2022, wat een teken kan zijn van hernieuwde investeerdersbelangstelling.</p>
<p>Volgens PolkaWorld, Gavin Wood, medeoprichter van <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a>, publiceerde zijn vooruitzichten voor 2024 in de jaarlijkse samenvatting van Polkadot, waarin staat dat <a href="/price/polkadot-dot" target="_blank" class="blog_inner_link">Polkadot</a> te maken zal krijgen met een reeks belangrijke ontwikkelingen en druk werk in het nieuwe jaar, waaronder vier aanstaande belangrijke infrastructuur: agile Coretime, on-demand parallel chain. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Snowbridge (brugtechnologie die Polkadot en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> verbindt) en <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a> Brug (technologie die Polkadot en zijn zusternetwerk <a href="/price/kusama-ksm" target="_blank" class="blog_inner_link">Kusama</a> verbindt). Daarnaast is er nog een vijfde aankomende technologie, namelijk elastische uitbreiding, die naar verwachting in 2024 zal worden geïmplementeerd.</p>
<p>Beïnvloed door gunstige factoren, volgens Gate.io marktgegevens, steeg DOT ooit boven de $9,5 mark, rechtstreeks naar $10, en wordt nu gerapporteerd op $9,38, met een stijging van 7,6% in 24 uur.</p>
<p>Met betrekking tot marktfluctuaties van andere populaire tokens waren de intraday winsten van ORDI en 1000SATS respectievelijk 44,77% en 41,58%. Volgens de marktgegevens van Gate.io doorbrak ORDI kortstondig $78 en wordt nu verhandeld tegen $76,12. 24-uurs toename van 44,77%; 1000SATS steeg ooit tot $ 0,000889 en wordt nu gerapporteerd op $ 0,0008717, een toename van 24 uur van 41,58%.</p>
<p>Volgens DeBank-gegevens houdt het Blast-contractadres van Blur-oprichter Pacman momenteel een totale activawaarde van meer dan $1 miljard aan, wat $1,03 miljard bereikt. Ongeveer $918 miljoen aan ETH werd gestort in het Lido-protocol, en er werd voor $107 miljoen aan activa gestort in het Maker-protocol.</p>
<p>Daarnaast heeft het netwerk TVL van Sui ook de $200 miljoen overschreden en een historisch hoogtepunt bereikt. Sinds september 2023 is het netwerk TVL met bijna 500% gegroeid.</p>
<p>Wat betreft NFT, Cryptoslam.io-gegevens tonen aan dat de NFT-transactievolume vorige week met 12,26% is afgenomen, met een totaal van $463,87 miljoen. Vorige week is het aantal NFT-kopers met 72,05% gestegen en het aantal verkopers met 56,61%.</p>
<p>Ondanks een daling van 13.71% ten opzichte van de vorige week, stonden NFT’s op de Bitcoin-keten nog steeds op de eerste plaats met een wekelijks handelsvolume van $265.61 miljoen, wat overeenkomt met 57.25% van alle NFT-transacties vorige week. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De on-chain NFT handelsvolume van Binance ($88,42 miljoen) steeg naar de tweede plaats, terwijl het on-chain NFT wekelijkse handelsvolume van Ethereum ($75,91 miljoen) naar de derde plaats daalde.</p>
<p>Onder de top tien belangrijkste NFT-series qua transactievolume in de afgelopen week kwamen er 9 van de Bitcoin-keten. De <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> NFT-serie Open Solmap staat op de vijfde plaats qua wekelijks transactievolume ($1,04 miljoen) op de keten.</p>
<p>Hoewel het handelsvolume is vertraagd, vertoont de tokenmarkt in de blockchain gamingsector een algemene opwaartse trend. Volgens marktgegevens is er sprake van een algemene opwaartse trend in blockchain gaming tokens, met AXS die een stijging van 30,31% in 24 uur heeft doorgemaakt en momenteel wordt aangeboden voor $10,5; MBOX heeft een stijging van 23,03% in 24 uur doorgemaakt en wordt momenteel genoteerd op $0,4; AGLD heeft een stijging van 19,44% in 24 uur doorgemaakt en wordt momenteel genoteerd op $1,446; de stijging van VOXEL in 24 uur bedraagt 13,32%, en de huidige notering is $0,2438; De stijging van SLP in 24 uur bedraagt 11,68%, en de huidige notering is $0,0035.</p>
<p>Vergeleken met de $33,3 miljard geïnvesteerd in 2022, is het durfkapitaal in crypto in 2023 met 68% gedaald naar $10,7 miljard. Desalniettemin overtreft de totale investering in 2023 nog steeds de vorige berenmarkt, waarbij de investering in 2019 en 2020 van $6,4 miljard wordt overschreden. Het merendeel van de investeringen vond plaats in de eerste helft van het jaar, met een lichte daling in de tweede helft, ondanks een toename van investeringen in november.</p>
<p>Het is vermeldenswaard dat het aandeel transacties toegewezen aan pre-seed, seed en A-ronde startups in 2023 is toegenomen, terwijl transacties in de middelste tot late stadia zijn afgenomen in vergelijking met het voorgaande jaar. Ondanks de economische vertraging in 2023 overtrof het totale investeringsbedrag voor het jaar nog steeds de vorige berenmarkt. Het investeringsbedrag van 2019 tot 2020 bedroeg $6.4 miljard.</p>
<p>Het aantal transacties van crypto-venturekapitaal is ook vertraagd in 2023. Er waren in dat jaar in totaal 1819 transacties, een daling van 32% ten opzichte van 2671 in 2022. Over het algemeen was het handelsvolume in 2023 hoger dan het maandelijkse handelsvolume in 2020 en benaderde het het handelsvolume in 2021. Uit de verdeling van investeringen in fasen blijkt dat de meeste fondsen zullen <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> om pre seed, seed en pre A-ronde startups te ondersteunen in 2023, terwijl de activiteit van mid- tot late-stage startups relatief laag is, wat overeenkomt met de trend in 2022.</p>
<h2 id="h2-Belangrijkste20trends20van20de20hoofdtokens20van20vandaag389435"><a name="Belangrijkste trends van de hoofdtokens van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends van de hoofdtokens van vandaag</h2><h3 id="h3-BTC672974"><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/1703574507BTC.png" alt=""><br>Vorige week sloot boven de $42.500, en vanochtend blijft het testen van de middelste kanaalas. Deze week wordt verwacht dat twee weerstandsniveaus getest zullen worden: $45.345 en $47.990. De steun blijft sterk op $40.280 en $38.399, wat duidt op een voortdurende hoog-niveau oscillatie op de middellange termijn.</p>
<h3 id="h3-ETH543361"><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/1703574525ETH.png" alt=""><br>Op korte termijn wordt een dalende driehoekstrend van vier uur waargenomen. Er wordt aandacht besteed aan de korte termijn hoge weerstand van $2.381. Een doorbraak kan leiden tot een opwaartse beweging richting $2.489 en $2.838. Als dit niet lukt, kan dit resulteren in een herstest van de ondersteuning op $2.135. Het langetermijnbeeld blijft bullish.</p>
<h3 id="h3-GT644716"><a name="GT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>GT</h3><p><img src="https://gimg2.gateimg.com/image/article/1703574542GT.png" alt=""><br>Het wekelijkse diagram geeft het begin aan van de tweede fase van een stierenmarkt. Korte termijn ondersteuning ligt bij de witte lijn, terwijl de lange termijn ondersteuning convergerend is rond $2.88. In afwachting van een vroege opwaartse beweging in de platformvalutasector zijn de streefprijzen ingesteld op $12.877, $18.977, $28.58 en $44.99. Langetermijn vasthouden wordt aanbevolen.</p>
<h2 id="h2-Macro20Kerstvakantie20markt20gesloten20hoe20te20investeren20in20een20portefeuille20in202024271830"><a name="Macro: Kerstvakantie markt gesloten, hoe te investeren in een portefeuille in 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Kerstvakantie markt gesloten, hoe te investeren in een portefeuille in 2024</h2><p>Op maandag waren de Amerikaanse dollarkoers, Amerikaanse obligaties, spot goud, spot zilver, WTI ruwe olie, Brent ruwe olie, Amerikaanse aandelen, Europese aandelen en Hong Kong aandelen gesloten vanwege de kerstvakantie.</p>
<p>Wat betreft renteverlagingen, volgens de laatste CME ‘Federal Reserve Observation’ op 26 december, is de waarschijnlijkheid dat de Federal Reserve de rentetarieven handhaaft in het bereik van 5,25% -5,50% in februari volgend jaar 83,5%, en de waarschijnlijkheid van een renteverlaging van 25 basispunten is 16,5%. De waarschijnlijkheid dat de rentetarieven in maart volgend jaar ongewijzigd blijven, is 6,7%, de waarschijnlijkheid van een cumulatieve renteverlaging van 25 basispunten is 78,1%, en de waarschijnlijkheid van een cumulatieve renteverlaging van 50 basispunten is 15,2%.</p>
<p>2023 loopt ten einde en we kijken uit naar 2024 als een jaar vol uitdagingen en kansen voor investeerders, met betrekking tot meerdere aspecten zoals de Amerikaanse economie, beleggingsmarkten en cryptocurrencies.</p>
<p>Laten we eerst eens kijken naar enkele suggesties van experts over hoe je je goed kunt voorbereiden op 2024, evenals hun visie op de aandelenmarkt, obligaties, cryptocurrencies en beleggingsportefeuilles.</p>
<p>Ten eerste, overweeg uw risiconiveau. Beleggers moeten onderzoeken hoeveel risico ze hebben genomen in hun beleggingsportefeuille, aangezien 2024 mogelijk te maken kan krijgen met enkele potentiële obstakels, waaronder een daling op de arbeidsmarkt, hoge rentetarieven en aanhoudende inflatie. Daarom is het verstandig om voorzichtig te zijn en in staat te zijn om een lage latentie te doorstaan.</p>
<p>Ten tweede, haast je niet om aandelen en obligaties te verkopen. Aandelen en obligaties zullen naar verwachting nog steeds aanzienlijke rendementen opleveren volgend jaar, en de verlaging van de rentetarieven van de Federal Reserve kan een opleving op de aandelenmarkt stimuleren.</p>
<p>Ten derde, laat de traditionele investeringsportefeuillestructuur van 60% aandelen en 40% obligaties niet los. Wanneer de rentetarieven hun piek bereiken of benaderen, kan het obligatiegedeelte van de investeringsportefeuille uiteindelijk goed presteren. Geef daarom deze portefeuille nu niet op, maar diversifieer door een mix van internationale aandelen, Amerikaanse schatkistobligaties en bedrijfsobligaties toe te voegen.</p>
<p>Bovendien moeten beleggers hun contante opties opnieuw beoordelen. Een hogere rente betekent dat beleggers aanzienlijke contante rendementen hebben ontvangen, maar als de Federal Reserve de rente verlaagt, kan de situatie veranderen. Daarom is het een suggestie om te overwegen Amerikaanse staatsobligaties met een looptijd van één tot drie jaar te kopen om het rendement vast te zetten.</p>
<p>Ten slotte, leg cryptocurrencies op voorhand vast. Het toevoegen van een klein deel van cryptocurrency aan een beleggingsportefeuille kan helpen bij diversificatie. Bitcoin heeft dit jaar een grootschalige stijging doorgemaakt, waarbij de prijs meer dan verdubbeld is. Bovendien kunnen Bitcoin Exchange Traded Funds (ETF’s) volgend jaar eindelijk worden uitgebracht, wat investeren in cryptocurrencies gemakkelijker zal maken.</p>
<p>Het jaar 2024 zit vol uitdagingen en kansen voor investeerders, en ze moeten voorzichtig zijn en verwijzen naar deskundig advies om hun eigen onderzoek te doen, om betere rationele investeringsbeslissingen te nemen.</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 visie 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 wettelijke stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>