R2F0ZS5pbyBBTUEgbWV0IERlRmkgRm9yIFlvdS1Bc3NldC1CYXNlZCBGaW5hbmNlICYgTkZUIFRyYWRpbmcgUGxhdGZvcm0gb3AgQlND

<p><img src="https://gimg2.gateimg.com/image/article/16850110871.jpg" alt=""><br><strong>Tijd: 20 januari 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> heeft een AMA (Ask-Me-Anything) sessie gehouden met William Gray, CMO van DeFi For You in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële Website: <a href="http://www.defiforyou.uk/" rel="nofollow noopener noreferrer" target="_blank">http://www.defiforyou.uk/</a></strong><br><strong>Twitter: <a href="https://twitter.com/DeFiForYou" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/DeFiForYou</a></strong><br><strong>Volg DeFi For You op <a href="https://twitter.com/DeFiForYou" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/DeFiForYou_English" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16850112802.png" alt=""><br><strong>William Gray - CMO van DeFi For You</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio529356"><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-Q120Wat20betekent20DEFI20voor20jou504861"><a name="Q1: Wat betekent DEFI voor jou?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Wat betekent DEFI voor jou?</h3><p><strong>William</strong>: DeFi For You is een op activa gebaseerd crypto-financierings- en NFT-handelsplatform. Gebruikers kunnen handelen en lenen tegen digitale en fysieke activa met behulp van een unieke combinatie van DeFi en onderpandleningen via onze partners.</p>
<h3 id="h3-Q220Ok20interessant2020en20wat20maakt20het20uniek951933"><a name="Q2: Ok interessant … en wat maakt het uniek?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Ok interessant … en wat maakt het uniek?</h3><p><strong>William</strong>: DeFi For You is een van de zeer weinige platforms die werkt aan het brengen van fysieke activa naar de blockchain via wat we ‘Hard NFTs’ noemen. Dit zijn fysieke activa NFT’s die eigendom van een tastbaar goed in de echte wereld vertegenwoordigen. We staan mensen toe om te handelen en te lenen tegen deze Hard NFT’s, evenals crypto-activa.</p>
<p>We hebben ook een FCA-licentie uit het Verenigd Koninkrijk om activagebaseerde financieringsactiviteiten te vergemakkelijken, wat betekent dat we in de toekomst transparant kunnen zijn met regelgevers. Dit is een licentie waar projecten zoals Binance zelfs moeite mee hebben om te verkrijgen, en het hebben ervan stelt ons in staat het project te beschermen tegen regelgevingscrackdowns in de toekomst.</p>
<h3 id="h3-Q320Kun20je20meer20uitleg20geven20over20Hard20NFTs2020hoe20kunnen20gebruikers20weten20dat20ze20echt20zijn648100"><a name="Q3: Kun je meer uitleg geven over Hard NFT’s - hoe kunnen gebruikers weten dat ze echt zijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Kun je meer uitleg geven over Hard NFT’s - hoe kunnen gebruikers weten dat ze echt zijn?</h3><p><strong>William</strong>: Natuurlijk. We vertrouwen op een netwerk van partnerschappen met gelicentieerde en geverifieerde detailhandelaren die zich bij ons ecosysteem kunnen aansluiten om fysieke goederen op te slaan, te verzekeren en te tokeniseren. We werken samen met juweliers, pandjeshuizen, horlogehandelaren en anderen om ervoor te zorgen dat activa veilig worden opgeslagen bij een gerenommeerd bedrijf. Niet zomaar iedereen kan een partner worden van DeFi For You, ze moeten een gerenommeerd en gelicentieerd bedrijf hebben.</p>
<p>Gebruikers kunnen hun activa naar deze partners brengen nadat ze een ‘waardebepalingsverzoek voor activa’ via ons platform hebben verzonden. Vervolgens kunnen deze activa worden opgeslagen en getokeniseerd, waarna ze aan onze NFT-marktplaats kunnen worden toegevoegd. Als de fysieke activa ooit worden opgeëist, wordt de NFT verbrand om ervoor te zorgen dat deze niet frauduleus kan worden gebruikt.</p>
<p>Deze Hard NFT’s kunnen worden verkocht, geveild of gebruikt als onderpand voor een stablecoin-lening. Het belangrijkste idee is om de fysieke activa van mensen te verbinden met DeFi. Het is geen gemakkelijke taak geweest vanwege de logistiek buiten de keten, maar we staan nu dicht bij de implementatie van een wereldwijd systeem hiervoor. We zullen morgen een belangrijke update van onze website lanceren, waarin een eerste glimp van deze functies te zien is, evenals leningen tegen ‘traditionele’ NFT’s (als NFT’s traditioneel genoemd kunnen worden haha).</p>
<h3 id="h3-Q420Dat20is20een20behoorlijk20interessant20concept20En20het20lijkt20erop20dat20je20aan20veel20dingen20werkt20Wat20doet20DeFi20For20You20nog20meer20om20waarde20te20brengen20in20het20cryptoecosysteem248363"><a name="Q4: Dat is een behoorlijk interessant concept!! En het lijkt erop dat je aan veel dingen werkt… Wat doet DeFi For You nog meer om waarde te brengen in het crypto-ecosysteem?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Dat is een behoorlijk interessant concept!! En het lijkt erop dat je aan veel dingen werkt… Wat doet DeFi For You nog meer om waarde te brengen in het crypto-ecosysteem?</h3><p><strong>William</strong>: We zijn ook bezig met een grote campagne om elke dag één nieuw crypto project aan boord te krijgen in ons crypto P2P leningprotocol. We stellen houders van de token in staat om stabiele munt leningen te krijgen tegen projecten op BSC en daarbuiten, wat betekent dat ze meer gebruiksmogelijkheden hebben voor de token en houders hun activa kunnen financieren zonder ze te verkopen.</p>
<p>Ons doel is om dit naar zoveel mogelijk projecten op de Binance Smart Chain en elders te brengen, zodat ze meer nut hebben voor hun tokens, en zodat we de plek worden waar mensen naartoe gaan om te lenen tegen crypto-activa die vaak niet te vinden zijn op andere DeFi-platforms.</p>
<p>We hebben ook onlangs onze eigen NFT-marktplaats gelanceerd (wie heeft dat niet op dit moment?!) maar we hebben iets sappigers in deze:</p>
<ol>
<li>Ten eerste kunnen gebruikers winkelen voor Hard NFT’s met fysieke activa als basis</li><li>Ten tweede kunnen gebruikers NFT’s vinden die geldverstrekkers hebben verworven via niet-nakoming van DeFi-leningen, wat betekent dat ze ze snel zullen proberen te verkopen om hun kapitaal terug te krijgen (dit is vergelijkbaar met hoe een bank een in beslag genomen huis verkoopt voor minder dan de marktwaarde).</li></ol>
<p>De NFT-marktplaats is nog erg nieuw (ongeveer een week oud), dus het is nog ‘vers’, maar we zijn erg enthousiast om enkele harde NFT’s daar te krijgen wanneer ze gelanceerd worden!</p>
<h3 id="h3-Q520Ok20en20om20het20af20te20ronden20voordat20we20doorgaan20naar20vragen20van20ons20publiek20Heeft20u20binnenkort20nog20belangrijke20aankondigingen822210"><a name="Q5: Oké, en om het af te ronden voordat we doorgaan naar vragen van ons publiek, Heeft u binnenkort nog belangrijke aankondigingen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Oké, en om het af te ronden voordat we doorgaan naar vragen van ons publiek, Heeft u binnenkort nog belangrijke aankondigingen?</h3><p><strong>William</strong>: We hebben er enkele in de maak:<br>🔸 Vandaag hebben we een partnerschap aangekondigd met Uno Re, een NFT-verzekeringsprotocol<br>🔸 We hebben vandaag gesproken met onze bankpartners waarmee we samenwerken in Oekraïne:</p>
<p>We hebben onlangs een partnerschap gesloten met een bank in Oekraïne, een land dat bezig is met de legalisering van cryptocurrency. Het partnerschap stelt ons in staat om een brug te slaan tussen de wereld van bankwezen en DeFi en we streven ernaar om in de toekomst samen met hen een crypto-assetbeurs van de volgende generatie op te zetten.</p>
<p>We zullen ook twee partnerschappen aankondigen met grote pandjeshuizen in het Verenigd Koninkrijk.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>