TWFya3R0cmVuZCB8IEZCSSBiZWdpbnQgbWV0IGhldCBvbmRlcnpvZWtlbiB2YW4gZGUgZGF0YWxlayBiaWogM0NvbW1hczsgQ2hhcmxlcyBIb3NraW5zb24gb250aHVsdCBoZXQga29tZW5kZSBBREEtZXhwZXJpbWVudA==

2022-12-30, 09:07

<p><img src="https://gimg2.gateimg.com/image/article/1666334998%E4%B8%80%E5%91%A8%E8%A1%8C%E6%83%85.jpeg" alt=""></p>
<p>In een andere week van de ogenschijnlijk eindeloze berenmarkt zijn verschillende cryptocurrencies blijven afglijden in een spiraal van rode kaarsen als prijsdalingen marktbreed plaatsvinden. Met dalingen variërend van 1% tot meer dan 10% hebben veel van de top 100 activa de handelsvolume blijven verliezen, terwijl ze allemaal bearish sentimenten blijven opbouwen.</p>
<p>Echter, met deze week die enkele van de laatste dagen van 2022 markeert, zijn exploits en hacks steeds meer onderwerp van gesprek geworden nu de FBI begint op te treden tegen de 3Commas Data Breach. Toch is er een positiever discussie begonnen, aangezien de eerste NFT-verkopen van Kia een bewijs leveren van het real-world nut van blockchain, en aangezien de ontwikkeling van <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> aangeeft dat de toekomst van blockchain niet is belemmerd ondanks de bear market.</p>
<h2 id="h2-Het20laatste20nieuws612597"><a name="Het laatste nieuws" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het laatste nieuws</h2><h3 id="h3-FBI20begint20met20het20onderzoeken20van20de20gegevensinbreuk20bij203Commas699020"><a name="FBI begint met het onderzoeken van de gegevensinbreuk bij 3Commas" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FBI begint met het onderzoeken van de gegevensinbreuk bij 3Commas</h3><p>In een schokkende gegevensinbreuk eerder deze week lekte een anonieme partij een aanzienlijke 100.000 API-sleutels die verbonden waren met de cryptocurrency-handelsbeurs 3Commas. De in Estland gevestigde handelsservice is de afgelopen weken onder vuur komen te liggen vanwege beschuldigingen dat de CEO herhaaldelijk waarschuwingssignalen negeerde dat het platform gebruikersgegevens had gelekt. Deze zorgen bleken terecht te zijn, aangezien 100.000 Binance- en KuCoin-API-sleutels die aan het platform waren gekoppeld, werden blootgesteld, waarbij twee verschillende gebruikers zich tot CoinDesk wendden om te onthullen dat ze waren benaderd door FBI-agenten van het Cincinnati Field Office in verband met de gegevensinbreuk.</p>
<p>Historisch gezien is 3Commas tegengewerkt met problemen, aangezien verschillende gebruikers het afgelopen jaar naar voren zijn gekomen waarin staat dat hun geld via gekoppelde portefeuilles op externe beurzen is verhandeld. 3Commas heeft echter altijd volgehouden dat de gebruikers waarschijnlijk voornamelijk betrokken waren bij phishing-oplichting, in een poging om zorgen over de beveiliging van het platform te verlichten. Toch zijn deze beweringen weerlegd in het licht van de insinuatie van de leaker van de API-database dat de 3Commas-sleutels intern waren verkocht, ondanks dat de CEO, Yuriy Sorokin, benadrukte dat er ‘geen bewijs’ werd gevonden om de beweringen van de leaker te ondersteunen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672366951001.png" alt=""><br>FBI (Afbeelding met dank aan OCCRP)</p>
<h3 id="h3-Kias20NFTcollectie20dekt20de20kosten20van202200020dierenadopties546788"><a name="Kia’s NFT-collectie dekt de kosten van 22.000 dierenadopties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kia’s NFT-collectie dekt de kosten van 22.000 dierenadopties</h3><p>In samenwerking met NFT-ontwikkelingsbedrijf Sweet onthulde Kia eerder dit jaar hun eerste NFT-collectie voor het goede doel met als doel initiatieven te ondersteunen om de stress te verlichten die wordt veroorzaakt door overvolle dierenasielen in de VS. Met de collectie nu verkocht en de jaarlijkse gegevens vrijgegeven, is vastgelegd dat Kia in totaal $100.000 heeft opgehaald voor de non-profitorganisatie Petfinder Foundation door een overvloed aan op robots geïnspireerde puppy-NFT’s te veilen. Met Kia die de donatie aanvulde met nog eens $500.000, is gemeld dat hiermee nu de adoptiekosten zijn gedekt van meer dan 22.000 dieren die eerder in asielen verbleven.</p>
<p>Kia’s NFT-collectie is een van de vele grote instellingen en merken die meedoen aan de huidige hype rond NFT’s en NFT-projecten onthullen met als doel fondsen te genereren voor liefdadigheid.<br><img src="https://gimg2.gateimg.com/image/article/1672366993002.png" alt=""><br>Een van de collaboratieve NFT’s van KIA x Sweet (Afbeelding met dank aan de Medium-pagina van Sweet)</p>
<h3 id="h3-Charles20Hoskinson20onthult20aankomend20ADAexperiment961859"><a name="Charles Hoskinson onthult aankomend ADA-experiment" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Charles Hoskinson onthult aankomend ADA-experiment</h3><p>Cardano medeoprichter en CEO, Charles Hoskinson, heeft onthuld dat hij van plan is om een $1.000.000 ADA-experiment uit te voeren met de nieuwe Cardano-portemonnee, Lace, om de beveiliging te waarborgen. De Lace-portemonnee is gebouwd door de Cardano-ontwikkelaar Input Output Hong Kong (IOHK) en fungeert als een lichtgewicht multi-chain crypto-portemonnee die streeft naar het interconnecten en onboarden van alles, van zowel Web2 als Web3, in één enkele interface. In een recente YouTube-video merkte Hoskinson op de recente hack op bij het wachtwoordbeheerbedrijf, LastPass, nadat een ongeautoriseerde entiteit toegang had gekregen tot hun cloudgebaseerde opslagservice van derden, wat leidde tot het verkrijgen van ‘basisinformatie van klanten en gerelateerde metadata’.</p>
<p>Deze inbreuk heeft de zorgen over cyberbeveiliging verergerd en Hoskinson ertoe aangezet te verklaren dat het een ‘schande’ is dat programma’s voor Pretty Good Privacy (PGP)-versleuteling geen industriestandaard zijn. Als bewijs van de toewijding van Cardano aan beveiliging heeft Hoskinson verklaard dat wanneer de Lace wallet PGP-versleuteling van papieren wallets ondersteunt, hij ‘waarschijnlijk een miljoen dollar’ aan ADA zal nemen en het in een papieren wallet zal plaatsen die met PGP is versleuteld en het openbaar zal plaatsen op Twitter, zodat ‘jullie het kunnen proberen te breken’. Dit experiment, hoewel gedurfd, zou een cruciale stap voorwaarts kunnen zijn om de beveiliging van blockchain op een breder niveau te verbeteren, op voorwaarde dat pogingen tot breken niet succesvol zijn.<br><img src="https://gimg2.gateimg.com/image/article/1672367093003.png" alt=""><br>Charles Hoskinson (Afbeelding Courtesy of UToday)</p>
<h2 id="h2-Huidige20projecttrends282734"><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 zijn de meeste van de projecten die de afgelopen week het meest zijn gestegen, gebaseerd op anonieme P2P-transacties. In het licht van gegevensinbreuken en exploits is er duidelijk vraag naar anonieme, versleutelde transacties en gegevens als een middel om het risico van eerdergenoemde te beperken. Deze projecten hebben aanzienlijke waarderingen gezien van meer dan 95% en een grote toename in handelsvolume, waarschijnlijk omdat investeerders die betrokken willen blijven bij blockchain op zoek zijn naar alternatieve projecten en oplossingen om hun vertrouwen in te stellen.</p>
<h2 id="h2-De20huidige20BTCtrend881810"><a name="De huidige BTC-trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De huidige BTC-trend</h2><p>Naarmate beleggers begonnen te anticiperen op het potentieel van een ‘Santa Rally’ in de aanloop naar de feestdagen, die gehoopt werd het jaar positief af te sluiten, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, helaas kwam het tekort omdat de prijsstagnatie op de 22e plaatsvond. Met <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> beweegt zich in een nauwe horizontale range tussen $16,585 en $16,940 tussen de 22e en 25e, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> uiteindelijk bereikte een vlakke neerwaartse beweging in de dagelijkse kaars voordat het sloot op $16.830. Sindsdien, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> is verder gedaald, waarbij het gebied van $16.480 als lokale ondersteuning fungeert sinds gisteren. Echter, zoals <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a> is begonnen te bewegen boven de $16.800 zone, die in de vorige week werd vastgesteld als een weerstandsgebied, het zou kunnen aangeven dat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a> kan zich mogelijk geleidelijk richting herstel bewegen, vooral als het de weerstand van $17.000 in de komende weken doorbreekt. Toch kan deze mogelijkheid nog ver weg zijn, aangezien <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> blijft stagneren en beweegt zich op wekelijkse basis onder de 1% in een positieve of negatieve richting.</p>
<p>Aan de andere kant, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> MVRV (marktwaarde versus gerealiseerde waarde) is de afgelopen paar weken relatief horizontaal gebleven, maar deze week, ondanks eventuele prijsschommelingen, is de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> MVRV is consistent gebleven op 0,853. Aangezien de waarde onder de één blijft, geeft dit aan dat de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> de markt kan zich op een ‘mogelijk marktdieptepunt’ bevinden, wat aangeeft dat het innemen van een geleidelijke longpositie een gunstige tactiek kan zijn in het huidige marktklimaat, omdat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> wordt naar verluidt verhandeld onder zijn gerealiseerde waarde. Deze week is de MVRV echter gestegen boven die van de vorige week, wat suggereert dat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> kan geleidelijk terugkeren naar een gezond waarderingsgebied. Dit kan erop wijzen dat de huidige bearish spiraal <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> is misschien aan het aflopen, op voorwaarde dat deze minuut, maar opmerkelijk significant, momentum blijft.<br><img src="https://gimg2.gateimg.com/image/article/1672367235004.png" alt=""><br>Maandelijkse MVRV-gegevens voor BTC (gegevens met dank aan Blockchain.com)</p>
<h2 id="h2-De20staat20van20ETHgaskosten130450"><a name="De staat van ETH-gaskosten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De staat van ETH-gaskosten</h2><p>Op 29 december is er een kleine toename geweest in het totale gasverbruik in de afgelopen week in vergelijking met het voorgaande, waarbij het laagste cijfer op de 27e werd bereikt, met een totaal van 108.656.647.519. Het hoogste cijfer dat deze week werd bereikt, was op de 25e, met een totaal van 109.290.486.943, wat een toename is ten opzichte van de vorige week. Ondanks de toename lijkt het gasverbruik consistent te zijn met de huidige maandelijkse trends.</p>
<p>Als gevolg hiervan zijn de Ethereum-gasvergoedingen deze week opmerkelijk gestegen ten opzichte van vorige week. De lage gaslimieten bleven tussen 7-91 gwei, de gemiddelde limieten lagen tussen 7-93 gwei, en de hoge limieten lagen tussen 8-112 gwei – wat een enorme kloof in gasvergoedingen over 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 $206,569.06 of 172.20 ETH), <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> V3: Router 2 (met totale kosten van $162,216.90 of 135.23 ETH), en CoinTool: XEN Batch Minter (met totale kosten van $163,406.37 of 136.22 ETH).</p>
<p>De geschatte kosten van transacties via platforms zoals OpenSea: Verkoop, Uniswap V3: Ruil, en USDT: Overdracht, worden geschat op tussen de $0,84 en $3,32, volgens Etherscan.</p>
<h2 id="h2-De20huidige20macroeconomische20situatie43470"><a name="De huidige macro-economische situatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De huidige macro-economische situatie</h2><h3 id="h3-Ripple20vs20SEC20Zaak313006"><a name="Ripple vs SEC Zaak" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ripple vs SEC Zaak</h3><p>Na meer dan een jaar van de Ripple vs SEC-rechtszaak die de publieke en juridische perceptie van blockchain in het algemeen bezoedelde, heeft een historische beslissing van het Amerikaanse ministerie van Justitie mogelijk de weg vrijgemaakt voor Ripple om als overwinnaar uit de rechtszaak te komen. In een baanbrekende beslissing heeft Ripple mogelijk een voorsprong gekregen in de rechtszaak toen een officiële rechter van het Amerikaanse ministerie van Justitie, Analisa Torres, digitale valuta als handelswaar bestempelde. Op voorwaarde dat de advocaten van Ripple de verklaringen van rechter Torres citeren, zou dit op de lange termijn een pleidooi kunnen houden voor Ripple en mogelijk deze rechtszaak tot een einde kunnen brengen en een gevoel van duidelijkheid over de regelgeving kunnen creëren in de bredere markt.</p>
<h2 id="h2-Wat20zou20er20kunnen20komen20in20de20komende20week71602"><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>Op basis van de genoemde gegevens en het huidige algemene bearish sentiment op de markt, kan worden aangenomen dat de bearmarkt waarschijnlijk zal voortduren tot 2023. Toch groeit het positieve sentiment rondom het werkelijke nut van blockchain in de echte wereld, en Ripple nadert een overwinning tegen de SEC, en <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> De MVRV van ‘s begint te stijgen, wat kan bijdragen aan de heropleving van het vertrouwen van investeerders in de bredere cryptocurrency-markt, die ons naar 2023 zou kunnen leiden. Misschien zou Q1 van 2023 kunnen leiden tot een geleidelijk en duurzaam herstel van de cryptoicurrency-markt - maar alleen de tijd zal het leren.</p>
<div><br><div class="blog-details-info"><br><div>Auteur:<strong> Matthew Webster-Dowsing</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>