R2F0ZS5pbyBBTUEgY29uIERlRmkgRm9yIFlvdSAtIFBpYXR0YWZvcm1hIGRpIEZpbmFuemEgQmFzYXRhIHN1IEFzc2V0IGUgVHJhZGluZyBkaSBORlQgc3UgQlND

<p><img src="https://gimg2.gateimg.com/image/article/16850110871.jpg" alt=""><br><strong>Ora: 20 gennaio 2022, 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 William Gray, CMO di DeFi For You in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di Gate.io Exchange</a>.</strong><br><strong>Sito Web Ufficiale: <a href="http://www.defiforyou.uk/" rel="nofollow noopener noreferrer" target="_blank">http://www.defiforyou.uk/</a></strong><br><strong>Cinguettare: <a href="https://twitter.com/DeFiForYou" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/DeFiForYou</a></strong><br><strong>Segui DeFi For You su <a href="https://twitter.com/DeFiForYou" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/DeFiForYou_English" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16850112802.png" alt=""><br><strong>William Gray - CMO di DeFi For You</strong></p>
<h2 id="h2-QampA20da20Gateio512144"><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-Q120Cos20DEFI20per20te306968"><a name="Q1: Cos’è DEFI per te?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Cos’è DEFI per te?</h3><p><strong>William</strong>: DeFi For You è una piattaforma di finanza crittografica basata su asset e di trading NFT. Gli utenti possono scambiare e prendere in prestito asset digitali e fisici utilizzando una combinazione unica di DeFi e prestiti garantiti tramite i nostri partner.</p>
<h3 id="h3-Q220Ok20interessantee20cosa20lo20rende20unico609767"><a name="Q2: Ok interessante…e cosa lo rende unico?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Ok interessante…e cosa lo rende unico?</h3><p><strong>William</strong>: DeFi For You è uno dei pochissimi platform che lavora per portare beni fisici sulla blockchain tramite quello che chiamiamo ‘Hard NFT’. Si tratta di NFT di beni fisici che rappresentano la proprietà di un bene tangibile nel mondo reale. Consentiamo alle persone di scambiare e prendere in prestito contro questi Hard NFT, nonché asset cripto.</p>
<p>Abbiamo anche una licenza FCA dal Regno Unito per facilitare le attività finanziarie basate su asset, il che significa che possiamo essere al di sopra delle autorità di regolamentazione in futuro. Si tratta di una licenza che progetti come Binance hanno difficoltà a ottenere, e averla ci permette di rendere il progetto a prova di futuro contro le repressioni normative.</p>
<h3 id="h3-Q320Puoi20spiegare20di20pi20riguardo20agli20Hard20NFT2020come20sapranno20gli20utenti20che20sono20autentici660099"><a name="Q3: Puoi spiegare di più riguardo agli Hard NFT - come sapranno gli utenti che sono autentici?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Puoi spiegare di più riguardo agli Hard NFT - come sapranno gli utenti che sono autentici?</h3><p><strong>William</strong>: Certo. Ci affidiamo a una rete di partnership con rivenditori autorizzati e verificati che possono unirsi al nostro ecosistema per conservare, assicurare e tokenizzare beni fisici. Lavoriamo con gioiellieri, pegni, rivenditori di orologi e altri per garantire che gli asset siano conservati in modo sicuro con un’azienda affidabile. Non tutti possono diventare partner di DeFi For You, devono avere un’attività affidabile e autorizzata.</p>
<p>Gli utenti possono portare i loro asset a questi partner dopo aver inviato loro una ‘richiesta di valutazione degli asset’ attraverso la nostra piattaforma, quindi questi asset possono essere conservati e tokenizzati, dopodiché possono essere aggiunti al nostro mercato NFT. Se l’asset fisico viene mai richiesto, l’NFT viene bruciato per garantire che non possa essere utilizzato in modo fraudolento.</p>
<p>Questi Hard NFT possono essere venduti, messi all’asta o utilizzati come garanzia per un prestito stabile in criptovaluta. L’idea principale è collegare gli asset fisici delle persone a DeFi. Non è stato un compito facile a causa della logistica esterna coinvolta, ma siamo vicini ora a implementare un sistema globale per questo. Domani lanceremo un’importante aggiornamento del nostro sito web, mostrando un primo sguardo a queste funzionalità e ai prestiti contro gli NFT ‘tradizionali’ (se gli NFT possono essere definiti tradizionali haha) anche.</p>
<h3 id="h3-Q420Questo2020un20concetto20molto20interessante20E20sembra20che20tu20stia20lavorando20su20molto20Cosa20sta20facendo20DeFi20For20You20per20portare20valore20allecosistema20crittografico135547"><a name="Q4: Questo è un concetto molto interessante!! E sembra che tu stia lavorando su molto… Cosa sta facendo DeFi For You per portare valore all’ecosistema crittografico?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Questo è un concetto molto interessante!! E sembra che tu stia lavorando su molto… Cosa sta facendo DeFi For You per portare valore all’ecosistema crittografico?</h3><p><strong>William</strong> Stiamo anche facendo un’importante campagna per integrare un nuovo progetto crittografico al giorno nel nostro protocollo di prestito P2P crittografico. Stiamo consentendo ai detentori del token di ottenere prestiti con stablecoin contro progetti su BSC e oltre, il che significa che hanno più casi d’uso per il token e i detentori possono finanziare i loro asset senza venderli.</p>
<p>Il nostro obiettivo è di portare questo a quanti più progetti possibili sulla Binance Smart Chain e altrove, in modo che abbiano maggiore utilità per i loro token e in modo che possiamo diventare il punto di riferimento per le persone che vogliono prendere in prestito contro asset cripto che spesso non si trovano su altre piattaforme DeFi.</p>
<p>Abbiamo anche recentemente lanciato il nostro marketplace NFT (chi non l’ha fatto in questa fase?!) ma avremo qualcosa di più succoso in questo:</p>
<ol>
<li>Prima di tutto, gli utenti potranno acquistare Hard NFT con asset fisici sottostanti</li><li>In secondo luogo, gli utenti potrebbero trovare NFT che i prestatori hanno acquisito attraverso prestiti DeFi in default, il che significa che cercheranno di venderli rapidamente per recuperare il proprio capitale (questo è simile al modo in cui una banca vende una casa pignorata a un prezzo inferiore rispetto al tasso di mercato).</li></ol>
<p>Il mercato NFT è molto nuovo (come appena una settimana fa) quindi è ancora ‘fresco’, ma siamo molto entusiasti di mettere alcuni NFT solidi lì quando vengono lanciati!</p>
<h3 id="h3-Q520Ok20e20per20concludere20prima20di20passare20alle20domande20del20nostro20pubblico20avete20annunci20importanti20in20arrivo640009"><a name="Q5: Ok e per concludere prima di passare alle domande del nostro pubblico, avete annunci importanti in arrivo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Ok e per concludere prima di passare alle domande del nostro pubblico, avete annunci importanti in arrivo?</h3><p><strong>William</strong>: Abbiamo diversi progetti in corso:<br>🔸 Oggi abbiamo annunciato una partnership con Uno Re, un protocollo di assicurazione NFT<br>🔸 Abbiamo parlato ai nostri partner bancari che stiamo integrando in Ucraina oggi:</p>
<p>Recentemente abbiamo ottenuto una partnership con una banca in Ucraina, una nazione che sta legalizzando le criptovalute. La partnership ci permetterà di costruire un ponte tra il mondo bancario e il mondo DeFi e puntiamo a costruire in futuro un exchange di cripto-attività di prossima generazione con loro.</p>
<p>Annunceremo anche due partnership con importanti aziende di pegni nel Regno Unito.</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 alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripostare l'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>