TWljcm9TdHJhdGVneSByYWZmb3J6YSBsZSBzdWUgcG9zaXppb25pIGluIEJpdGNvaW4gY29uIHVuIGFjcXVpc3RvIGRpIDc4NiBtaWxpb25pLCBwZXIgdW4gdG90YWxlIGRpIHF1YXNpIDE1IG1pbGlhcmRp

2024-07-03, 02:52

<p><img src="https://gimg2.gateimg.com/image/article/17199747861692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR782834"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Tra il 27 aprile e il 19 giugno, MicroStrategy ha acquisito 11.931 BTC per aumentare il proprio portafoglio a 226.331.</p>
<p>Semler Scientific, Tesla e <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> sono esempi di altre organizzazioni aziendali che hanno aggiunto <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> alle loro riserve finanziarie.</p>
<p>L’approvazione degli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> spot negli Stati Uniti ha influenzato le organizzazioni aziendali ad acquistare e detenere BTC.</p>
<h2 id="h2-Introduzione448105"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’adozione delle criptovalute è destinata a aumentare con l’ingresso di sempre più aziende e altre <a href="https://www.gate.io/blog_detail/1685/how-are-institutional-investors-participating-in-crypto" target="_blank">le organizzazioni stanno investendo in asset digitali</a>. Già alcune aziende private hanno acquisito criptovalute che stanno diventando componenti delle loro riserve. MicroStrategy, Tesla e <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> sono esempi di aziende che hanno aggiunto bitcoin alle loro riserve. Oggi, ci concentriamo su <a href="https://www.gate.io/blog_detail/1595/microstrategy-btc" target="_blank">La strategia di acquisizione di bitcoin di MicroStrategy</a> adottato nel 2020.</p>
<h2 id="h2-Acquisizione20di20Bitcoin20di20MicroStrategy201193120BTC20per2078620milioni20di20dollari743040"><a name="Acquisizione di Bitcoin di MicroStrategy: 11.931 BTC per 786 milioni di dollari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Acquisizione di Bitcoin di MicroStrategy: 11.931 BTC per 786 milioni di dollari</h2><p>Il 20 giugno, MicroStrategy ha annunciato di aver acquisito 11.931 bitcoin del valore di circa 786 milioni di dollari tra il 27 aprile e il 19 giugno. L’azienda ha utilizzato i fondi raccolti tramite la propria Offerta e l’Extra Cash per acquistare la criptovaluta ad un prezzo medio di 65.883 dollari, spese e costi correlati inclusi.<br><img src="https://gimg2.gateimg.com/image/article/17199749081.jpg" alt=""><br>Origine: x.com</p>
<p>Entro il 20 giugno, MicroStrategy aveva acquistato circa 226.331 bitcoins a un costo totale di circa 8,33 miliardi di dollari e a un prezzo medio di 36.798 dollari per moneta. Alla fine di aprile, l’azienda aveva un totale di 226.331 bitcoins del valore di circa meno di 15 miliardi di dollari se valutati a 66.000 dollari ciascuno. L’ultima acquisizione, orchestrata dal CEO di MicroStrategy, Michael Saylor, dimostra l’impegno dell’azienda nel considerare bitcoin come un asset di riserva.</p>
<p>Come previsto, le azioni di MicroStrategy (MSTR) hanno risposto positivamente alla notizia della recente acquisizione di bitcoin. Pertanto, il suo valore è aumentato del 2% a $1,507. Storicamente, fin dal momento in cui l’azienda ha iniziato ad investire in bitcoin, circa 4 anni fa, le sue azioni hanno ottenuto buoni risultati. Ad esempio, dalle agosto 2020, le azioni di MSTR hanno registrato un rendimento cumulativo del 1,089%. Di conseguenza, hanno superato altre azioni leader che includono Nasdaq 100 (QQQ) e S&amp;P 500 (SPY). Solo NVDA, il favorito dell’IA, ha brillato più di MSTR poiché il suo valore è aumentato del 1,114% nello stesso periodo.</p>
<h2 id="h2-Strategia20di20investimento20in20Bitcoin20di20MicroStrategy20dal202020566479"><a name="Strategia di investimento in Bitcoin di MicroStrategy dal 2020" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Strategia di investimento in Bitcoin di MicroStrategy dal 2020</h2><p>Nel 2020, MicroStrategy ha reso gli investimenti in bitcoin una delle sue principali priorità. Pertanto, ha adottato la criptovaluta come riserva per il suo tesoro aziendale bitcoin. Ad oggi, diverse aziende si sono impegnate ad investire in bitcoin. Semler Scientific (SMLR) quotata negli Stati Uniti, Tether Labs e Tesla sono esempi di investitori istituzionali in criptovalute con ampie disponibilità di bitcoin aziendali.</p>
<h2 id="h2-Gli20sforzi20di20raccolta20fondi20di20MicroStrategy20per20gli20acquisti20di20Bitcoin216045"><a name="Gli sforzi di raccolta fondi di MicroStrategy per gli acquisti di Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli sforzi di raccolta fondi di MicroStrategy per gli acquisti di Bitcoin</h2><p>Ora, concentriamoci su come MicroStrategy ha reperito i fondi per la sua recente acquisizione di bitcoin. La società ha utilizzato i 800 milioni di dollari raccolti attraverso l’offerta di note convertibili a imprese e altri investitori istituzionali. Anche se il valore originale dell’offerta era di 500 milioni di dollari, è stato aumentato a 700 milioni di dollari prima di essere chiuso a 800 milioni di dollari. A marzo, la società ha anche acquistato 9.245 BTC dopo aver raccolto i 623 milioni di dollari necessari attraverso l’emissione di debito.</p>
<p>Attraverso un comunicato stampa, MicroStrategy ha spiegato i termini e le condizioni della sua recente emissione di debito. <a href="https://www.microstrategy.com/press/microstrategy-announces-pricing-of-offering-of-convertible-senior-notes_06-14-2024" rel="nofollow noopener noreferrer" target="_blank">Si è affermato</a> MicroStrategy Incorporated ha annunciato oggi il prezzo del suo offerta di $700 milioni di ammontare principale aggregato di 2,25% obbligazioni convertibili senior scadenti nel 2032. Le obbligazioni saranno vendute privatamente a persone ragionevolmente ritenute essere qualificate acquirenti istituzionali.</p>
<p>Inoltre, l’offerta è stata aumentata rispetto all’offerta precedentemente annunciata di un ammontare aggregato di $ 500 milioni di note. Si prevede che l’offerta si chiuderà il 17 giugno 2024, a condizione che siano soddisfatte le consuete condizioni di chiusura… Le note avranno scadenza il 15 giugno 2032, salvo riacquisti, rimborsi o conversioni anticipate in conformità alle loro condizioni.</p>
<h2 id="h2-Lanalisi20del20mercato20criptato20impatto20di20BTC20sul20mercato20dellacquisizione20di20MicroStrategy643505"><a name="L’analisi del mercato criptato: impatto di BTC sul mercato dell’acquisizione di MicroStrategy" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’analisi del mercato criptato: impatto di BTC sul mercato dell’acquisizione di MicroStrategy</h2><p>MicroStrategy’s <a href="https://www.gate.io/learn/articles/cryptocurrency-investment-guide-in-the-bear-market/1549" target="_blank">strategia di investimento in criptovalute</a> ha un grande impatto sul mercato di BTC. La sua accumulazione influenza la dinamica del prezzo del bitcoin poiché segnala l’aumento dell’adozione istituzionale dell’asset digitale e di altre criptovalute. L’adozione di bitcoin da parte di MicroStrategy potrebbe portare ad un aumento degli investitori istituzionali nelle criptovalute, il che potrebbe portare ad un aumento dell’adozione delle criptovalute.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1697" target="_blank">8 Migliori Consigli per Investimenti Cripto a Breve Termine</a></p>
<p>Tuttavia, alcuni critici hanno sollevato preoccupazioni a causa del rischio di volatilità delle criptovalute che potrebbe influenzare la stabilità finanziaria di MicroStrategy in futuro se il valore del bitcoin dovesse diminuire. Nonostante tali timori, altre aziende ritengono che valga la pena investire in bitcoin. Ad esempio, Eric Semler, presidente di Semler Scientific, che ha avviato l’acquisizione di bitcoin della sua azienda, ha una convinzione ferma nell’asset. In un recente <a href="https://ir.semlerscientific.com/news-releases/news-release-details/semler-scientificr-announces-bitcoin-treasury-strategy#:~:text=%22Our%20bitcoin%20treasury%20strategy%20and,%241%20trillion%20of%20market%20value." rel="nofollow noopener noreferrer" target="_blank">comunicato stampa ha detto</a>, “La nostra strategia del tesoro di bitcoin e l’acquisto di bitcoin sottolineano la nostra convinzione che il bitcoin sia un affidabile deposito di valore e un investimento convincente.”</p>
<p>Ha aggiunto: “Bitcoin è ora una classe di attività importante con un valore di mercato superiore a 1 trilione di dollari. Crediamo che abbia caratteristiche uniche come una risorsa scarsa e finita che può fungere da parziale copertura contro l’inflazione e un rifugio sicuro in mezzo all’instabilità globale.”</p>
<p>“Crediamo anche che la sua resilienza digitale e architettonica la renda preferibile all’oro, che ha un valore di mercato circa 10 volte superiore a quello del bitcoin. Dato il divario di valore tra l’oro e il bitcoin, riteniamo che il bitcoin abbia il potenziale per generare rendimenti superiori man mano che guadagna sempre più accettazione come oro digitale.”</p>
<p>Molte organizzazioni aziendali sono disposte a investire in bitcoin a causa della SEC degli Stati Uniti <a href="https://www.gate.io/blog_detail/3434/btc-etf-approval-catalysts" target="_blank">approvazione di ETF di bitcoin spot</a> a gennaio. L’approvazione degli ETF ha agito come un sigillo di fiducia in Bitcoin in particolare e nelle criptovalute in generale. <a href="https://ir.semlerscientific.com/news-releases/news-release-details/semler-scientificr-announces-bitcoin-treasury-strategy#:~:text=%22Our%20bitcoin%20treasury%20strategy%20and,%241%20trillion%20of%20market%20value." rel="nofollow noopener noreferrer" target="_blank">Semler ha detto</a>, Inoltre, siamo entusiasti dell’aumento dell’accettazione globale e dell’istituzionalizzazione di Bitcoin - riflessa più di recente dalla Securities and Exchange Commission’s <a href="https://www.gate.io/blog_detail/3707/bitcoin-etf-approval-analysts-weigh-in-on-implications" target="_blank">Approvazione gennaio 2024 di 11 fondi negoziati in borsa di bitcoin</a>.”</p>
<h2 id="h2-Conclusione930218"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Tra il 27 aprile e il 19 giugno MicroStrategy ha acquisito 11.931 bitcoin del valore di circa 786,0 milioni di dollari. Dopo quell’acquisizione, l’azienda ha oltre 226.331 BTC del valore di circa 15 miliardi di dollari. Semler Scientific, Tesla e Tether sono altre aziende che hanno acquisito molti bitcoin. L’approvazione degli ETF di bitcoin spot negli Stati Uniti ha motivato molte organizzazioni aziendali ad investire in bitcoin.</p>
<h2 id="h2-Domande20frequenti20su20MicroStrategy20Bitcoin775558"><a name="Domande frequenti su MicroStrategy Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su MicroStrategy Bitcoin</h2><h3 id="h3-Quanto20ha20perso20MicroStrategy20su20Bitcoin640655"><a name="Quanto ha perso MicroStrategy su Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto ha perso MicroStrategy su Bitcoin?</h3><p>Al 1 maggio 2024 MicroStrategy aveva una perdita di valore di $53 milioni. A quel tempo aveva 214.278 BTC. La perdita della società in qualsiasi momento dipende dal valore attuale di bitcoin.</p>
<h3 id="h3-Chi20possiede20la20maggior20parte20dei20bitcoin20MicroStrategy877870"><a name="Chi possiede la maggior parte dei bitcoin MicroStrategy?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi possiede la maggior parte dei bitcoin MicroStrategy?</h3><p>In termini generali, Satoshi Nakamoto possiede la quantità più elevata di bitcoin in quanto detiene 1,1 milioni di BTC. Tuttavia, tra tutte le società pubbliche, MicroStrategy possiede il maggior numero di bitcoin in quanto ne possiede 226.331 BTC.</p>
<h3 id="h3-Cosa20faceva20MicroStrategy20prima20di20bitcoin62185"><a name="Cosa faceva MicroStrategy prima di bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa faceva MicroStrategy prima di bitcoin?</h3><p>Prima di avventurarsi in Bitcoin MicroStrategy, produceva software per l’intelligence aziendale e l’estrazione dei dati. Tuttavia, ha <a href="https://www.gate.io/learn/articles/mitigating-risk-and-enhancing-returns-with-bitcoin/2438" target="_blank">diversificato negli investimenti in bitcoin</a> per preservare il valore dei suoi guadagni.</p>
<div class="blog-details-info"><br><div>Autore:<em> Mashell C.</em>, 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 il ripostaggio dell'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>