SWwgZmF0dHVyYXRvIGRpIEJpdGNvaW4gYXVtZW50YSBCbG9jayBJbmMuIGEgMiw2IG1pbGlhcmRpIGRpIGRvbGxhcmk6IFNlbnRpbWVudG8gZGkgbWVyY2F0bw==

2024-08-14, 02:40

<p><img src="https://gimg2.gateimg.com/image/article/17236028241690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR858366"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Block Inc., il gigante dei pagamenti guidato da Jack Dorsey, ha riportato un notevole aumento del 9% anno su anno in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> fatturato per il secondo trimestre del 2024, raggiungendo 2,61 miliardi di dollari.</p>
<p>In una recente lettera agli azionisti, Block ha dettagliato che il suo ricavo netto totale per il trimestre ha raggiunto 6,16 miliardi di dollari, segnando un aumento dell’11% rispetto allo stesso periodo del 2023.</p>
<p>Escludendo il fatturato di Bitcoin, il fatturato dell’azienda è stato di $3,54 miliardi, riflettendo una crescita annua del 13%.</p>
<p>Block calcola il ricavo <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> come il valore totale di BTC venduto ai suoi clienti.</p>
<p>Cash App, il servizio di punta di Block, ha contribuito per 4,13 miliardi di dollari al fatturato trimestrale. Senza le transazioni Bitcoin, il fatturato di Cash App si attestava a 1,52 miliardi di dollari. L’app ha registrato anche un significativo aumento del profitto lordo di Bitcoin, che è aumentato del 52% anno su anno, raggiungendo i 67 milioni di dollari nel secondo trimestre del 2024.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/bitcoin-btc" target="_blank">Previsioni sul prezzo del Bitcoin per il 2024-2030</a></p>
<h2 id="h2-Block20e20la20Saga20BTC136904"><a name="Block e la Saga BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Block e la Saga BTC</h2><p>L’aumento del profitto lordo di Bitcoin è stato in gran parte attribuito a una media più alta <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo BTC</a>, che è aumentata del 45% nel 2024, scambiandosi a $64.777 al momento della segnalazione. Tuttavia, Block ha riportato una perdita di $70 milioni dalle sue attività in Bitcoin, con circa 8.211 BTC valutati a $515 milioni nel bilancio al 30 giugno 2024. La società ha aggiunto circa 173 BTC durante il trimestre.</p>
<p>Il profitto lordo complessivo di Block è cresciuto del 20% rispetto all’anno precedente, raggiungendo i 2,23 miliardi di dollari. L’utile netto attribuibile agli azionisti comuni è stato di 195 milioni di dollari, quasi il doppio rispetto ai 102 milioni dell’anno scorso nello stesso trimestre.</p>
<p>Nel tentativo di rafforzare la propria posizione finanziaria, Block ha annunciato a maggio la sua intenzione di raccogliere 2 miliardi di dollari attraverso note senior non garantite per investitori istituzionali qualificati. La società ha dichiarato che, con i proventi di questa offerta di debito, ha chiuso il secondo trimestre del 2024 con una liquidità disponibile di 10,3 miliardi di dollari.</p>
<p>I fondi dell’offerta di debito sono destinati a una varietà di scopi, tra cui il rimborso del debito, acquisizioni, transazioni strategiche, spese di capitale, investimenti e capitale circolante.</p>
<h2 id="h2-Piani20di20Dorsey20su20BTC875975"><a name="Piani di Dorsey su BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Piani di Dorsey su BTC</h2><p>Block Inc., guidata da Jack Dorsey, ha delineato i piani per aumentare significativamente le sue riserve di Bitcoin entro il 2024. L’azienda ha implementato un programma di acquisto a costo medio in dollari (DCA) di Bitcoin, che impegna il 10% del profitto lordo dei suoi prodotti correlati a Bitcoin per acquisire ulteriori Bitcoin ogni mese. Questa decisione strategica si allinea alla convinzione di Block in Bitcoin come strumento per l’empowerment economico, consentendo alle persone di partecipare a un sistema finanziario globale e controllare il loro futuro finanziario in modo indipendente.</p>
<p>Quest’iniziativa, che è iniziata nell’aprile 2024, continuerà per tutto l’anno, garantendo che Block aumenti sistematicamente le sue riserve di Bitcoin indipendentemente dalle condizioni di mercato. Questo approccio riflette la fiducia a lungo termine di Block nel potenziale di Bitcoin come asset trasformativo.</p>
<p>L’impegno di Block verso Bitcoin è ulteriormente riflesso nella sua strategia completa per gestire le sue riserve di Bitcoin. Ciò include piani dettagliati per l’esecuzione degli acquisti, i meccanismi di archiviazione e le considerazioni assicurative e contabili, garantendo che l’investimento dell’azienda in Bitcoin sia ben protetto e gestito strategicamente. Questa iniziativa non solo supporta gli obiettivi finanziari di Block, ma sottolinea anche la sua fiducia a lungo termine nel potenziale di Bitcoin.</p>
<h2 id="h2-Altre20aziende20con20BTC20in20giacenza166974"><a name="Altre aziende con BTC in giacenza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altre aziende con BTC in giacenza</h2><p>Diverse aziende di rilievo stanno attivamente acquistando Bitcoin per detenerli come parte delle loro riserve aziendali. Ecco alcune delle principali:</p>
<p>MicroStrategy: Guidando la strada, MicroStrategy detiene la più grande quantità di Bitcoin tra le società quotate in borsa. Al momento, possiedono circa 158.400 BTC. L’azienda, sotto la guida di Michael Saylor, è stata un forte sostenitore di Bitcoin, considerandolo un asset strategico e aumentando continuamente le proprie partecipazioni attraverso varie iniziative di raccolta di capitale.</p>
<p>Marathon Digital Holdings: Questa società di mining di criptovalute con sede negli Stati Uniti detiene circa 13.726 BTC. Marathon Digital ha ampliato le sue operazioni di mining e le riserve, diventando uno dei maggiori detentori di Bitcoin tra le società di mining.</p>
<p>Tesla: L’azienda di veicoli elettrici ed energia pulita guidata da Elon Musk detiene circa 10.500 BTC. Nonostante Tesla abbia avuto un rapporto altalenante con Bitcoin, rimane uno dei principali detentori aziendali della criptovaluta.</p>
<p>Hut 8 Mining Corp: Questa società canadese di mining di Bitcoin ha circa 9.255 BTC. Hut 8 si è concentrata sulla crescita delle sue riserve di Bitcoin attraverso le sue operazioni di mining e acquisizioni strategiche.</p>
<p>Riot Platforms, Inc.: Un altro importante giocatore nell’industria del mining di Bitcoin, Riot Platforms (precedentemente Riot Blockchain), detiene circa 9.084 BTC. L’azienda ha investito pesantemente nell’espansione della sua capacità di mining negli Stati Uniti.</p>
<p>Galaxy Digital Holdings: Questa banca commerciale focalizzata sulle criptovalute detiene circa 8.100 BTC. Fondata da Michael Novogratz, Galaxy Digital è stata un attore significativo nello spazio degli investimenti in criptovalute.</p>
<p>Queste aziende considerano Bitcoin come un asset strategico, contribuendo alle loro riserve finanziarie e sfruttando il suo potenziale di apprezzamento del valore a lungo termine.</p>
<h2 id="h2-Come20influisce20questo20sul20prezzo20del20BTC403749"><a name="Come influisce questo sul prezzo del BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come influisce questo sul prezzo del BTC</h2><p>La sostanziale accumulazione di Bitcoin da parte di grandi aziende può avere diversi impatti <a href="https://www.gate.io/blog_detail/26" target="_blank">sul prezzo di Bitcoin</a>:</p>
<p>1-Aumento della domanda: quando aziende come MicroStrategy, Tesla e Block Inc. acquistano grandi quantità di Bitcoin, aumentano significativamente la domanda per la criptovaluta. Poiché Bitcoin ha un’offerta limitata di 21 milioni di monete, una maggiore domanda solitamente fa aumentare il prezzo. Più Bitcoin queste aziende comprano, più scarsità viene creata nel mercato, il che può portare a prezzi più alti.</p>
<p>2-Sentimento di mercato: Grandi acquisti da parte di note società possono influenzare positivamente il sentimento di mercato. Gli investitori spesso considerano queste azioni come un’approvazione del valore e della legittimità del Bitcoin. Questo può attirare più investitori istituzionali e al dettaglio, aumentando ulteriormente la domanda e il prezzo. Quando una società come MicroStrategy <a href="https://www.gate.io/blog/1595/what-is-behind-microstrategy-all-in-btc" target="_blank">fa un investimento di alto profilo</a>, può segnalare fiducia nel futuro di Bitcoin, incoraggiando gli altri a fare altrettanto.</p>
<ol>
<li><p>Volatilità ridotta: Nel tempo, poiché sempre più istituzioni detengono Bitcoin, il mercato potrebbe diventare meno volatile. Gli investitori istituzionali tendono a mantenere gli asset più a lungo rispetto agli investitori al dettaglio, riducendo la frequenza e l’impatto delle grandi vendite. Questa maggiore stabilità può rendere Bitcoin più attraente ad altri potenziali investitori, portando eventualmente ad ulteriori incrementi dei prezzi.</p>
</li><li><p>Liquidità di mercato: sebbene le acquisizioni su larga scala possano temporaneamente ridurre la liquidità (rendendo disponibili meno Bitcoin per il trading), possono anche migliorare la liquidità complessiva del mercato poiché le istituzioni spesso operano in modo più strutturato e prevedibile. Ciò può rendere il mercato più profondo e più resiliente agli shock, stabilizzando potenzialmente i prezzi nel lungo termine.</p>
</li><li><p>Effetti di rete: Man mano che sempre più aziende integrano Bitcoin nei loro bilanci e nelle loro operazioni, entra in gioco l’effetto di rete. Un maggiore utilizzo e accettazione possono portare a una maggiore adozione, rafforzando la proposta di valore di Bitcoin come valuta digitale globale. Questa diffusa adozione può spingere il prezzo verso l’alto a causa di un aumento dell’utilizzo su diverse piattaforme e servizi.</p>
</li><li><p>Influenza regolamentare: il coinvolgimento delle grandi società in Bitcoin potrebbe attirare l’attenzione dei regolatori, portando potenzialmente a regolamentazioni più chiare. Sebbene ciò possa inizialmente causare incertezza e volatilità, quadri regolamentari chiari possono fornire legittimità e sicurezza agli investitori istituzionali, incoraggiando ulteriori investimenti e potenzialmente aumentando il prezzo di Bitcoin.</p>
</li></ol>
<p>Nel complesso, l’attività di acquisti aziendali su larga scala è generalmente rialzista per il prezzo del Bitcoin, poiché sottolinea la fiducia nel suo valore e utilità futuri, attira più investitori, e può portare a un aumento dell’adozione e della stabilità nel <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a>.</p>
<h2 id="h2-FAQ198608"><a name="FAQ" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FAQ</h2><h3 id="h3-Cosa20sta20facendo20Jack20Dorsey20con20Bitcoin83177"><a name="Cosa sta facendo Jack Dorsey con Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa sta facendo Jack Dorsey con Bitcoin?</h3><p>Dorsey tende a rimanere in silenzio.</p>
<p>Anche quando parla, è di poche parole, ma ha investito molto in Bitcoin. Più di recente, ha promesso 21 milioni di dollari per lo sviluppo open source. E ha investito in startup di Bitcoin, come Lightning Labs.</p>
<h3 id="h3-Quanto20guadagna20Block20da20Bitcoin545952"><a name="Quanto guadagna Block da Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto guadagna Block da Bitcoin?</h3><p>Block, creatore di Cash App, ha registrato un aumento di ricavi dalle vendite di bitcoin di $660,8 milioni nel terzo trimestre del 2023</p>
<h3 id="h3-Quanto20bitcoin20possiede20Block503886"><a name="Quanto bitcoin possiede Block?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto bitcoin possiede Block?</h3><p>Block, Inc. possiede 8.027 BTC</p>
<h3 id="h3-Block20sta20comprando20Bitcoin926498"><a name="Block sta comprando Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Block sta comprando Bitcoin?</h3><p>Block intende <a href="/crypto/buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">acquista bitcoin</a> mensilmente, a partire da aprile 2024, utilizzando ordini di prezzo medio ponderato nel tempo (TWAP). Per ridurre al minimo lo slippage, l’azienda ha dichiarato che <a href="/crypto/buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">acquista BTC</a>“in una finestra di due ore che storicamente ha avuto la maggior quantità di liquidità.”</p>
<div class="blog-details-info"><br><div>Autore:<em> Andrei</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 riutilizzo dell'articolo a condizione che venga indicato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>