VGVuZGVuemEgZGkgbWVyY2F0b++9nEZCSSBpbml6aWEgYSBpbmRhZ2FyZSBzdWxsYSB2aW9sYXppb25lIGRlaSBkYXRpIGRpIDNDb21tYXM7IENoYXJsZXMgSG9za2luc29uIHJpdmVsYSBsJ2ltbWluZW50ZSBlc3BlcmltZW50byBBREE=

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 un’altra settimana del mercato orso apparentemente senza fine, diverse criptovalute hanno continuato a scivolare in una spirale di candele rosse mentre i declini dei prezzi si verificano in tutto il mercato. Con declini che vanno dall’1% al 10% e oltre, molti dei primi 100 asset hanno continuato a perdere volume di scambio, accumulando sentimenti negativi.</p>
<p>Tuttavia, con questa settimana che segna alcuni degli ultimi giorni del 2022, gli exploits e gli hacks sono diventati sempre più attuali poiché l’FBI inizia a combattere la violazione dei dati di 3Commas. Tuttavia, una discussione più positiva è iniziata poiché le prime vendite della collezione NFT di Kia hanno fornito una testimonianza dell’utilità del mondo reale della blockchain e lo sviluppo di <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> ha segnalato che il futuro della blockchain non è riuscito ad essere ostacolato nonostante il mercato ribassista.</p>
<h2 id="h2-Ultime20notizie243656"><a name="Ultime notizie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultime notizie</h2><h3 id="h3-LFBI20inizia20a20indagare20sulla20violazione20dei20dati20di203Commas194671"><a name="L’FBI inizia a indagare sulla violazione dei dati di 3Commas" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’FBI inizia a indagare sulla violazione dei dati di 3Commas</h3><p>In una scioccante violazione dei dati avvenuta all’inizio di questa settimana, una parte anonima ha divulgato un consistente numero di 100.000 chiavi API connesse allo scambio di criptovalute 3Commas. Il servizio di trading con sede in Estonia è stato criticato nelle ultime settimane a seguito di accuse secondo cui il CEO ha ripetutamente ignorato i segnali di allarme che la piattaforma aveva divulgato i dati degli utenti. Queste preoccupazioni si sono rivelate vere, poiché sono state esposte 100.000 chiavi API di Binance e <a href="/price/kucoin-kcs" target="_blank" class="blog_inner_link">KuCoin</a> collegate alla piattaforma, portando due utenti diversi a contattare CoinDesk per rivelare di essere stati contattati dagli agenti dell’FBI dell’ufficio di Cincinnati in relazione alla violazione dei dati.</p>
<p>Storicamente, 3Commas è stato ostacolato da problemi, poiché diversi utenti sono emersi nel corso dell’ultimo anno affermando che i loro fondi erano stati scambiati tramite portafogli collegati su scambi esterni. Tuttavia, 3Commas ha sempre insistito sul fatto che gli utenti erano probabilmente coinvolti in truffe di phishing, cercando di alleviare le preoccupazioni riguardanti la sicurezza della piattaforma. Tuttavia, queste affermazioni sono state smentite alla luce del leaker del database API che insinua che le chiavi 3Commas erano state vendute internamente, nonostante il CEO in carica, Yuriy Sorokin, abbia sottolineato che ‘nessuna prova’ è stata trovata a supporto delle affermazioni fatte dal leaker.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672366951001.png" alt=""><br>FBI (Immagine cortesia di OCCRP)</p>
<h3 id="h3-La20collezione20NFT20di20Kia20copre20i20costi20di20adozione20di202200020animali581682"><a name="La collezione NFT di Kia copre i costi di adozione di 22.000 animali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La collezione NFT di Kia copre i costi di adozione di 22.000 animali</h3><p>In collaborazione con la società di sviluppo NFT, Sweet, Kia ha presentato la sua prima collezione NFT a scopo benefico all’inizio di quest’anno con l’intenzione di sostenere iniziative per alleviare le pressioni sui canili sovraffollati negli Stati Uniti. Con la collezione ora venduta e i dati annuali pubblicati, è stato registrato che Kia ha raccolto un totale di $100.000 per la Petfinder Foundation, organizzazione non-profit, mettendo all’asta una serie di NFT a tema cucciolo robotico. Con Kia che ha aggiunto una donazione ulteriore di $500.000, si è appreso che questo ha coperto i costi di adozione di oltre 22.000 animali precedentemente residenti nei canili.</p>
<p>La collezione di NFT di Kia è una delle tante istituzioni e marchi di grande nome che si stanno unendo all’attuale hype intorno agli NFT e svelando progetti NFT con l’intento di generare fondi per beneficenza.<br><img src="https://gimg2.gateimg.com/image/article/1672366993002.png" alt=""><br>Uno degli NFT collaborativi di KIA x Sweet (Immagine per gentile concessione di Sweet’s Medium Page)</p>
<h3 id="h3-Charles20Hoskinson20Rivela20Prossimo20Esperimento20ADA58187"><a name="Charles Hoskinson Rivela Prossimo Esperimento ADA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Charles Hoskinson Rivela Prossimo Esperimento ADA</h3><p>Il co-fondatore e CEO di Cardano, Charles Hoskinson, ha rivelato di avere l’intenzione di condurre un esperimento ADA del valore di $1,000,000 con il nuovo portafoglio Cardano, Lace, per garantirne la sicurezza. Il portafoglio Lace è stato sviluppato da Input Output Hong Kong (IOHK), sviluppatore di Cardano, ed è un portafoglio criptato multi-chain leggero che mira a interconnettere e integrare tutto, sia da Web2 che da Web3, in un’interfaccia singola. In un recente video su YouTube, Hoskinson ha commentato l’hack recente della società di gestione delle password, LastPass, dopo che un’entità non autorizzata ha ottenuto accesso al loro servizio di archiviazione basato su cloud di terze parti, che ha portato all’ottenimento di ‘informazioni di base sui clienti e metadati correlati’.</p>
<p>Questa violazione ha aggravato le preoccupazioni per la sicurezza informatica e ha portato Hoskinson a dichiarare che è una ‘vergogna’ che i programmi di crittografia Pretty Good Privacy (PGP) non siano uno standard industriale. In segno della dedizione di Cardano alla sicurezza, Hoskinson ha dichiarato che quando il portafoglio Lace inizierà a supportare la crittografia PGP dei portafogli di carta, metterà ‘probabilmente un milione di dollari’ di ADA in un portafoglio di carta crittografato con PGP e lo renderà pubblico su Twitter in modo che ‘potete provare a violarlo’. Questo esperimento, sebbene audace, potrebbe dimostrarsi una pietra miliare vitale per migliorare la sicurezza del blockchain su una scala più ampia, a condizione che i tentativi di violazione siano infruttuosi.<br><img src="https://gimg2.gateimg.com/image/article/1672367093003.png" alt=""><br>Charles Hoskinson (Immagine Cortesia di UToday)</p>
<h2 id="h2-Tendenze20attuali20del20progetto933748"><a name="Tendenze attuali del progetto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze attuali del progetto</h2><p>Sulla base dei dati forniti da CoinMarketCap, la maggior parte dei progetti che hanno guadagnato di più nella scorsa settimana si basano su transazioni anonime P2P. Alla luce delle violazioni dei dati e degli attacchi informatici, c’è stata una evidente richiesta di transazioni anonime e crittografate e di dati come mezzo per attenuare il rischio di quanto sopra menzionato. Questi progetti hanno registrato consistenti guadagni di valutazione superiori al 95% e un vasto aumento del volume di scambi, probabilmente perché gli investitori dedicati a rimanere coinvolti nella blockchain cercano progetti e soluzioni alternative in cui riporre la loro fiducia.</p>
<h2 id="h2-Lattuale20trend20del20BTC521243"><a name="L’attuale trend del BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’attuale trend del BTC</h2><p>Mentre gli investitori iniziarono a prevedere il potenziale di un ‘Santa Rally’ in vista delle vacanze, con la speranza di chiudere l’anno con una nota positiva, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Purtroppo, non è riuscito a raggiungere l’obiettivo poiché si è verificata una stagnazione dei prezzi il 22. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> muovendosi in un range orizzontale stretto tra $16.585 e $16.940 tra il 22 e il 25 <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Alla fine ha raggiunto un’oscillazione piatta al ribasso nella candela giornaliera prima di chiudere a $ 16.830. Da allora <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> ha continuato a scendere ulteriormente, con la regione di $16,480 che funge da supporto locale fino a ieri. Tuttavia, come <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> ha iniziato a salire sopra la zona di $16,800, che è stata identificata come un’area di resistenza nella settimana precedente, potrebbe segnalare che <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> potrebbe essere progressivamente in via di recupero, in particolare se avanza oltre la resistenza di $17,000 nelle prossime settimane. Tuttavia, questa possibilità potrebbe essere lontana, poiché <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> continua a stagnare e a muoversi al di sotto dell’1% in direzione positiva o negativa su base settimanale.</p>
<p>D’altra parte, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> L’MVRV (valore di mercato rispetto al valore realizzato) è rimasto relativamente orizzontale nelle ultime settimane, ma questa settimana, nonostante le fluttuazioni di prezzo, il <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> MVRV è rimasto costante a 0,853. Considerando che il valore rimane al di sotto di uno, ciò indica che il <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> il mercato potrebbe trovarsi in un ‘possibile minimo di mercato’, indicando che assumere gradualmente una posizione lunga potrebbe essere una tattica vantaggiosa nel clima attuale del mercato, poiché <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Si dice che stia scambiando al di sotto del suo valore reale. Tuttavia, l’MVRV di questa settimana è salito sopra quello della settimana precedente, suggerendo che <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> potrebbe gradualmente tornare verso un territorio di valutazione sano. Questo potrebbe segnalare che la spirale ribassista attuale <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> sta forse per giungere al termine, a condizione che questo minuto, ma notevolmente significativo, impulso continui.<br><img src="https://gimg2.gateimg.com/image/article/1672367235004.png" alt=""><br>Dati MVRV mensili per BTC (Dati forniti da Blockchain.com)</p>
<h2 id="h2-Lo20Stato20Delle20Gas20Fee20di20ETH534534"><a name="Lo Stato Delle Gas Fee di ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lo Stato Delle Gas Fee di ETH</h2><p>Al 29 dicembre c’è stato un piccolo aumento del gas totale utilizzato durante l’ultima settimana rispetto a quello precedente, con la cifra più bassa raggiunta il 27, per un totale di 108.656.647.519. La cifra più alta raggiunta questa settimana è stata il 25, per un totale di 109.290.486.943, che rappresenta un aumento rispetto alla settimana precedente. Tuttavia, nonostante l’aumento, l’uso del gas sembra essere in linea con le tendenze attuali mese dopo mese.</p>
<p>Di conseguenza, i limiti delle commissioni di gas di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> questa settimana hanno registrato un notevole aumento rispetto alla settimana precedente. I limiti bassi del gas sono rimasti compresi tra 7-91 gwei, i limiti medi si attestavano tra 7-93 gwei e i limiti alti erano compresi tra 8-112 gwei, dimostrando una grande disparità nelle commissioni di gas durante la scorsa settimana.</p>
<p>Nelle ultime 24 ore, i principali ‘Gas Guzzlers’ secondo Etherscan sono stati Seaport 1.1 (con commissioni totali di $206,569.06 o 172.20 ETH), <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> V3: Router 2 (con commissioni totali di $162,216.90 o 135.23 ETH) e CoinTool: XEN Batch Minter (con commissioni totali di $163,406.37 o 136.22 ETH).</p>
<p>Il costo stimato delle transazioni su piattaforme come OpenSea: Vendita, Uniswap V3: Scambio e USDT: Trasferimento è stato suggerito essere compreso tra $0.84 e $3.32, secondo Etherscan.</p>
<h2 id="h2-La20situazione20macro20attuale472595"><a name="La situazione macro attuale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La situazione macro attuale</h2><h3 id="h3-Caso20Ripple20vs20SEC568746"><a name="Caso Ripple vs SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Caso Ripple vs SEC</h3><p>Dopo oltre un anno di controversie tra Ripple e la SEC che hanno danneggiato l’immagine della blockchain, una decisione storica del Dipartimento di Giustizia degli Stati Uniti potrebbe aprire la strada alla vittoria di Ripple nella causa legale. In una decisione innovativa, Ripple potrebbe aver ottenuto un vantaggio nella causa, poiché una giudice ufficiale del Dipartimento di Giustizia degli Stati Uniti, Analisa Torres, ha classificato le valute digitali come beni. Se gli avvocati di Ripple citano le dichiarazioni della giudice Torres, potrebbe esserci una possibilità di successo a lungo termine per Ripple e potrebbe porre fine a questa causa, fornendo una chiara regolamentazione per il mercato più ampio.</p>
<h2 id="h2-Cosa20potrebbe20arrivare20nella20settimana20a20venire524375"><a name="Cosa potrebbe arrivare nella settimana a venire?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa potrebbe arrivare nella settimana a venire?</h2><p>Sulla base dei suddetti dati e dell’attuale sentimento ribassista generale del mercato, si può presumere che il mercato ribassista continuerà probabilmente fino al 2023. Tuttavia, il crescente sentimento positivo che circonda l’utilità reale del blockchain, Ripple che si avvicina a una vittoria contro la SEC e <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>‘s MVRV iniziando ad aumentare, potrebbe contribuire alla rivitalizzazione della fiducia degli investitori nel mercato più ampio delle criptovalute, portandoci nel 2023. Forse il primo trimestre del 2023 potrebbe portare al recupero graduale e sostenibile del mercato delle criptovalute - ma solo il tempo dirà.</p>
<div><br><div class="blog-details-info"><br><div>Autore: <strong>Matthew Webster-Dowsing</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>