R2F0ZS5pbyBBTUEgbWV0IEhvcmQtRWVudm91ZGlnLCBWZWlsaWcgZW4gVmxvZWliYWFyIEV0aGVyZXVtIFN0YWtlbiBtZXQgZGUgQmVzdGUgQVBS

<p><img src="https://gimg2.gateimg.com/image/article/16914889041.jpg" alt=""><br><strong>Tijd: 7 augustus 2023 om 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> gehost een AMA (Ask-Me-Anything) sessie met Erez Ben Kiki, CEO van Hord en Meir Rosenschien,Product Manager van Hord in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Community</a>.</strong><br><strong>Officiële website: <a href="https://www.hord.fi/" rel="nofollow noopener noreferrer" target="_blank">https://www.hord.fi/</a></strong><br><strong>Sjilpen: <a href="https://twitter.com/HordApp" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/HordApp</a></strong><br><strong>Volg Hord op <a href="https://twitter.com/HordApp" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/hordnews" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gasten</strong><img src="https://gimg2.gateimg.com/image/article/16914891042.jpg" alt=""><br><strong>Erez Ben Kiki — CEO van Hord</strong><img src="https://gimg2.gateimg.com/image/article/16914891223.jpg" alt=""><br><strong>Meir Rosenschien - Product Manager van Hord</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio559393"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-Q120Wat20is20HORD720373"><a name="Q1: Wat is HORD?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Wat is HORD?</h3><p>Hord is meer dan 2 jaar geleden opgericht met als doel iedereen in staat te stellen geïndexeerde, getokeniseerde pools te maken voor hun cryptoinvesteringsstrategieën.</p>
<p>Met ‘getokeniseerd’ bedoel ik dat onze technologie mensen in staat stelt om een verhandelbaar actief, een token, te creëren dat een beleggingsstrategie bevat.</p>
<p>Of met andere woorden een token die een ander actief, of meerdere activa, vertegenwoordigt die in de loop van de tijd in waarde kunnen toenemen.</p>
<p>Toen we onze eerste versie lanceerden eind 2021, merkten we een verschuiving op de markt.</p>
<p>Onze gebruikers, samen met de rest van het cryptolandschap, werden terughoudend om activa te verhandelen. En nog belangrijker, ze werden veel aarzelender om hun eigen strategieën te tokeniseren en hun reputatie op het spel te zetten op een volatiele markt.</p>
<p>Maar terwijl dit allemaal plaatsvond, gebeurde er een zeer belangrijke ontwikkeling in de cryptoruimte. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De overgang van Proof of Work… naar Proof of Stake.</p>
<p>Plotseling was er een nieuwe vermogensklasse die voldeed aan onze criteria voor tokenisatie, en belangrijker nog, het was relatief immuun voor marktvolatiliteit.</p>
<p>Zo is het hETH-token geboren en daarmee ook de Hord’s Liquid ETH Staking Pool.</p>
<p>Het idee is heel simpel:<br>Gebruikers kunnen ETH storten in de pool.</p>
<p>In ruil daarvoor krijgen ze een token genaamd hETH, dat hun aandeel in de pool vertegenwoordigt.</p>
<p>We gebruiken de door gebruikers gestorte ETH om validators te laten draaien die helpen bij het bedienen van de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> blockchain.</p>
<p>In ruil daarvoor verdienen onze validators beloningen, extra ETH die weer in de pool wordt gestort.<br>Dus nu vertegenwoordigen gebruikershETH-tokens de ETH die ze hebben gestort + hun deel van de beloningen die in de pool zijn opgebouwd.<br><img src="https://gimg2.gateimg.com/image/article/16914891474.png" alt=""><br>We hebben in slechts een paar maanden meer dan 1.700 ETH gedeponeerd en we hebben een aantal productverbeteringen waar we erg trots op zijn en die in de komende maand zullen worden aangekondigd.</p>
<h3 id="h3-V220Nu20Ethereumstaking20aan20populariteit20wint20hoe20is20het20plan20van20Hord20om20concurrerend20te20blijven248153"><a name="V2: Nu Ethereum-staking aan populariteit wint, hoe is het plan van Hord om concurrerend te blijven?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V2: Nu Ethereum-staking aan populariteit wint, hoe is het plan van Hord om concurrerend te blijven?</h3><p>Allereerst wordt het Ethereum staking landschap inderdaad steeds competitiever.</p>
<p>Dit is een goede zaak.</p>
<p>Er is een zeer kritiek, inherent gevaar binnen Ethereum. Dat te veel van Ethereum’s validators - ook wel zijn verwerkingskracht, zal op één plaats worden gehouden.</p>
<p>Als dat gebeurt en er gaat iets mis (en helaas zijn we ons allemaal bewust van voorbeelden waarin dingen misgaan in de ruimte), kan dat niet alleen extreem slecht zijn voor Ethereum-houders, maar voor de hele cryptogemeenschap.</p>
<p>Dus we geloven dat concurrentie binnen de ETH staking ruimte erg belangrijk is. En we nemen onze rol daarin zeer serieus.</p>
<p>Onze fundamentele focus met Hord ligt op beveiliging, gebruikerservaring en werkelijk rendement waar we later wat dieper op in zullen gaan.</p>
<h3 id="h3-Q320Kun20je20ons20meer20vertellen20over20het20early20adopter20programma20van20Hord656951"><a name="Q3: Kun je ons meer vertellen over het early adopter programma van Hord?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Kun je ons meer vertellen over het early adopter programma van Hord?</h3><p>Ja. Om de publieke lancering van onze Pool te vieren, bieden we onze vroege gebruikers enkele spannende incentives aan.</p>
<p>Allereerst hebben we tijdelijk onze eigen protocoltoken, HORD, aan de pool toegevoegd.</p>
<p>Dus wanneer je ETH staket, ontvangen vroege gebruikers naast hETH ook HORD-tokens.</p>
<p>Ten tweede zijn we een partnerschap aangegaan met Galxe en Airdrop.io voor een spannende airdrop-campagne. Vroege gebruikers die verschillende acties voltooien binnen onze app en onze community zullen punten verdienen die zullen bijdragen aan een HORD-airdrop.</p>
<p>Iedereen die wil deelnemen aan ons vroege gebruikersprogramma is uitgenodigd om lid te worden van onze Discord-gemeenschap waar je alle details kunt vinden. Je kunt de <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> op onze Twitter of website - <a href="https://www.hord.fi/" rel="nofollow noopener noreferrer" target="_blank">https://www.hord.fi/</a></p>
<h3 id="h3-Q420Wat20is20de20rol20van20de20token20in20dit20alles182760"><a name="Q4: Wat is de rol van de token in dit alles?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Wat is de rol van de token in dit alles?</h3><p>Zoals ik al eerder zei, nemen we onze verantwoordelijkheid voor het onderhouden van een gezonde Ethereum-blockchain zeer serieus.</p>
<p>We geloven dat het cruciaal is dat de ruimte zo open en gedecentraliseerd mogelijk is.</p>
<p>Ons HORD-token speelt een belangrijke rol bij de overgang van ons protocol naar een dentralisatie.</p>
<p>Dus HORD-houders kunnen voorstellen doen en stemmen over belangrijke beslissingen binnen Hord, wat ons en de hele ruimte helpt beveiligen.</p>
<p>Daarnaast wil ik ook graag Real Yield introduceren, een van onze meest spannende functies bij Hord, waarmee we ons echt onderscheiden van de rest.</p>
<p>Zoals ik al zei, is het erg belangrijk voor ons om ons platform open te stellen voor de gemeenschap.</p>
<p>We doen dit via governance.</p>
<p>Wij beschouwen governance als een dienst die onze gemeenschap ons biedt.</p>
<p>Ze besteden tijd en aandacht om te helpen bij het veilig en in balans houden van het protocol.</p>
<p>We willen slimme, ambitieuze leden stimuleren om zich bij onze reis aan te sluiten en onze gemeenschap te laten groeien en ontwikkelen.<br>Daarom introduceren we echte opbrengst, die later dit jaar zal worden geïmplementeerd.</p>
<p>Real Yield is een toezegging van ons om onze inkomsten van Hord met de gemeenschap te delen.</p>
<p>Het zal heel eenvoudig werken.</p>
<p>Het Hord-protocol verzamelt 10% van de beloningen die onze validatoren verdienen.</p>
<p>Na aftrek van de kosten die nodig zijn om het netwerk te exploiteren. Dingen zoals onderhoudskosten, het bieden van liquiditeit, enz…<br>De resterende fondsen worden gelijk verdeeld tussen HORD-houders en de Hord Operating Foundation.<br><img src="https://gimg2.gateimg.com/image/article/16914891605.png" alt=""><br>We geloven dat dit een zeer spannende kans zal zijn voor crypto-gebruikers die geloven in de toekomst van ETH Staking en zich bij ons willen aansluiten en samen met ons willen bouwen.</p>
<h3 id="h3-Q520Met20de20Dencun20Upgrade20in20het20verschiet20hoe20zal20Hord20gebruikmaken20van20deze20Ethereum20hard20fork78756"><a name="Q5: Met de Dencun Upgrade in het verschiet, hoe zal Hord gebruikmaken van deze Ethereum hard fork?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Met de Dencun Upgrade in het verschiet, hoe zal Hord gebruikmaken van deze Ethereum hard fork?</h3><p>Dus er is nog behoorlijk wat voor ons te ontdekken met betrekking tot de Dencun-upgrade, maar er zijn een paar punten die duidelijk belangrijk zullen worden voor wat we bij Hord aan het bouwen zijn.</p>
<p>We volgen nauwlettend wat er wordt gewerkt aan Proto-Dank-Sharding, met betrekking tot het verminderen van L2 transactiekosten.</p>
<p>We hebben onlangs een groot deel van onze token-liquiditeit gemigreerd naar Arbitrum en we onderzoeken aanvullende manieren om Arbitrum te integreren met ons kernproduct.</p>
<p>Het is nog vrij vroeg voor ons om voldoende details te geven, maar ik zou iedereen die geïnteresseerd is aanraden om ons te volgen op Twitter en zich aan te sluiten bij onze Discord-kanalen om op de hoogte te blijven.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>