R2F0ZS5pbyBBTUEgY29uIEhvcmQgLSBTdGFraW5nIEV0aGVyZXVtIFNlbXBsaWNlLCBTaWN1cm8gZSBMaXF1aWRvIGNvbiBpbCBNaWdsaW9yIEFQUg==

<p><img src="https://gimg2.gateimg.com/image/article/16914889041.jpg" alt=""><br><strong>Ora: 7 agosto 2023 alle 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Erez Ben Kiki, CEO di Hord e Meir Rosenschien, Product Manager di Hord nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio di Gate.io</a>.</strong><br><strong>Sito web ufficiale: <a href="https://www.hord.fi/" rel="nofollow noopener noreferrer" target="_blank">https://www.hord.fi/</a></strong><br><strong>Twitter: <a href="https://twitter.com/HordApp" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/HordApp</a></strong><br><strong>Segui Hord su <a href="https://twitter.com/HordApp" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/hordnews" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospiti</strong><img src="https://gimg2.gateimg.com/image/article/16914891042.jpg" alt=""><br><strong>Erez Ben Kiki - CEO di Hord</strong><img src="https://gimg2.gateimg.com/image/article/16914891223.jpg" alt=""><br><strong>Meir Rosenschien - Product Manager di Hord</strong></p>
<h2 id="h2-QampA20da20Gateio670065"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Cos20HORD682053"><a name="Q1: Cos’è HORD?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Cos’è HORD?</h3><p>Quindi Hord è stato creato oltre 2 anni fa con l’obiettivo di consentire a chiunque di creare pool indicizzati e tokenizzati per le proprie strategie di investimento in criptovalute.</p>
<p>Per ‘tokenizzato’ intendo che la nostra tecnologia consente alle persone di creare un asset negoziabile, un token, che contiene al suo interno una strategia di investimento.</p>
<p>O in altre parole un token che rappresenta un altro asset, o più asset, che hanno il potenziale di aumentare di valore nel tempo.</p>
<p>Mentre abbiamo lanciato la nostra prima versione alla fine del 2021, abbiamo notato un cambiamento nel mercato.</p>
<p>I nostri utenti, insieme al resto del panorama cripto, stavano diventando titubanti nel commerciare gli asset. E ancora più importante, sono diventati molto più titubanti nel tokenizzare le proprie strategie e rischiare la loro reputazione su un mercato volatile.</p>
<p>Ma mentre tutto questo stava accadendo, c’era uno sviluppo molto importante che stava accadendo nello spazio cripto. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> passare da Proof of Work… a Proof of Stake.</p>
<p>All’improvviso c’era una nuova classe di asset che soddisfaceva i nostri criteri per la tokenizzazione e, cosa importante, era relativamente immune alla volatilità di mercato.</p>
<p>Così è nato il token hETH e con esso il Liquid ETH Staking Pool di Hord.</p>
<p>L’idea è molto semplice:<br>Gli utenti possono depositare ETH nel pool.</p>
<p>In cambio ottengono un token chiamato hETH, che rappresenta la loro quota del pool.</p>
<p>Utilizziamo gli ETH depositati dagli utenti per eseguire validatori che aiutano a far funzionare la blockchain di Ethereum.</p>
<p>In cambio, i nostri validatori guadagnano ricompense, ETH extra che viene depositato nuovamente nel pool<br>Quindi ora gli utenti token hETH rappresentano l’ETH che hanno depositato + la loro quota delle ricompense accumulate nel pool.<br><img src="https://gimg2.gateimg.com/image/article/16914891474.png" alt=""><br>Abbiamo depositato oltre 1.700 ETH in pochi mesi e abbiamo una serie di miglioramenti del prodotto di cui siamo molto orgogliosi e che saranno annunciati nel prossimo mese.</p>
<h3 id="h3-Q220Con20laumentare20della20popolarit20dello20staking20di20Ethereum20come20intende20Hord20rimanere20competitivo560239"><a name="Q2: Con l’aumentare della popolarità dello staking di Ethereum, come intende Hord rimanere competitivo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Con l’aumentare della popolarità dello staking di Ethereum, come intende Hord rimanere competitivo?</h3><p>Prima di tutto, sì, il panorama dello staking di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> sta diventando competitivo.</p>
<p>Questo è una cosa buona.</p>
<p>Esiste un pericolo molto critico e intrinseco in Ethereum. Troppi dei validatori di Ethereum, ovvero la sua potenza di elaborazione, saranno concentrati in un unico luogo.</p>
<p>Se ciò accade, e qualcosa va storto (e sfortunatamente siamo tutti consapevoli degli esempi di cose che vanno storte nello spazio) questo può essere estremamente negativo non solo per i detentori di Ethereum, ma per l’intera comunità crittografica.</p>
<p>Quindi crediamo che la concorrenza nello spazio di ETH staking sia molto importante. E prendiamo il nostro ruolo all’interno di esso molto seriamente.</p>
<p>I nostri principali obiettivi con Hord sono la sicurezza, l’esperienza utente e il rendimento reale di cui parleremo più avanti.</p>
<h3 id="h3-Q320Puoi20dirci20di20pi20sul20programma20per20i20primi20adottanti20di20Hord665162"><a name="Q3: Puoi dirci di più sul programma per i primi adottanti di Hord?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Puoi dirci di più sul programma per i primi adottanti di Hord?</h3><p>Sì. Per celebrare il lancio pubblico del nostro Pool, offriamo ai nostri primi utenti alcuni incentivi entusiasmanti.</p>
<p>Prima di tutto, abbiamo temporaneamente aggiunto il nostro token di protocollo, HORD, al pool.</p>
<p>Quindi, quando si mette in staking ETH, oltre a ricevere hETH, i primi utenti riceveranno anche token HORD.</p>
<p>In secondo luogo, ci siamo associati a Galxe e Airdrop.io per una campagna di airdrop entusiasmante. Gli utenti precoci che completano diverse azioni all’interno della nostra app e della nostra comunità guadagneranno punti che andranno verso un airdrop di HORD.</p>
<p>Chiunque desideri partecipare al nostro programma di adozione anticipata è invitato a unirsi alla nostra comunità Discord dove è possibile ottenere tutti i dettagli. Puoi trovare il <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> nel nostro Twitter o sul sito web - <a href="https://www.hord.fi/" rel="nofollow noopener noreferrer" target="_blank">https://www.hord.fi/</a></p>
<h3 id="h3-Q420Qual2020il20ruolo20del20token20in20tutto20questo625771"><a name="Q4: Qual è il ruolo del token in tutto questo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Qual è il ruolo del token in tutto questo?</h3><p>Come stavo dicendo prima, prendiamo molto seriamente la nostra responsabilità nel mantenere una blockchain Ethereum sana.</p>
<p>Crediamo che sia fondamentale che lo spazio sia il più aperto e decentralizzato possibile.</p>
<p>Il nostro token HORD svolge un ruolo importante nell’aiutare il nostro protocollo a passare a essere decentralizzato.</p>
<p>I detentori di HORD saranno in grado di proporre e votare sulle decisioni chiave all’interno di Hord, aiutandoci a garantire la sicurezza di noi stessi e di tutto lo spazio.</p>
<p>Ora inoltre, vorrei presentare Real Yield, una delle nostre caratteristiche più entusiasmanti su Hord, che riteniamo ci distingua davvero dal resto.</p>
<p>Come stavo dicendo, è molto importante per noi aprire la nostra piattaforma alla comunità.</p>
<p>Stiamo facendo questo attraverso la governance.</p>
<p>Vediamo la governance come un servizio che la nostra comunità ci fornisce.</p>
<p>Stanno dedicando tempo e attenzione nell’aiutare il protocollo a rimanere sicuro e bilanciato.</p>
<p>Vogliamo incentivare membri intelligenti e ambiziosi a unirsi al nostro viaggio e aiutare la crescita e lo sviluppo della nostra comunità.<br>Ecco perché stiamo introducendo un rendimento reale, che sarà implementato più avanti quest’anno.</p>
<p>Il Real Yield è un impegno da parte nostra di condividere le nostre entrate da Hord con la comunità.</p>
<p>Funzionerà molto semplicemente.</p>
<p>Il protocollo Hord raccoglie il 10% delle ricompense guadagnate dai nostri validatori.</p>
<p>Dopo aver contabilizzato le spese necessarie per il funzionamento della rete. Cose come i costi di manutenzione, la fornitura di liquidità, ecc…<br>I fondi rimanenti saranno divisi al 50% tra i possessori di HORD e la fondazione operativa Hord.<br><img src="https://gimg2.gateimg.com/image/article/16914891605.png" alt=""><br>Crediamo che questa sarà un’opportunità estremamente entusiasmante per gli utenti di criptovalute che credono nel futuro dello staking di ETH e vogliono unirsi e costruire con noi.</p>
<h3 id="h3-Q520Con20laggiornamento20di20Dencun20allorizzonte20come20sfrutter20Hord20questa20hard20fork20di20Ethereum833511"><a name="Q5: Con l’aggiornamento di Dencun all’orizzonte, come sfrutterà Hord questa hard fork di Ethereum?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Con l’aggiornamento di Dencun all’orizzonte, come sfrutterà Hord questa hard fork di Ethereum?</h3><p>Quindi c’è ancora molto da esplorare riguardo all’aggiornamento Dencun, ma ci sono alcuni punti che diventeranno chiaramente importanti per ciò che stiamo costruendo presso Hord.</p>
<p>Stiamo seguendo da vicino ciò che viene lavorato con Proto-Dank-Sharding, per quanto riguarda la riduzione dei costi delle transazioni L2.</p>
<p>Di recente abbiamo migrato gran parte della nostra liquidità dei token su Arbitrum e stiamo esplorando ulteriori modi per integrare Arbitrum con il nostro prodotto principale.</p>
<p>È ancora abbastanza presto per fornire dettagli sufficienti, ma suggerirei a chiunque interessato di seguirci su Twitter e unirsi ai nostri canali Discord per rimanere aggiornato.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Rio Fu.</strong>, Comunità Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti 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 citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>