VGV0aGVyIGltcGVnbmEgJCA1MDAgTSBwZXIgaWwgbWluaW5nIGRpIEJpdGNvaW4=

2023-11-29, 02:14

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR134719"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> intende investire in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> mining, mirando a raggiungere almeno l’1% del trimestre di mining.</p>
<p>L’emittente di stablecoin (Tether) stabilirà le sue strutture di mining in Uruguay, Paraguay e El Salvador.</p>
<p>Aumento della difficoltà di mining e calo <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo di Bitcoin</a> sono alcune delle sfide chiave che <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> potrebbe affrontare dopo l’halving di Bitcoin.</p>
<h2 id="h2-Introduzione549221"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La nuova tendenza nello spazio delle criptovalute riguarda la diversificazione dell’offerta di prodotti e l’innovazione nella strategia aziendale. Le aziende cripto che hanno portafogli aziendali diversificati, prodotti di alta qualità e offrono servizi di assistenza clienti competitivi si comportano bene nel settore.</p>
<p>Abbiamo visto aziende come PayPal, Grayscale e BlackRock che introducono prodotti cripto come derivati. Sfruttano i vantaggi della blockchain e entrano in nuovi territori commerciali.</p>
<p>Tether Labs, il fornitore di Tether USD (USDT), è un esempio di azienda cripto che sta diversificando i suoi prodotti. In questo post verrà trattato l’investimento pianificato di Tether di $500 milioni in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> mining. Inoltre, esamineremo alcune delle principali sfide che l’azienda dovrà affrontare dopo l’evento di dimezzamento del bitcoin del 2024.</p>
<h2 id="h2-Strategia20di20mining20di20Bitcoin20di20Tether860737"><a name="Strategia di mining di Bitcoin di Tether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Strategia di mining di Bitcoin di Tether</h2><p>Tether ha stabilito una roadmap per diventare una delle principali società minerarie di bitcoin poiché punta a investire più di $500 milioni nel settore. In un’intervista con Bloomberg, <a href="https://www.bnnbloomberg.ca/biggest-stablecoin-issuer-tether-now-wants-to-become-a-major-bitcoin-miner-1.1999526" rel="nofollow noopener noreferrer" target="_blank">Paolo Ardoino, CEO di Tether, ha detto</a> che nei prossimi 6 mesi l’azienda costruirà la propria infrastruttura di mining e acquisirà alcune già esistenti.</p>
<p>Ardoino ha detto: “Siamo impegnati a far parte dell’ecosistema del mining di Bitcoin”, ha detto. “Quando si tratta di espansioni, costruzione di nuove sottostazioni e nuovi siti, li prendiamo estremamente sul serio.”</p>
<p>L’obiettivo di Tether è raggiungere l’1% dell’hashrate di Bitcoin, iniziando con 120 MW entro la fine dell’anno e 450 MW nel 2025. Già l’azienda ha messo da parte 150 milioni di dollari per investimenti diretti nel settore minerario. Se Tether raggiunge il suo obiettivo di mining di BTC, diventerà uno dei primi 20 minatori di Bitcoin al mondo.</p>
<p>Una delle strategie infrastrutturali di Tether è quella di costruire strutture minerarie in grandi contenitori mobili. Pertanto, sarà molto facile spostare i contenitori in paesi dove l’elettricità è economica.</p>
<h2 id="h2-Investimenti20correlati20alle20criptovalute20di20Tether25579"><a name="Investimenti correlati alle criptovalute di Tether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Investimenti correlati alle criptovalute di Tether</h2><p>Come sappiamo, il prodotto principale attuale di Tether è la stablecoin USDT, ancorata a un tasso di 1,1 rispetto al dollaro statunitense. Di conseguenza, genera gran parte dei suoi ricavi dai suoi asset di riserva multimiliardari, inclusi i titoli del Tesoro degli Stati Uniti. Le riserve sono importanti nella gestione di USDT poiché garantiscono che il <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Prezzo Tether</a> è stabile.</p>
<p>È importante notare che Tether ha già effettuato diversi investimenti in criptovalute relativi al mining di bitcoin. Ad esempio, a giugno ha investito in Volcano Energy, un’impresa salvadoregna di mining di BTC.</p>
<p>Ancora, a settembre ha ottenuto una quota del 20% in Northern Data e ha acquisito le GPU orientate all’IA di Nvidia nel processo. In una mossa correlata, Tether ha reso noto che includerà bitcoin nei suoi bilanci.</p>
<p>Oltre ai suoi investimenti diretti nel settore del mining di bitcoin, Tether ha messo da parte molti fondi per la ricerca e lo sviluppo. Solo quest’anno, l’azienda ha destinato oltre 800 milioni di dollari per condurre ricerche in campi correlati al crypto-mining come l’uso dell’energia.</p>
<p>L’ingresso di Tether nell’industria del mining di bitcoin indica che ci saranno alcuni giocatori dominanti nel settore. Attualmente, Marathon Digital Holdings, una società quotata in borsa, controlla circa il 4% del tasso di hash totale del mining di BTC. Tuttavia, è possibile che in futuro Tether ne possiederà più dell’1% poiché dispone di molte risorse finanziarie.</p>
<p>L’ingresso deciso di Tether nel settore del mining di BTC lo posizionerà come uno dei più grandi progetti di criptovaluta. Ciò aumenterà anche la concorrenza che potrebbe spingere altri minatori di bitcoin fuori dal mercato.</p>
<h2 id="h2-Localit20per20le20operazioni20di20mining20di20Tether679389"><a name="Località per le operazioni di mining di Tether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Località per le operazioni di mining di Tether</h2><p>Abbiamo già evidenziato il piano strategico di Tether di spostare le sue strutture minerarie in aree dove l’elettricità è economica. Tuttavia, <a href="https://www.bloomberg.com/news/articles/2023-11-16/stablecoin-issuer-tether-usdt-btc-wants-to-become-a-major-bitcoin-miner" rel="nofollow noopener noreferrer" target="_blank">Ardoino ha detto a Bloomberg</a> che stabilirà le sue strutture minerarie, con capacità comprese tra 40 e 70 megawatt in Uruguay, Paraguay e El Salvador. Uno dei fattori chiave per la scelta di tali posizioni è l’elettricità economica e le regolamentazioni amichevoli per le criptovalute.</p>
<h2 id="h2-Le20sfide20del20mining20che20creer20lhalving20del20Bitcoin20nel202024216514"><a name="Le sfide del mining che creerà l’halving del Bitcoin nel 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le sfide del mining che creerà l’halving del Bitcoin nel 2024</h2><p>Gli effetti dell’halving di bitcoin sull’estrazione mineraria sono complessi e diversificati. In primo luogo, l’halving di bitcoin rappresenta un’ottima opportunità per i minatori poiché potrebbe portare a un aumento del prezzo.</p>
<p>Nel periodo successivo a tutti gli eventi di dimezzamento precedenti, il prezzo del bitcoin è aumentato di ampi margini. Se si verifica lo stesso scenario, i minatori di BTC trarranno vantaggio dall’aumento del suo valore poiché genereranno maggiori entrate dalla vendita di ciascun BTC rispetto ad ora.</p>
<p>Tuttavia, l’evento dell’halving presenta diverse sfide che potrebbero influenzare Tether durante i suoi primi anni di mining. In primo luogo, l’halving del bitcoin del 2024 ridurrà la ricompensa del minatore per blocco da 6,25 BTC a 3,125. Ciò significa che i minatori con strutture di mining inefficienti potrebbero incontrare problemi di sostenibilità.</p>
<p>Questo significa anche che i minatori di bitcoin che operano in luoghi dove il costo dell’elettricità è molto elevato possono ottenere profitti molto bassi o addirittura subire perdite. Per contestualizzare, la creazione di un singolo bitcoin richiede circa 266.000 Kilowatt-ora (kWh) di elettricità. Comunque, il fattore del costo dell’elettricità è una delle principali ragioni per cui Tether ha scelto di stabilire i suoi impianti di mining in paesi con un costo energetico relativamente basso.</p>
<p>È più probabile che la concorrenza mineraria aumenti nell’era successiva all’evento di dimezzamento del 2024. Nick Cote, fondatore di Second Lane, ha una visione simile. <a href="https://twitter.com/mBTCPiz/status/1693607177142104521/" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>, “Continuo a sostenere che la maggior parte dei minatori non sarà in grado di competere efficacemente nella prossima fase di partecipazione allo spazio minerario. La quantità di hash di rete al di fuori degli Stati Uniti continuerà a crescere, portando a una forte concorrenza.”</p>
<p>È importante notare che la difficoltà di mining di bitcoin è probabile che continui a salire nel 2024. Considerando che è aumentata più volte quest’anno, lo stesso potrebbe accadere nel 2024 e oltre. Fondamentalmente, la difficoltà di mining misura la potenza di calcolo richiesta per minare nuovi bitcoin. La rete bitcoin bilancia il tasso medio di produzione della blockchain per ottenere sei blocchi all’ora.</p>
<h2 id="h2-Conclusion498325"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Tether sta espandendo la sua operazione di criptovaluta nell’estrazione di bitcoin. Intende stabilire le sue strutture di mining in Uruguay, Paraguay e El Salvador. Già ha effettuato diversi investimenti in cripto in aziende come Volcano Energy e Northern Data. Se riuscirà a ottenere l’1% del mercato del mining, come intende, sarà tra le 20 migliori aziende di mining di criptovaluta.</p>
<h2 id="h2-Domande20frequenti20su20Tether876174"><a name="Domande frequenti su Tether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Tether</h2><h3 id="h3-Tether20ha20un20futuro128247"><a name="Tether ha un futuro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tether ha un futuro?</h3><p>Tether ha un buon futuro poiché possiede la principale stablecoin, Tether USDT. Molti investitori utilizzano USDT per mantenere il valore del loro denaro. Attualmente, Tether sta anche investendo nell’estrazione di bitcoin.</p>
<h3 id="h3-Quanto20varr20Tether20tra201020anni839827"><a name="Quanto varrà Tether tra 10 anni?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto varrà Tether tra 10 anni?</h3><p>Dato che Tether USDT è una stablecoin, è improbabile che il suo valore cambi in 10 anni. Ciò significa che manterrà un prezzo di $1 dopo 10 anni.</p>
<h3 id="h3-Perch20USDT20sta20scendendo621060"><a name="Perché USDT sta scendendo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché USDT sta scendendo?</h3><p>Nella maggior parte dei casi, il valore di USDT non diminuisce. Tuttavia, ci sono momenti in cui il suo valore può deviare dal rapporto di $1. Di solito ciò avviene quando ci sono cattive notizie su Tether o quando ci sono gravi sfide macroeconomiche come il crollo di grandi banche.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripostare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>