TWFya3R0cmVuZCB8IENoYXJsZXMgSG9za2luc29uIGtpamt0IG5hYXIgQ29pbkRlc2stYWFua29vcDsgRWVuIHZhbiBkZSBBdXN0cmFsaXNjaGUgJ0JpZyBGb3VyJy1iYW5rZW4gc2xhYXQgU3RhYmxlY29pbg==

2023-01-20, 05:48

<p><img src="https://gimg2.gateimg.com/image/article/1666334998%E4%B8%80%E5%91%A8%E8%A1%8C%E6%83%85.jpeg" alt=""><br>In weer een onmiskenbaar bullish week voor de cryptocurrency markt, zijn groene kaarsen verlicht over de top honderd, waardoor winsten tot 25% marktbreed zijn toegekend. Aangezien deze bullish momentum heeft geleid tot een aanzienlijke waarderingsstijging marktbreed, is de markt ook begroet met positief nieuws met betrekking tot adoptie.</p>
<p>Deze week werd onthuld dat National Australia Bank, een van de ‘Big Four’ banken in Australië, hun eigen stablecoin heeft onthuld die gekoppeld is aan de Australische dollar en klaar is voor consumenten- en institutioneel gebruik. Op vergelijkbare wijze heeft Charles Hoskinson, CEO van wat verkozen werd tot het ‘meest geliefde’ cryptoproject in de westerse wereld, Cardano, zijn plannen onthuld om mogelijk het blockchain-nieuwsplatform CoinDesk te kopen. Echter, in wellicht zorgwekkender nieuws, heeft de nieuwe CEO van FTX verklaard dat ze van plan zijn mogelijk de beurs nieuw leven in te blazen. Maar gezien de beruchtheid en controverses rond deze beurs, lijkt dit nieuws omgeven te zijn met angst en vrees naarmate de gevolgen van de ineenstorting zich voordoen.</p>
<h2 id="h2-Het20laatste20nieuws841271"><a name="Het laatste nieuws" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het laatste nieuws</h2><h3 id="h3-Charles20Hoskinson20overweegt20de20aankoop20van20CoinDesk193498"><a name="Charles Hoskinson overweegt de aankoop van CoinDesk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Charles Hoskinson overweegt de aankoop van CoinDesk</h3><p>Charles Hoskinson, de geprezen CEO van Cardano, onthulde in een recente live stream dat hij geïnteresseerd is in het overnemen van ‘s werelds grootste crypto nieuwsuitlaat, Coindesk. Nadat hij in het verleden had geklaagd over oneerlijke behandeling door de media, streeft Hoskinson ernaar om ‘journalistieke integriteit’ opnieuw in te voeren in blockchain nieuwsbronnen, waarbij hij aangeeft dat zijn interesse in media ‘breder’ is.</p>
<p>Eerder heeft Hoskinson gesuggereerd dat het mogelijk is om nieuwsartikelen om te zetten in niet-fungibele tokens (NFT’s), waardoor lezers kunnen communiceren met en eigenaar kunnen worden van een stuk nieuws en geschiedenis. Hoskinson beschouwt dit concept als ‘echt cool’ en gelooft dat het werkelijkheid maken van dit concept het mogelijk zou maken dat elk verhaal zijn eigen levende entiteit wordt. Als Hoskinson op een dag CoinDesk zou kunnen verwerven, zou dit concept heel goed werkelijkheid kunnen worden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1674193557001.png" alt="">Charles Hoskinson (Afbeelding met dank aan UToday)</p>
<h3 id="h3-Huidige20CEO20van20FTX20zegt20dat20hij20het20herstarten20van20de20beurs20aan20het20verkennen20is864595"><a name="Huidige CEO van FTX zegt dat hij ‘het herstarten van de beurs’ aan het verkennen is" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Huidige CEO van FTX zegt dat hij ‘het herstarten van de beurs’ aan het verkennen is</h3><p>Naar aanleiding van de ontbinding van 130 bedrijven die actief zijn onder de FTX-paraplu, trad John Ray op als CEO van de FTX cryptocurrency exchange om het faillissementsproces in gang te zetten. Het is echter naar voren gekomen dat Ray naar verluidt een taskforce heeft opgezet om de beurs te proberen te herstellen en FTX opnieuw op te starten. Volgens een rapport van de Wall Street Journal verklaarde Ray dat alles ‘bespreekbaar’ was met betrekking tot de toekomst van de beruchte beurs.</p>
<p>Na te hebben gemeld op 17 januari dat er $5,5 miljard aan liquide middelen in zijn onderzoeken waren, met nog eens $3 miljoen verschuldigd aan zijn top 50 schuldeisers, lijken de huidige financiën voor FTX ernstig - waardoor de vraag rijst: is het de moeite waard om de beurs opnieuw op te starten of zelfs haalbaar?</p>
<p><img src="https://gimg2.gateimg.com/image/article/1674193584002.png" alt=""><br>FTX-logo (Afbeelding met dank aan FTX Facebook)</p>
<h3 id="h3-En20van20de20vier20grote20Australische20banken20NAB20slaat20de20stabiele20munt20AUDN801110"><a name="Eén van de vier grote Australische banken, NAB, slaat de stabiele munt AUDN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Eén van de vier grote Australische banken, NAB, slaat de stabiele munt AUDN</h3><p>National Australia Bank (NAB) zal nu de tweede van de ‘Grote Vier’ banken van Australië worden die een Australische dollar-gekoppelde stablecoin (1:1 gedekt) op het Ethereum-netwerk lanceert. NAB heeft aangekondigd dat de lancering naar verwachting ergens in het midden van 2023 zal plaatsvinden. Het doel van deze stablecoin is het stroomlijnen van grensoverschrijdende overboekingen en de handel in koolstofkredieten.</p>
<p>De Chief Innovation Officer (CIO) van de NAB, Howard Silby, heeft verklaard dat de beslissing om de AUDN-stablecoin te slaan is gebaseerd op de overtuiging van de bank dat de blockchain-infrastructuur een cruciale rol kan spelen in de volgende grote evolutie van financiën. ‘We geloven dat er elementen van blockchaintechnologie zullen zijn die deel zullen uitmaken van de toekomst van financiën… vanuit ons oogpunt zien we [blockchain] het potentieel heeft om directe, transparante, inclusieve financiële resultaten te leveren,’ verklaarde Silby.<br><img src="https://gimg2.gateimg.com/image/article/1674193603004.png" alt=""><br>Logo van National Australia Bank (Afbeelding met dank aan Australia Chamber)</p>
<h2 id="h2-Huidige20projecttrends647256"><a name="Huidige projecttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Huidige projecttrends</h2><p>Op basis van gegevens verstrekt door CoinMarketCap, heeft een meerderheid van de topwinnende projecten in de afgelopen week zich gericht op het genereren van consistente waarde en volume via inflatoire tokenomics-structuren. Veel van deze projecten proberen problemen op te lossen zoals marketing en ontwikkeling die worden gedempt tijdens bear-markten. Als gevolg hiervan hebben sommige van deze projecten winsten gezien van meer dan 100% in 24 uur, evenals winsten van bijna 500% in de afgelopen week.</p>
<h2 id="h2-De20huidige20BTCtrend967971"><a name="De huidige BTC-trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De huidige BTC-trend</h2><p>Voortbouwend op het bullish momentum dat vorige week werd gezien, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> is blijven stijgen met een ongekend tempo, boven zijn 7-daagse SMA zwevend en consistent boven dit niveau blijvend. Na de week te zijn begonnen op $18,81k, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> steeg scherp op 14 januari, duwde het ruim boven de $20k drempel naar een gemiddelde van $20.8k. Dit gemiddelde verschoof snel naar een prijsvloer gedurende het midden van de week, met <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> testen van het $21k-gebied en af en toe tekortschieten, waardoor het terug wordt geduwd naar het bovenste $20.9k-gebied. Echter, op 18 januari, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Uiteindelijk door deze weerstandszone geduwd en landde op een wekelijks hoogtepunt van $ 21.501,44, voordat het een scherpe dip zag terug naar de prijsbodem, waarvan het zich heeft hersteld en nu net boven de drempel van $ 21k handelt. Na ruim boven wat naar verwachting de volgende belangrijke weerstandszone zou zijn, kan alleen worden vastgesteld dat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> zal nu $21.6k testen, waarbij dit optreedt als de nieuwe lokale weerstand.</p>
<p>Na deze positieve beweging, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> De MVRV (marktwaarde naar gerealiseerde waarde) is de afgelopen week aanzienlijk gestegen en is uiteindelijk boven de drempel van 1 gekomen. Bij het ingaan van de week op 0,954 was BTC’s MVRV de hoogste in enkele weken, en dit steeg vervolgens naar een hoogtepunt van 1,075 op de 17e. Dit geeft aan dat BTC eindelijk afstand heeft genomen van de ‘marktbodem’-indicatie en naar een stabieler gebied is gegaan, wat aangeeft dat het activum is geëvolueerd naar een meer realistische en volledig gerealiseerde waardering.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1674193628005.png" alt=""><br>Wekelijkse BTC MVRV-gegevens (gegevens met dank aan Blockchain.com)</p>
<h2 id="h2-De20staat20van20ETHgasvergoedingen774248"><a name="De staat van ETH-gasvergoedingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De staat van ETH-gasvergoedingen</h2><p>Vanaf 19 januari is er de afgelopen week een gematigde daling geweest van het totale gasvolume dat is gebruikt in vergelijking met de eerste, met het laagste cijfer op de 15e, in totaal 108.296.985.205. Het hoogste cijfer dat deze week werd bereikt, was op de 17e, met een totaal van 108.533.581.326, wat een vergelijkbaar totaal gebruik aantoont als tijdens de opening van 2023. Ondanks deze kleine verandering in de hoeveelheid gebruikt gas, lijkt de huidige hoeveelheid gebruikt gas in lijn te zijn met de huidige maandelijkse trends.</p>
<p>Als gevolg hiervan zijn de grenzen van de Ethereum-gaskosten deze week gematigd gestegen ten opzichte van de week ervoor. De lage gasgrenzen lagen tussen 11-117 gwei, de gemiddelde grenzen lagen tussen 11-339 gwei en de hoge grenzen lagen tussen 12-407 gwei - wat een enorm verschil in gaskosten in de afgelopen week aantoont.</p>
<p>In de afgelopen 24 uur waren de top ‘Gas Guzzlers’ volgens Etherscan Seaport 1.1 (met totale kosten van $346.604,82 of 222,84 ETH), Uniswap: Universal Router (met totale kosten van $255.898,99 of 164,52 ETH) en XEN Crypto: XENT Token (met totale kosten van $81.210,65 of 140,03 ETH) - wat een aanzienlijke stijging laat zien ten opzichte van de vorige week.</p>
<p>De geschatte kosten van transacties in onder meer OpenSea: Sale, <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> V3: Swap en USDT: Transfer zijn volgens Etherscan gesuggereerd tussen $ 1,29 en $ 4,59.</p>
<h2 id="h2-De20Huidige20Macro20Situatie259193"><a name="De Huidige Macro Situatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Huidige Macro Situatie</h2><h3 id="h3-Davos20202320werpt20licht20op20de20huidige20cryptomarkt901988"><a name="Davos 2023 werpt licht op de huidige cryptomarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Davos 2023 werpt licht op de huidige cryptomarkt</h3><p>Davos, de jaarlijkse bijeenkomst van het World Economic Forum, stelde leiders in de crypto-industrie en regelgevers in staat om licht te werpen op de huidige macro-situatie in crypto gedurende de afgelopen week. Met een meer ingetogen aanwezigheid dit jaar, was het aantal blockchainbedrijven dat aanwezig was afgenomen in vergelijking met voorgaande jaren, maar de likes van Casper Labs, de <a href="/price/filecoin-fil" target="_blank" class="blog_inner_link">Filecoin</a> Foundation en Circle leidden een reeks evenementen en bespraken onderwerpen als centrale bank digitale valuta (CBDC’s) en de ineenstorting van FTX. Naast de blockchainmoguls waren er ook vertegenwoordigers van de Verenigde Naties (VN) aanwezig, die het gebruik van blockchains binnen VN-afdelingen bevestigden (zoals Advit Nath van het Internationaal Fonds voor Landbouwontwikkeling die verklaarde dat ze blockchain gebruiken om gedoneerde fondsen op regionale basis te monitoren). Deze geleidelijke integratie van traditionele regelgevers en blockchainmoguls op zo’n groot forum is een teken van de groeiende samenwerking tussen beide en kan erop wijzen dat de toekomst van technologie en financiën ongetwijfeld blockchain als kern zal hebben.</p>
<h2 id="h2-Wat20zou20er20kunnen20komen20in20de20komende20week836662"><a name="Wat zou er kunnen komen in de komende week?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zou er kunnen komen in de komende week?</h2><p>Gezien de algemene bullishness op de markt en het positieve nieuws met betrekking tot adoptie en regulering, is het zeer waarschijnlijk dat de komende week dit momentum verder zal uitbreiden. Op deze manier zullen verschillende activa binnen de top honderd blijven winnen aan momentum en waardering regenereren, waardoor cryptocurrencies verder uit de loopgraven worden gehaald en op het strijdtoneel worden gebracht terwijl ze zich een weg banen naar hun voormalige glorie.</p>
<div class="blog-details-info"><br><div>Auteur: Gate.io Onderzoeker: <strong>Matthew Webster-Dowsing</strong><br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle andere glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>