R2F0ZSBMaXZlIEFNQSBSZWNhcCAtIE9ib2w=

<p><img src="https://gimg2.gateimg.com/image/article/1747206572live.jpeg" alt="">
</p><p>Oggi, come il <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> ondata che sta spazzando il mondo, il Collettivo Obol sta ridisegnando la logica sottostante dell’infrastruttura blockchain con la rivoluzionaria Tecnologia dei Validatori Distribuiti (DVT). Come la rete operativa decentralizzata più innovativa nel <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ecosistema, Obol ha raccolto oltre 800 operatori di nodi globali, salvaguardando la sicurezza di oltre 1 miliardo di USD di asset di mainnet. Comprendiamo profondamente che la vera decentralizzazione richiede non solo progressi tecnologici ma anche la co-costruzione dell’ecosistema. Questo dialogo approfondito con la comunità Gate ti porterà a esplorare come OBOL, attraverso la governance, lo staking e gli incentivi dell’ecosistema, diventi una chiave <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">link</a> collegare il valore tecnologico e il consenso della comunità.</p>
<h2 id="h2-Introduzione20al20progetto303831"><a name="Introduzione al progetto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione al progetto</h2><p>L’esistenza di Obol è quella di distribuire, decentralizzare e democratizzare l’infrastruttura digitale futura—da <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> a tutto il Web3. Come fondamento della blockchain Layer1 e della rete di infrastrutture decentralizzate, Obol Collective è la sede del più grande ecosistema operativo decentralizzato al mondo. Oggi, oltre 800 operatori decentralizzati a livello globale gestiscono i Validatori Distribuiti di Obol (DVs) per proteggere oltre $1 miliardo di asset nella mainnet.</p>
<h3 id="h3-Visione10465"><a name="Visione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Visione</h3><p>Obol aiuta a distribuire, decentralizzare e democratizzare l’infrastruttura digitale futura. Tutto inizia con il validatore distribuito di Obol, che aiuta gli stakeholder, le istituzioni e persino gli stakeholder domestici a ottenere migliori prestazioni, minor rischio e maggiori ricompense. Inoltre, porta di più attraverso lo Stack di Obol.</p>
<p>Obol immagina un mondo più decentralizzato per finanza, comunicazione e sistemi di identità, in cui gli individui hanno più potere. Questa visione è principalmente realizzata facendo sì che la maggioranza dei validatori di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> funzioni come validatori distribuiti di Obol, trasformando Ethereum in uno strato di insediamento globale e un computer mondiale, contribuendo a decentralizzare tutti gli altri sistemi. Inoltre, crediamo che lo Stack di Obol accelererà ulteriormente lo sviluppo di questi sistemi semplificando il processo di confezionamento, distribuzione ed esecuzione di applicazioni decentralizzate e infrastrutture, dando potere alle reti, ai costruttori e agli operatori di lanciare e sviluppare sistemi decentralizzati senza richiedere il permesso a nessuno.</p>
<h3 id="h3-Economia20dei20token406129"><a name="Economia dei token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Economia dei token</h3><p>Il design del token OBOL è mirato a massimizzare l’utilità e a restituire valore ai detentori e all’intero Collettivo Obol. Attualmente, ci sono quattro principali casi d’uso integrati nell’economia del token:</p>
<ol>
<li>Governance: Le proposte sono votate dai rappresentanti con diritti di voto con token OBOL.</li><li>Tracciare i fondi: Il progetto ottiene OBOL basato sul giro RAF per guidare una maggiore crescita dell’ecosistema, aiutando a sua volta ad aumentare il valore dell’intero ecosistema Obol.</li><li>Staking: Puoi fare staking dei tuoi token OBOL e ricevere stOBOL, permettendoti di partecipare alla governance e guadagnare ricompense di staking.</li><li>Re-staking e DeFi: Obol ha un gran numero di partner e occupa una posizione importante nell’industria. Nel tempo, il token OBOL è destinato a diventare l’attivo di garanzia primario all’interno dell’ecosistema dei partner, aumentando ulteriormente l’accumulo di valore e l’utilità.</li></ol>
<h3 id="h3-Valore531358"><a name="Valore" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Valore</h3><p>Il valore di Obol Collective e del token OBOL si riflette in molteplici aspetti:</p>
<ul>
<li>Ecosistema: collaborare con dozzine di protocolli e istituzioni nel settore</li><li>Community: Ci sono quasi mille operatori di nodi di mainnet indipendenti a livello globale, rendendolo l’ecosistema operativo decentralizzato più grande.</li><li>Tecnologia: Il validatore distribuito ha protetto oltre $1 miliardo di valore di ETH sulla mainnet, e il team di Obol sta per lanciare il suo nuovo prodotto di punta Obol Stack, che rivoluzionerà l’industria.</li></ul>
<h3 id="h3-Obiettivo202025480539"><a name="Obiettivo 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Obiettivo 2025</h3><ul>
<li>Adottare continuamente validatori distribuiti con l’obiettivo di raggiungere un valore totale di blocco di 100 miliardi di dollari entro la fine dell’anno.</li><li>L’adozione rapida di Obol Stack, inizialmente in collaborazione con alcuni partner chiave, si è poi estesa a più reti, costruttori e operatori all’interno del settore.</li></ul>
<h2 id="h2-Domande20e20risposte20della20comunit563136"><a name="Domande e risposte della comunità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte della comunità</h2><ul>
<li>Guardando avanti, come il Collettivo $OBOL immagina lo sviluppo del suo ecosistema di validatori decentralizzati in termini di interoperabilità tra le diverse catene, e come il token OBOL faciliterà interazioni fluide tra più reti e protocolli?</li></ul>
<p>Risposta: OBOL è la fondazione del primo livello della blockchain, aiutandoli a raggiungere la decentralizzazione attraverso un insieme diversificato di operatori e validatori distribuiti. Oggi, il nostro valore totale bloccato è di 1,5 miliardi di USD, con l’obiettivo di raggiungere 10 miliardi di USD entro la fine dell’anno. Potremmo non focalizzarci necessariamente sull’interoperabilità, ma aiutiamo tutte le blockchain a muoversi attivamente lungo la curva della decentralizzazione per ottenere più ricompense, performance e resilienza.</p>
<ul>
<li>Rispetto ad altre soluzioni DVT come la rete SSV, come affronta in modo specifico la tecnologia dei Validatori Distribuiti (DVT) di OBOL i rischi di centralizzazione nello staking di Ethereum e fornisce vantaggi unici in termini di prestazioni e adozione?</li></ul>
<p>Risposta: Come soluzione middleware pura, Obol Distributed Validator non accede alle chiavi private o esegue direttamente altre reti. Possiamo integrarci con qualsiasi stack di staking mantenendo la sua sicurezza esistente. Operiamo anche i DV in modo indipendente, rendendoli più veloci ed efficienti rispetto a SSV.</p>
<ul>
<li>Guardando avanti, quali eccitanti innovazioni possono gli utenti aspettarsi sulla roadmap di $OBOL? Come si allineano queste innovazioni con la tua visione a lungo termine per la piattaforma?</li></ul>
<p>Risposta: Certo! Aumentare il valore totale bloccato degli Obol DV a $10 miliardi per migliorare le prestazioni di Ethereum e altri PoS, fornendo migliori ricompense e un’esperienza più sicura per gli stakeholder. Lanciare Obol Stack, un framework modulare, plug-and-play per applicazioni decentralizzate e infrastrutture.</p>
<ul>
<li>Come DAO, come OBOL permette ai detentori di token di governare lo sviluppo del progetto e il processo decisionale? Potresti spiegare il meccanismo di voto on-chain guidato dal token OBOL?</li></ul>
<p>Risposta: A Token House, i detentori di token OBOL sono responsabili di presentare, esaminare e votare su varie proposte di governance di Obol Collective. Attraverso il nostro programma di finanziamento retroattivo (simile a Optimism), i detentori di token possono anche premiare il finanziamento dei beni pubblici. Infine, $OBOL può essere messo in gioco per guadagnare ulteriori premi per partecipare alla governance!</p>
<ul>
<li>Quali rischi o compromessi possono esistere nella distribuzione programmatica dei token OBOL attraverso programmi incentivanti?</li></ul>
<p>Risposta: Crediamo che il programma di incentivi sia un beneficio netto perché beneficia le persone che investono nei validatori che lavorano con noi ricevendo token OBOL. Se scommetti su Obol DVs con Lido, Etherfi, Swell, ecc., riceverai più ricompense!</p>
<h2 id="h2-Prospettive20future20di20Obol126245"><a name="Prospettive future di Obol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future di Obol</h2><p>Mentre il validatore decentralizzato di Obol si avvicina all’obiettivo di 100 miliardi di TVL, e mentre Obol Stack permette ai developer di costruire la prossima generazione di applicazioni decentralizzate, ciò che vediamo non è solo la crescita di un protocollo tecnico, ma anche un esperimento sociale sulla sovranità digitale. Come sottolineato dal team di Obol nell’AMA: la decentralizzazione non è la fine, ma un processo di evoluzione continua.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Gate Live</strong><br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Gli investimenti comportano rischi e gli utenti devono prendere decisioni oculate.<br><div></div>Gate.io si riserva tutti i diritti su questo articolo. Il re-post dell'articolo sarà consentito a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br><p></p><br></em></div></div></div>