R2F0ZS5pbyBBTUEgbWV0IFlJTi1NYWFrIG1vb2llIGdlc3RydWN0dXJlZXJkZSBmaW5hbmNpw6tsZSBwcm9kdWN0ZW4gaW4gZ2VkZWNlbnRyYWxpc2VlcmRlIGZpbmFuY2nDq24=

<p><img src="https://gimg2.gateimg.com/image/article/16872432241.jpeg" alt=""><br><strong>Tijd: 3 december 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Marco, BD van YIN Finance in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io-uitwisselingsgemeenschap</a>.</strong><br><strong>Officiële website: <a href="https://yin.finance/" rel="nofollow noopener noreferrer" target="_blank">https://yin.finance/</a></strong><br><strong>Twitter: <a href="https://twitter.com/YinFinance" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/YinFinance</a></strong><br><strong>Volg YIN op <a href="https://twitter.com/YinFinance" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/YinFinance" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16872433982.png" alt=""><br><strong>Marco — BD van YIN Finance</strong></p>
<h2 id="h2-Vragen20en20antwoorden20van20Gateio115536"><a name="Vragen en antwoorden van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vragen en antwoorden van Gate.io</h2><h3 id="h3-Q120Kun20je20je20project20kort20introduceren20alsjeblieft899200"><a name="Q1: Kun je je project kort introduceren alsjeblieft?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je je project kort introduceren alsjeblieft?</h3><p><img src="https://gimg2.gateimg.com/image/article/16872434413.png" alt=""><br><strong>Marco</strong>: YIN Finance is een multi-strategisch NFT-liquiditeitsbeheerplatform dat gebruikers in staat stelt zich te abonneren op liquiditeitsbeheerstrategieën om effectieve hoogrenderende te behalen. We streven ernaar proactieve liquiditeitsbeheerdiensten te bieden op verschillende openbare ketens en gedecentraliseerde beurzen. Momenteel gaan we implementeren op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> MainNet, vervolgens hebben we plannen om te lanceren op BSC, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, Arbitrum, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en <a href="/price/harmony-one" rel="nofollow noopener noreferrer" target="_blank">Harmonie</a>.</p>
<h3 id="h3-Q220Kun20je20jezelf20en20het20team20achter20YIN20Finance20voorstellen559550"><a name="Q2: Kun je jezelf en het team achter YIN Finance voorstellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kun je jezelf en het team achter YIN Finance voorstellen?</h3><p><strong>Marco</strong>: Mijn naam is Marco en ik ben verantwoordelijk voor externe communicatie en samenwerking in het YIN Finance-team. Ik ben voornamelijk verantwoordelijk voor onze wereldwijde marketingstrategie, gebruikersgroei, project samenwerking en pitches aan Venture Capitals.<br>We zijn een anoniem team. Het team van YIN Finance bestaat uit verschillende ‘wetenschappers’, elk met een uitgebreide ervaring op het gebied van DeFi-ontwikkeling en community white hat. Onze teamleden hebben veel ervaring in DeFi-projectontwikkeling, professionele liquiditeitsstrategieën en ervaring in smart contract auditing, waardoor de veiligheid en financiële opbrengst van ons project worden gewaarborgd.</p>
<h3 id="h3-Q320En20de20naam20is20erg20interessant20Waar20komt20de20projectnaam20vandaan20Waarom20heb20je20die20naam20voor20je20project20gekozen479490"><a name="Q3: En de naam is erg interessant… Waar komt de projectnaam vandaan? Waarom heb je die naam voor je project gekozen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: En de naam is erg interessant… Waar komt de projectnaam vandaan? Waarom heb je die naam voor je project gekozen?</h3><p><strong>Marco</strong>: De naam YIN is afgeleid van de oude Chinese filosofie van yin en yang - het concept van dualisme, dat beschrijft hoe tegenovergestelde of tegenstrijdige krachten eigenlijk complementair, onderling verbonden en onderling afhankelijk kunnen zijn in de natuurlijke wereld. Dit is bijna een perfecte representatie van wat een liquiditeitspool is, omdat het een balans vereist van twee activa die aan een pool worden toegevoegd. Als een activum begint af te nemen in volume, wordt de prijs verhoogd tot een niveau waar evenwicht wordt hersteld tussen beide activa - vandaar een yin-yang soort balans.</p>
<h3 id="h3-Laten20we20dus20wat20dieper20ingaan20op20het20product20zelf2020zou20u20verder20willen20uitweiden20over20YIN20Finance20en20welke20verschillende20functies20kunnen20gebruikers20zoals20wij20verwachten488284"><a name="Laten we dus wat dieper ingaan op het product zelf … zou u verder willen uitweiden over YIN Finance en welke verschillende functies kunnen gebruikers zoals wij verwachten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Laten we dus wat dieper ingaan op het product zelf … zou u verder willen uitweiden over YIN Finance en welke verschillende functies kunnen gebruikers zoals wij verwachten?</h3><p><strong>Marco</strong>: YIN Finance bestaat uit 4 modules: (1) YIN, dat is de governance token; (2) YANG, de persoonlijke kluis van de gebruiker; (3) CHI, de programmeerbare strategieën en (4) Grand Master, het hefboomfonds. We kunnen actief liquiditeitsbeheer, automatische herinvestering en yield farming diensten aanbieden voor gebruikers.</p>
<p>CHI is het belangrijkste module omdat het de kerncompetitieve voordeel van YIN Finance is om rendement te genereren voor gebruikers. De strategieën die via CHI worden ingezet, zijn geraffineerd ontworpen door Shadow Labs, een instelling die gespecialiseerd is in het strategiseren van structurele financiële producten, zelfs in traditionele markten. Verwacht wordt dat YIN Finance in Q1 2022 een open platform zal zijn waar gebruikers hun eigen strategie kunnen creëren en anderen kunnen abonneren!</p>
<h3 id="h3-Vraag20520En20dus20waarom20zou20ik20YINtoken20kopen20en20vasthouden20Wat20zijn20de20voordelen5350"><a name="Vraag 5: En dus, waarom zou ik YIN-token kopen en vasthouden? Wat zijn de voordelen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 5: En dus, waarom zou ik YIN-token kopen en vasthouden? Wat zijn de voordelen?</h3><p><strong>Marco</strong>: Voor onze YIN-token zijn er 5 belangrijke toepassingen zoals hieronder, zij moeten de redenen rechtvaardigen waarom je YIN-token zou moeten vasthouden!</p>
<p>$YIN kan worden gestaked in de YIN Stake Pool waar gebruikers in staat zullen zijn om gedistribueerde transactiekosten van het platform te verdienen;</p>
<p>$YIN-houders komen in aanmerking voor het bestuur van DAO (Decentralized Autonomous Organization) met stemrechten voor voorstellen en updates, evenredig met het bedrag dat ze bezitten;</p>
<p>Gebruikers kunnen hefboomwerking toevoegen aan hun gehefboomde liquiditeitspool, in verhouding tot het bedrag dat ze vasthouden;</p>
<p>Gebruikers ontvangen ook winsten uit liquidatie binnen geheven liquiditeitspools;<br><img src="https://gimg2.gateimg.com/image/article/16872434494.png" alt=""><br>$YIN is ook vereist bij het maken van gepersonaliseerde slimme strategie CHI’s in YIN Finance MainNet V2.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Gemeenschap<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 alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan, mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>