R2F0ZS5pbyBBTUEgbWV0IEhvcmQgLSBPdXRwZXJmb3JtIGRlIG1hcmt0IG1ldCBIb3JkJ3MgZ2V0b2tlbmlzZWVyZGUgcG9vbHM=

<p><img src="https://gimg2.gateimg.com/image/article/16787781041.jpeg" alt=""><br><strong>Tijd: 13 maart 2023, 12:30 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> heeft een AMA (Ask-Me-Anything) sessie gehost met Erez Ben Kiki, CEO van Hord, en Meir Rosenschien, Product Manager van Hord in de <a href="https://twitter.com/i/spaces/1lPJqBwaLDwxb" rel="nofollow noopener noreferrer" target="_blank">Twitter Space</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>Twitter: <a href="https://twitter.com/HordAp" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/HordAp</a></strong><br><strong>Volg Hord op <a href="https://t.me/hordnews" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://twitter.com/HordApp" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Gasten</strong><img src="https://gimg2.gateimg.com/image/article/16787783012.jpg" alt=""><br><strong>Erez Ben Kiki - CEO van Hord</strong><img src="https://gimg2.gateimg.com/image/article/16787783373.jpg" alt=""><br><strong>Meir Rosenschien - Product Manager van Hord</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio665507"><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-Q120Wat20is20HORD497770"><a name="Q1: Wat is HORD?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Wat is HORD?</h3><p><img src="https://gimg2.gateimg.com/image/article/16787783734.png" alt=""><br>Hord is een multi-product platform voor getokeniseerde pools. De huidige belangrijkste focus bij Hord is ons vloeibare ETH staking platform en hETH dat de hoogste APR’s biedt. Momenteel bevindt het ETH staking platform zich in een community soft launch modus. De openbare lancering van Hord’s staking platform komt binnenkort. Andere implementaties van Hord’s protocol voor getokeniseerde pools zijn Viking DAO, een investerings-DAO die zich richt op Web3-projecten in de beginfase. Viking DAO is volledig ontwikkeld en zal worden gelanceerd zodra het Hord-team verbeterde omstandigheden in de cryptomarkt opmerkt.</p>
<h3 id="h3-V220Kunt20u20meer20uitleggen20over20Hords20ETH20Staking650433"><a name="V2: Kunt u meer uitleggen over Hord’s ETH Staking?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V2: Kunt u meer uitleggen over Hord’s ETH Staking?</h3><p>Hord is in staat om veel hogere APR’s te bieden dan concurrerende platforms door ETH-staking beloningen, MEV-boosts, automatisch samengestelde rente, en extra HORD-tokenbeloningen te combineren. De publieke lancering van Hord’s vloeibare ETH-staking platform komt binnenkort.<br><img src="https://gimg2.gateimg.com/image/article/16787783615.png" alt=""><br>Een ander voordeel van het vastzetten van ETH met Hord is de grotere decentralisatie van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> de validatorpool van ‘s. Momenteel wordt het toonaangevende vloeibare ETH-stakingsplatform beheerd door 23% van alle validators, wat vragen kan oproepen over decentralisatie. Degenen die ETH staken bij Hord dragen bij aan een grotere decentralisatie van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<h3 id="h3-Q320In20welke20fase20bevindt20het20platform20zich425648"><a name="Q3: In welke fase bevindt het platform zich?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: In welke fase bevindt het platform zich?</h3><p>Hord’s vloeibare ETH-stakingsplatform wordt in een zachte gemeenschapsintroductie gelanceerd. Onze gemeenschap kan ETH inzetten en het platform uitproberen. De zachte gemeenschapsintroductie zal niet alle functionaliteiten van de openbare introductie hebben, maar om dat te compenseren, bieden we zelfs hogere APR’s aan.</p>
<h3 id="h3-Q420Wat20is20de20rol20van20de20token20in20dit20alles991482"><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>Validators - Na de publieke lancering van Hord’s vloeibare ETH-stakingplatform kunnen gebruikers hun eigen validator lanceren, wat een bepaalde hoeveelheid ETH en Hord vereist.</p>
<p>Governance - Hord tokens zullen worden gebruikt voor governance beslissingen op het Hord platform, waarbij ze de toekomst vormgeven.</p>
<p>Viking DAO Inkoop, vernietigingen - Viking DAO zal binnenkort worden gelanceerd, en daarmee zullen Hord-token inkoop en vernietigingen gepaard gaan.</p>
<p>Vroege opnames - De Shanghai hard fork voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> wordt binnenkort verwacht. Wanneer ETH-opnames zijn toegestaan, kunnen gebruikers Hord-tokens inzetten voor vroegtijdige opnames zonder afkoelperiode.</p>
<h3 id="h3-Q520Wat20zijn20deze20andere20producten618383"><a name="Q5: Wat zijn deze andere producten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Wat zijn deze andere producten?</h3><p>Het protocol van Hord voor getokeniseerde pools kan op verschillende creatieve manieren worden geïmplementeerd. De oorspronkelijke implementatie van Hord was Champions pools, een platform waar iedereen de transacties van bekende handelaren en influencers kon volgen. Champion’s pools zullen in de toekomst worden gelanceerd na het vloeibare ETH-stakingplatform en Viking DAO.</p>
<p>Private pools zijn een vergelijkbare implementatie, hoewel het bedoeld is voor hedgefondsen, DAO’s en VC’s. Met Private pools kunnen fondsen hun portefeuille en wijzigingen daarvan uitzenden naar hun cliënten. Private pools kunnen elke door een fonds gevraagde EVM ondersteunen en het fonds kan deelnemers beperken, samen met andere functies. Private pools zullen ook binnenkort worden gelanceerd na Viking DAO.</p>
<p>Viking DAO is het volgende Hord-product dat zal worden uitgebracht. Viking DAO is een investerings-DAO die zich richt op een pool van 20 verschillende vroege Web3-projecten. De unieke waarde van Viking DAO is dat tokens van deze vroege projecten worden gekocht in de zaadfasen, wat betekent dat hun prijzen veel lager zullen zijn dan IDO’s. Viking DAO richt zich op maximaal 20 projecten omdat dit de winstgevendheid beschermt in g van een mislukt project.</p>
<p>Hord’s DEX komt binnenkort. Met Hord’s DEX kunnen gebruikers alle tokens die verband houden met Hord verhandelen in een eenvoudig orderboek.</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 mening van de onderzoeker en vormt geen beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>