Q29zXCfDqCBBcndlYXZlIChBUik/IEJlbnZlbnV0aSBuZWwgc3RvcmFnZSBibG9ja2NoYWluIHBlcm1hbmVudGUgKDIwMjUp

2022-04-07, 07:21

<p><img src="https://gimg2.gateimg.com/image/ar202506181202130398437351.png" alt="">
</p><p><a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">Arweave</a>(AR) fornisce memorizzazione blockchain permanente attraverso il suo innovativo modello di pagamento una tantum e un meccanismo di consenso unico basato sulla prova di accesso. Nel 2025, <a href="/price/arweave-ar" target="_blank" class="blog_inner_link">Arweave</a> ha aggiornato al protocollo SPoRA, raggiungendo 5.000 transazioni al secondo grazie alla tecnologia “Blockshadows”. Il lancio del progetto AO l’8 febbraio ha consentito alle applicazioni proxy di eseguire calcoli paralleli, permettendo ai detentori di AR di accumulare token AO. Le partnership strategiche con Meta, Solana, Polkadot, Internet Archive e ClimateTrace hanno rafforzato la sua posizione nell’ecosistema. Il token AR è aumentato da meno di $10 a oltre $40, affermandosi. <a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">Arweave</a> Come <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Lo stato delle soluzioni di archiviazione permanente definitorie.</p>
<h2 id="h2-Ultimi20sviluppi20nel202025103435"><a name="Ultimi sviluppi nel 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultimi sviluppi nel 2025</h2><p>Dalla sua istituzione, Arweave ha fatto progressi significativi nel suo framework tecnico e nella sua posizione di mercato. La piattaforma ora adotta il protocollo SPoRA dopo l’aggiornamento da RandomX, migliorando significativamente il throughput delle transazioni a circa 5.000 transazioni al secondo grazie alla sua innovativa tecnologia ‘Blockshadows’.</p>
<p>Un importante sviluppo nel 2025 è il lancio del mainnet del progetto AO l’8 febbraio. AO è costruito sopra Arweave, fornendo uno strato di calcolo parallelo per applicazioni proxy, e i detentori di token AR devono solo detenere AR nei loro portafogli per accumulare token AO.</p>
<p>Le collaborazioni significative hanno rafforzato la posizione di Arweave nell’ecosistema Blockchain:</p>
<ul>
<li>Collaborazione con Meta per fornire archiviazione permanente per collezionabili digitali su Instagram</li><li>Con <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> Integrato per memorizzare i registri</li><li>Adottato da Internet Archive per l’archiviazione web</li><li>Collaborando con ClimateTrace per memorizzare i dati sulle emissioni di gas serra</li></ul>
<p>I token AR hanno avuto una performance eccezionale, balzando da meno di 10 $ a oltre 40 $ dopo l’annuncio del progetto AO. Questa traiettoria di crescita ha reso Arweave un attore importante nello spazio di archiviazione decentralizzata, fungendo da soluzione di archiviazione permanente per il Web3.</p>
<h2 id="h2-Che20cos20Arweave20AR494834"><a name="Che cos’è Arweave (AR)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Che cos’è Arweave (AR)?</h2><p>Arweave è un progetto di crittografia per la memorizzazione decentralizzata dei dati, mirato a creare una piattaforma di archiviazione infinita per gli utenti, consentendo loro di memorizzare qualsiasi contenuto desiderino all’interno di un’infrastruttura decentralizzata. Pensalo come un Dropbox o Google Foto basato su Web 3, ma non governato da un’unica entità. Arweave raggiunge questo obiettivo attraverso la tecnologia di hosting della rete chiamata “permaweb.”</p>
<h2 id="h2-Quali20sfide20affronta20il20Permaweb793450"><a name="Quali sfide affronta il Permaweb?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sfide affronta il Permaweb?</h2><p>Come le problematiche che il World Wide Web ha affrontato sin dai tempi antichi, anche il Permaweb affronta attività criminali e contenuti illegali. Tuttavia, a differenza di internet tradizionale, gli strumenti per la revisione democratica dei contenuti del permaweb sono integrati nel cuore del protocollo. Inoltre, il team di sviluppo principale di Arweave collabora strettamente con l’Internet Watch Foundation per fornire ai minatori di Arweave gli strumenti e le tecnologie necessarie per eliminare gli abusi e i contenuti illegali sul permaweb.</p>
<h2 id="h2-token20AR681275"><a name="token AR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>token AR</h2><p>Gli utenti possono utilizzare i token AR per la governance, vendere beni per fornire finanziamenti al protocollo e pagare le commissioni di transazione per lo storage dei contenuti nel permaweb. Attualmente, ci sono 50 milioni di token AR in circolazione, mentre l’offerta massima del progetto è di 66 milioni di AR.</p>
<h2 id="h2-Arweave145382"><a name="Arweave" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Arweave</h2><p>è un progetto di criptovaluta dedicato all’hosting di dati in una rete globale decentralizzata. Sembra semplice, ma in realtà è uno dei progetti più ambiziosi dell’intero <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> l’ecosistema ed uno degli asset più apprezzati del 2021. In un aspetto estremamente importante della decentralizzazione digitale, Arweave è in prima linea, ma in realtà ha ricevuto quasi nessuna attenzione che merita.</p>
<p>Alla luce di ciò, questo articolo spiega cos’è Arweave, i dettagli sul token AR e perché questo progetto è così importante per il futuro del Web 3.</p>
<h2 id="h2-Che20cos20Arweave20AR407762"><a name="Che cos’è Arweave (AR)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Che cos’è Arweave (AR)?</h2><p>Come accennato in precedenza, Arweave è un progetto di crittografia per lo stoccaggio decentralizzato dei dati volto a creare una piattaforma di archiviazione infinita per gli utenti, consentendo loro di memorizzare qualsiasi contenuto desiderino all’interno di un’infrastruttura decentralizzata. In un certo senso, viene spesso definito come un disco rigido di proprietà collettiva che non può mai essere cancellato. Pertanto, i dati che scegli di memorizzare esisteranno permanentemente sulla Blockchain di Arweave a meno che tu non li cancelli.</p>
<p>Arweave opera attraverso il permaweb. Il permaweb è il nome del protocollo di archiviazione dei dati per una piattaforma Blockchain decentralizzata, conosciuta come il “web permanente”. All’interno del permaweb, ci saranno diverse applicazioni disponibili per gli utenti da utilizzare su richiesta. Pensa a Dropbox, Google Foto, iCloud, qualsiasi cosa tu possa immaginare: queste diverse opzioni di archiviazione e personalizzazione sono tutte all’interno di una Blockchain completamente decentralizzata.</p>
<p>Permaweb è realizzato attraverso la tecnologia blockweave, che è il nome della blockchain di Arweave. Il suo principio di funzionamento è molto simile a quello della blockchain di Bitcoin, ma Arweave utilizza la tecnologia proof of access (PoA) invece della proof of work. Nella proof of access, a differenza dei modelli blockchain tradizionali, i miner scambiano risorse energetiche attraverso il loro hardware e possono anche inserire e replicare direttamente dati preziosi dal World Wide Web in cambio di token AR come compenso.</p>
<p>Questo meccanismo compensate i miner (che in questo caso possono essere chiamati scrittori) fornendo informazioni di base al permaweb — sviluppandolo lentamente ma costantemente in una risorsa preziosa nel mondo digitale. In cambio, riceveranno la criptovaluta nativa del progetto per memorizzare le informazioni rilevanti.</p>
<p>È altrettanto importante notare che prima di giugno 2018, Arweave era conosciuta come Archain, ed è stata successivamente unificata sotto un unico nome a causa della natura della tecnologia blockweave stessa, mantenendo lo stesso nome durante l’intero processo di sviluppo del progetto. Nel giugno 2018, gli sviluppatori hanno infine deciso di cambiare il nome in uno che fosse più vicino al suo modello blockweave originale—così, Arweave è nata.</p>
<h2 id="h2-Quali20sfide20affronta20il20Permaweb803513"><a name="Quali sfide affronta il Permaweb?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sfide affronta il Permaweb?</h2><p>Simile al tradizionale World Wide Web, le piattaforme di archiviazione decentralizzata di internet possono anche incontrare vari problemi come contenuti criminali, informazioni fraudolente e altro. Questi problemi esistono sin dalla nascita del Web 1 all’inizio degli anni ‘90 e non sembrano scomparire presto. Tuttavia, a differenza di internet tradizionale, strumenti come permaweb sono integrati nel nucleo del protocollo—restituendo il controllo del Web ai suoi utenti e appassionati in un modo che il Web 1 e il Web 2 non sono mai riusciti a raggiungere.</p>
<p>Quando qualcuno invia dati da memorizzare nel permaweb di Arweave, il protocollo di archiviazione dei dati può scegliere di sostituire i dati pertinenti. Quindi, i miner della rete possono filtrare le transazioni in base alle loro scelte, utilizzando scanner software per verificare informazioni nascoste, ecc., per controllare se contengono contenuti illegali. Se vengono trovati contenuti criminali, i miner riceveranno ricompense in token AR.</p>
<p>Inoltre, il team di sviluppo principale di Arweave sta collaborando strettamente con l’Internet Watch Foundation per fornire ai miner di Arweave gli strumenti e le tecnologie necessari per mantenere il permaweb libero da abusi e contenuti illegali. Inoltre, se i fornitori di archiviazione dei dati scoprono che i contenuti violano il quadro del progetto, possono scegliere di non memorizzare alcun contenuto sulla rete senza fornire una motivazione. Se i mittenti dei dati vogliono verificare nuovamente, possono tentare di rinviare i contenuti per vedere se superano la seconda verifica.</p>
<h2 id="h2-Investimento20in20Arweave338314"><a name="Investimento in Arweave" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Investimento in Arweave</h2><p>Il white paper di Arweave afferma che Arweave si sforza di garantire una capacità collettiva che consenta agli individui di archiviare e condividere dati con le generazioni future dall’inizio alla fine. Rispetto agli obiettivi di altri progetti di criptovaluta, l’obiettivo di Arweave è piuttosto unico e alcune istituzioni sembrano aver preso nota di questo.</p>
<p>Nel marzo 2020, Arweave ha annunciato di aver raccolto 8,3 milioni di dollari di finanziamenti da Andreessen Horowitz, Union Square Ventures e persino Coinbase Ventures—questo è il secondo round di investimento in cui Andreessen e Union Square hanno iniettato milioni nel 2019. Oltre a menzionare gli investitori e la Internet Observation Foundation, oltre alla Watch Foundation, Arweave ha anche stabilito partnership con Techstars, USV, 1kx e MultiCoin Capital.</p>
<h2 id="h2-token20AR504265"><a name="token AR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>token AR</h2><p>Attualmente, ci sono 50 milioni di token AR disponibili sul mercato, con un limite di fornitura di 66 milioni. Gli sviluppatori di Arweave affermano che la rete è completamente decentralizzata - questo significa che non hanno più alcuna autorità sulla governance o distribuzione dei token.</p>
<p>Il token nativo della rete è un modo per finanziare il protocollo vendendo gradualmente i suoi beni, con i profitti utilizzati per migliorare il capitale di rischio di Arweave, aumentando così il valore del token e sperando di creare un ciclo di apprezzamento.</p>
<p>Le informazioni fornite sul sito ufficiale di Arweave mostrano che la distribuzione dei token del protocollo è la seguente:</p>
<ul>
<li>19,5% per vendite private 2,9%</li><li>Allocato il 13% ai consulenti del progetto</li><li>Dare al team centrale (termine di 5 anni, poi rilasciare il 20% dei fondi ogni anno)</li><li>19,1% per lo sviluppo dell’ecosistema</li><li>26,5% allocato per progetti futuri - soggetto anche alle stesse condizioni del finanziamento del team principale.</li></ul>
<p>La sicurezza di Arweave è anche molto alta. Il suo precedente protocollo di mining, RandomX, ha costantemente superato con successo audit da parte di quattro grandi aziende nel campo della sicurezza informatica: Trail of Bits, Kudelski Security, Quarks Lab e X41 D-Sec. Da febbraio 2021, Arweave ha aggiornato le sue istruzioni di mining al protocollo SPoRA, che ha anche subito molteplici revisioni da parte del NCC Group ed è frequentemente lodato dai sostenitori a lungo termine del progetto.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team Blog</strong><br><div class="info-tips"><em>Il contenuto qui presente non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso di tutti o di una parte dei Servizi da Località Vietate. Per ulteriori informazioni, si prega di leggere il Contratto Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="7">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>