Z2F0ZSBJbnN0aXR1dGlvbmVsZSBXZWtlbGlqa3NlIEluemljaHQgKERlYyAxOCwyMDIzKQ==

2023-12-22, 08:21

<h2 id="h2-Macro20Overzicht569389"><a name="Macro Overzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Overzicht</h2><p>Amerikaanse markt vestigt hoogtepunten als de Fed wijst op renteverlagingen; Inflatie <a href="/price/optimism-op" target="_blank" class="blog_inner_link">OptimIsm</a> Prevails: **The U.S. stock market reached record levels with the Dow, S&amp;P 500, and Nasdaq securing their longest winning streak since 2017. Small-caps surged, pulling the Russell 2000 Index out of bear market territory. Investor activity increased, favoring stocks with short interest, while the VIX hit a post-COVID low. Favorable inflation indicators and the Fed’s signal of substantial rate cuts in 2024 bolstered market confidence. Retail sales rose unexpectedly, but manufacturing showed weakness. Long-term Treasury yields dropped below 4%, while corporate bonds rallied after the Fed’s dovish stance.</p>
<p><strong>Renteverwachtingen en economische problemen in de Eurozone: een verhaal van marktdynamiek:</strong> De STOXX Europe 600 steeg met 0,92%, in afwachting van renteverlagingen in 2024 door belangrijke centrale banken. De CAC 40 van Frankrijk steeg; de DAX van Duitsland en de FTSE MIB van Italië daalden, terwijl de FTSE 100 van het VK met 0,29% steeg. De Europese Centrale Bank handhaafde haar stortingsrente van 4,0%, maar verlaagde de groei- en inflatieprognoses voor 2023 en 2024. De bedrijfsactiviteit in de Eurozone kromp, met een PMI van 47,0 in december. De Bank of England handhaafde haar referentierentevoet van 5,25%, klaar voor renteverhogingen als de inflatie aanhoudt. De economie van het VK kromp met 0,3% in oktober na een stijging van 0,2% in september. Norges Bank verhoogde de rente naar 4,5%, met het oog op stabiliteit tot eind 2024. De Zwitserse Nationale Bank handhaafde een rente van 1,75% en verlaagde de inflatievooruitzichten voor 2024 en 2025.</p>
<p><strong>Deflatieangst drukt op Chinese aandelen te midden van gemengde economische signalen:</strong> Chinese aandelen kregen te maken met dalingen nu deflatoire zorgen de economische situatie in beslag namen. De Shanghai Composite en de CSI 300 daalden, terwijl de Hang Seng Index in Hong Kong steeg te midden van een wereldwijde marktrally na de rentestand van de Fed. De consumentenprijsindex van China daalde met 0,5% in november, waarbij lagere varkensprijzen bijdroegen, terwijl de producentenprijsindex een daling van 3% op jaarbasis liet zien, wat zorgen baarde over een deflatoir cyclus. De economische gegevens van november lieten een gemengd beeld zien: de industriële productie overtrof de verwachtingen, de detailhandelsverkopen stegen maar misten de prognoses, en de investeringen in vaste activa bleven zwakker dan verwacht. Ondanks enkele positieve indicatoren bleven de zorgen bestaan, waardoor de People’s Bank of China geld in het banksysteem injecteerde en inspanningen bleef leveren om economische uitdagingen het hoofd te bieden. Analisten verwachten verdere beleidsondersteuning in 2024, aangezien de regering streeft naar het stimuleren van binnenlandse consumptie en investeringen, waarbij aanhoudende risico’s zoals zwak consumentenvertrouwen en een kwakkelende vastgoedsector zijn benoemd tijdens de Centrale Economische Werkconferentie.<br><img src="https://gimg2.gateimg.com/image/17032342931845989131.png" alt=""><br>DXY</p>
<p>DXY worstelt met instabiliteit en wiebelt boven 102,50 nadat het herstelde van een recent dieptepunt. Korte termijn Amerikaanse schatkistrendementen boden enige steun aan de Greenback, maar gemengde PMI-gegevens voor december creëerden onzekerheid. Terwijl de Services PMI groei aangaf, duidde de Manufacturing PMI op krimp. De focus ligt nu op Consumer Confidence en Existing Home Sales Change voor verdere aanwijzingen.</p>
<p>Gematigde opmerkingen van Fed-functionarissen, waaronder Raphael Bostic, president van de Atlanta Fed, die zinspeelt op een mogelijke renteverlaging in het derde kwartaal van 2024 en Austan Goolsbee, president van de Chicago Fed, die een renteverlaging tijdens de Fed-vergadering van maart niet afwijst, zouden in de komende sessies neerwaartse druk op de USD kunnen uitoefenen.<br><img src="https://gimg2.gateimg.com/image/17032343523237787642.png" alt=""><br>US10Y<br><img src="https://gimg2.gateimg.com/image/17032343934824315903.png" alt=""><br>US02Y<br><img src="https://gimg2.gateimg.com/image/17032343932672766304.png" alt=""><br>Het negatieve verschil tussen US10Y en US02Y</p>
<p>De Amerikaanse obligatierendement van 2 jaar verbeterde tot 4,48% op vrijdag, maar daalde tot 4,43% op het moment van schrijven op maandag. Het rendement van de Amerikaanse 10-jarige obligatie bedraagt 3,92%.</p>
<p><img src="https://gimg2.gateimg.com/image/17032344581778484755.png" alt=""><br>Goud</p>
<p>In de Aziatische sessie op maandag blijft goud stabiel in de buurt van $2.020 na een turbulente week die eindigde met een opmerkelijke terugtrekking op vrijdag. Naarmate de markt de pre-kerstfase ingaat, wacht de goudprijs op het cruciale Amerikaanse inflatierapport, dat het opnieuw ueren van verwachtingen rondom renteverlagingen van de Amerikaanse Federal Reserve voor het komende jaar zal beïnvloeden. Ondanks de terugtrekking van vrijdag van acht dagen hoogtepunten op $2.048, blijft de heersende koers voor goud neigen naar opwaartse momentum.</p>
<hr>
<h2 id="h2-Cryptomarkten20Overzicht921104"><a name="Cryptomarkten Overzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cryptomarkten Overzicht</h2><p><strong>1.Bitcoin</strong> <a href="/price/casper-network-cspr" rel="nofollow noopener noreferrer" target="_blank">Casper Network</a> <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Prijs<br><img src="https://gimg2.gateimg.com/image/17032345729559224657.png" alt=""><br>Bitcoin Dominantie</p>
<p>Bitcoin stabiliseert zich tussen $41.500 en $43.000 na herstel van de recente verkoop na de Amerikaanse CPI-gegevens. Inzichten van on-chain suggereren een verplaatsing van 5.000 BTC weg van beurzen en handelsportefeuilles tijdens het weekend, wat wijst op mogelijke investeerdersstrategieën. Technische indicatoren benadrukken cruciale weerstandsniveaus die BTC moet overwinnen voor een bullish momentum om kracht te herwinnen in de komende week.<br><img src="https://gimg2.gateimg.com/image/17032346551532866208.png" alt=""><br>Bitcoin-prijs versus DXY</p>
<p>In lijn met de negatieve correlatie tussen DXY en de Bitcoin-prijs, is DXY gestegen terwijl BTC de afgelopen week is gedaald.</p>
<p><strong>2.Ethethereum</strong></p>
<p><img src="https://gimg2.gateimg.com/image/17032347505209548689.png" alt=""><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Prijs</p>
<p>De ETH-prijs bleef rond het cruciale ondersteuningsniveau van $2.200 verhandeld worden. De prijs daalde hier en daar onder de $2.200, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> moet een aanhoudende sluiting onder de cruciale ondersteuningszone van $2.100 vermijden. Sinds vorige week tonen de bewegingen aanhoudende volatiliteit op de ETH-markt, met aanzienlijke risico’s en schommelingen op korte termijn.<br><img src="https://gimg2.gateimg.com/image/170323475019220267810.png" alt=""><br>Dagelijks ETHBTC<br><img src="https://gimg2.gateimg.com/image/170323486823007823311.png" alt=""><br>Wekelijks ETHBTC</p>
<p>De dagelijkse ETHBTC-verhouding bleef worden verhandeld binnen het bereik van 0,053-0,055.</p>
<p><strong>3. Totale marktkapitalisatie</strong><img src="https://gimg2.gateimg.com/image/170323486874256613912.png" alt=""><br>Totale marktkapitalisatie van crypto<br>Deze week bleef de wereldwijde cryptomarktkapitalisatie rond de 1,51 biljoen dollar verhandeld, een daling van -1,3% ten opzichte van vorige week.</p>
<p><strong>4. Stablecoin-stromen</strong><img src="https://gimg2.gateimg.com/image/170323502575357604513.png" alt=""><br>Totale marktkapitalisatie van stabiele munten, Bron: Defillama<br><img src="https://gimg2.gateimg.com/image/170323502575357604513.png" alt=""><br>Marktkapitalisatie van belangrijke stablecoins, bron: Defillama</p>
<p>Over de afgelopen week heeft de marktkapitalisatie van USDT opnieuw een grotere stijging gezien in vergelijking met de afgelopen maanden, en de marktkapitalisatie van USDC kende een kleine daling en vervolgens een stijging. De gecombineerde marktkapitalisatie van Stablecoins ligt nu rond het niveau van $129.5b, vergelijkbaar met het niveau van vorige week.</p>
<p><strong>5. Prestaties van top 30 crypto-activa</strong><img src="https://gimg2.gateimg.com/image/17032351029641947815.png" alt=""><br>Bron: Coingecko en Gate Ventures, per 18 december 2023</p>
<p>In de afgelopen 7 dagen hebben de top 30 crypto-activa enkele prijsstijgingen ervaren. BDe prijs van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> is met -2.8% gedaald en Ethereum is met -3.0% gedaald. ICP staat bovenaan de lijst met een groei van 82.9%, wat voortkomt uit zijn Internet CompGate $ICP initiatief airdrops.</p>
<p><strong>De Belangrijkste Crypto-Highlights</strong></p>
<p><strong>1. Highlights</strong></p>
<p>1) Solinions: Een revolutionaire aanpak voor Solana’s Digitale Artefacten</p>
<p>Solinions duiden op een significante afwijking in het rijk van digitale artefactcreatie en -deling, specifiek ontworpen voor de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> blockchain. Deze innovatieve Solinions herdefiniëren het landschap van digitale artefacten op <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> door gebruik te maken van de unieke functie die bekend staat als de ‘memo’, in tegenstelling tot zijn Ethereum-tegenhanger, Ethions.</p>
<p>Solinions functioneren als een open-source implementatie van een protocol dat gebruik maakt van de kracht van de Solana memo. Deze baanbrekende ontwikkeling toont de evolutie van het Solana digitale ecosysteem.</p>
<p>Solinions functioneren als een kostenbesparend protocol, waardoor informatie delen en berekeningen op Solana Layer 1 mogelijk zijn. Ze wijken af van conventionele slimme contracten en gecentraliseerde Layer 2-oplossingen en bieden een budgetvriendelijk alternatief. Door gebruik te maken van de Solana memo, omzeilen Solinions de noodzaak van opslag en uitvoering van slimme contracten en voeren ze wijzigingen in de staat uit via deterministische protocolregels. Dit benadrukt de efficiëntie en unieke mogelijkheden die inherent zijn aan Solana’s memo-functie.</p>
<p>In de kern zijn Solinions gericht op het democratiseren van gedecentraliseerde berekeningen, waardoor blockchain-activiteiten toegankelijk worden voor dagelijkse gebruikers tegen een betaalbare prijs.</p>
<p>Tegenwoordig dienen Solinions als een economisch alternatief voor Non-Fungible Tokens (NFT’s) binnen het Solana-ecosysteem. Vooruitkijkend streven ze ernaar om een kosteneffectief alternatief te worden voor traditionele Solana slimme contracten, waardoor er meer mogelijkheden ontstaan voor gebruikers die het Solana-blockchainlandschap verkennen.</p>
<p>2) OpenChat start gezichtsherkenning authenticatie voor menselijke validatie</p>
<p>OpenChat, een gedecentraliseerde chatapplicatie die gebruikmaakt van Dfinity’s <a href="/price/internet-computer-icp" rel="nofollow noopener noreferrer" target="_blank">Internet Computer</a> blockchain en met meer dan 100.000 gebruikers, is van plan om een gezichtsauthenticatiesysteem te testen om de menselijkheid van gebruikers te valideren, meldt The Block. Het platform streeft ernaar om meer ethische conversaties te bevorderen door gebruikers te verplichten hun enkele menselijke identiteit te bevestigen, met als doel frauduleuze activiteiten te beperken en de deugdzame discussie op apps te bevorderen.</p>
<p>Terwijl het verifiëren van menselijkheid eenvoudig blijft, vormt het bevestigen van unieke menselijke identiteiten een grotere complexiteit en zou het praktijken zoals token farming of airdrops via meerdere accounts kunnen ontmoedigen.</p>
<p>In deze eerste fase zal OpenChat het verificatieproces niet universeel afdwingen, maar toekomstige iteraties kunnen een andere benadering aannemen. In plaats van conventionele e-mailadressen en gebruikersnamen maakt het platform gebruik van crypto-adressen en NFT’s voor authenticatie en stimuleert het betrokkenheid.</p>
<p>Dit initiatief volgt op de samenwerking van OpenChat met Modclub, een gedecentraliseerde inhoudsmatigingsservice. De samenwerking verschuift de verantwoordelijkheid voor moderatie van chatgroepen van groepsleiders naar moderators van Modclub, die cryptocurrency als compensatie ontvangen. Dit benadrukt een verschuiving naar door de gemeenschap gestuurde governance en gedecentraliseerd toezicht op de inhoud.</p>
<p>3) <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> Labs’ Shift: Van <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> Edge naar ZK-Powered <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> CDK</p>
<p>Polygon Labs, cruciaal in de schaalnetwerken van Ethereum, is overgestapt van ‘Polygon Edge’ naar ‘Polygon CDK’, een blockchain-ontwikkelingskit die gebruik maakt van zero-knowledge cryptografie. Deze stap duidt op het stopzetten van de ondersteuning voor Polygon Edge, dat eerder werd gebruikt door Dogechain in een niet-officiële poging om een DDogecoin-gecentreerd smart contractnetwerk.</p>
<p>Terwijl Dogechain Polygon Edge wilde gebruiken voor <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> Deze inspanning ontbrak officiële ondersteuning van het Dogecoin-project. Polygon Labs heeft nu bijdragen aan Polygon Edge gestaakt en hun steun verlegd naar Polygon CDK. De ontwikkelaar benadrukt de rol van CDK bij het creëren van layer-2 blockchains met gebruik van zero-knowledge cryptografie, een technologie die steeds meer gebruikt wordt in crypto-projecten.</p>
<p>In een blogpost onthulde Polygon Labs hun strategische verschuiving, waarbij de vooruitgang binnen het Polygon-ecosysteem werd benadrukt. Deze overgang benadrukt hun focus op de Polygon CDK, een raamwerk waarmee ontwikkelaars layer-2-netwerken kunnen bouwen die zijn gemodelleerd naar zero-knowledge-technologie, een cruciale stap die hun verschuiving weg van Polygon Edge aangeeft.</p>
<p><strong>2. Belangrijke Venture Deals</strong><br>1) Bitcoin-protocol, bitSmiley, raised from OKX and ABCDE</p>
<p>bitSmiley, dat het potentieel van Bitcoin bevordert, start een nieuwe ronde met alpha-investeringen onder leiding van OKX Ventures en ABCDE Labs. De samenwerking heeft tot doel de missie van BTC te versterken door bitSmiley uit te breiden, een protocol dat gedijt binnen de Bitcoin blockchain. bitSmiley is een pionier op het gebied van een gedecentraliseerde Stablecoin, trustloze leningen en derivaten binnen het Fintegra-raamwerk. Het vlaggenschipproduct, bitUSD, staat voor stabiliteit en transparantie binnen de Bitcoin blockchain. bitLending voor peer-to-peer leningen en een segment voor Credit Default Swaps (CDS) verrijken verder het Bitcoin DeFi-landschap.</p>
<p>2) Farcana, een op pc gebaseerd arena-schietspel, haalde $ 10 miljoen op bij Animoca, Polygon, enz.</p>
<p>Farcana, de PC-arena shooter die een Web3-economie integreert, heeft $10 miljoen aan seedfinanciering veiliggesteld van Animoca Brands, Polygon Ventures en anderen. Farcana Studio, gevestigd in de VAE, introduceert een op teamgebaseerde shooter die de nadruk legt op strategische gameplay en een Bitcoin-prijssysteem. Ontwikkeld op Unreal Engine 5, biedt het innovatieve functies zoals ‘Free Mint’ Bitcoin-ordinaals binnen AAA Web3-gaming. Competitieve toernooien, een battle royale die zich afspeelt op Mars, en een deflatoir Play-to-Hash-model maken deel uit van de meeslepende ervaring van Farcana.</p>
<p>3) Andalusia Labs heeft $48 miljoen opgehaald bij Lightspeed, Mubadala, etc.</p>
<p>Andalusia Labs (voorheen Risk Harbor), een aanbieder van risicobeheer voor digitale activa, haalt $48 mln op in Serie A, geleid door Lightspeed, met Mubadala Capital en andere grote investeerders. Met oplossingen zoals de Karak-laag-2 blockchain en de Subsea crypto risicobeheer marktplaats, streeft Andalusia Labs ernaar om beveiligingsnormen vast te stellen en blockchain te integreren in wereldwijde financiële diensten.</p>
<p>4) LINE NEXT heeft $140 miljoen veiliggesteld onder leiding van private equity bedrijf Crescendo<br>LINE NEXT (DOSI), een wereldwijd NFT-platform, heeft $140 miljoen veiliggesteld onder leiding van Crescendo Equity Partners. DOSI streeft ernaar om <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> en bestaande webfuncties met elkaar te verbinden. Met gebruikersvriendelijke betaalmethoden en unieke PFP NFT’s doen DOSI-burgers mee aan een op NFT’s gebaseerd lidmaatschapsprogramma, wat een levendig ecosysteem voor makers en bedrijven over de hele wereld bevordert.</p>
<p>Het aantal afgesloten transacties in de vorige week was 33, waarbij Infra de weg leidde met 18 transacties, wat 55% van het totale aantal transacties vertegenwoordigt. De sector met het minste aantal transacties is GameFi met 3 gefinancierde transacties, wat 9% van het totale aantal transacties van vorige week vertegenwoordigt.<br><img src="https://gimg2.gateimg.com/image/170323520623949276016.png" alt=""><br>Wekelijkse Venture Deal Samenvatting, Bron: Cryptorank en Gate Ventures, vanaf 18 december 2023</p>
<p>Het totale bedrag aan financiering dat in de afgelopen week is opgehaald, bedroeg $314.2m, waarbij de sociale sector voorop liep met $141.3m, wat 45% van de totale financiering vertegenwoordigt. De sector met de minste financiering in de afgelopen week was DeFi met respectievelijk $7.3m opgehaald, wat 2% van de totale financiering van vorige week vertegenwoordigt.<br><img src="https://gimg2.gateimg.com/image/170323523550363707817.png" alt=""><br>Wekelijks Venture Deal Overzicht, Bron: Cryptorank en Gate Ventures, per 18 december 2023</p>
<p>Hoewel de financieringswaarden sinds augustus aanzienlijk zijn gedaald als gevolg van verschillende belangrijke macro-evenementen, is er sinds eind november weer een positieve momentum ontstaan. De totale wekelijkse financieringswaarde is gestegen naar $305,9 miljoen voor de eerste drie weken in december.</p>
<p>Tot volgende week!</p>
<div class="blog-details-info"><br><div>Auteur: Gate Venture<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div class="info-tips"><em></em>Geen enkele inhoud hierin vormt beleggingsadvies en vormt geen enkel aanbod of verzoek tot aanbod of aanbeveling van een beleggingsproduct of project.<br><div class="info-tips"><em>De opname van producten, diensten, entiteiten of inhoud van derden impliceert geen goedkeuring, aanbeveling of affiliatie door Gate.io. Voer grondig onderzoek uit en raadpleeg professioneel advies voordat u investeringsbeslissingen neemt.<br></em><div class="info-tips"><em></em>Gate.io behoudt alle rechten op dit artikel. Herplaatsing van het artikel is toegestaan ​​mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<p></p><br><br><p></p></div><p></p><br></div></div></div></div></div>