Z2F0ZUxpdmUgQU1BIFJlY2FwIC0gT3BlblNreSBGaW5hbmNl

2024-02-08, 05:59

<p><img src="https://gimg2.gateimg.com/image/article/1707371933blog.jpg" alt=""></p>
<h2 id="h2-Presentati20e20il20team20dietro20OpenSky523044"><a name="Presentati e il team dietro OpenSky?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Presentati e il team dietro OpenSky?</h2><p>Robbie - Prima persona al mondo a conseguire una laurea magistrale nei mercati finanziari e nel trading<br>Ha appreso i derivati a Chicago, la capitale mondiale dei futures. Venduto allo scoperto dimensioni (per me) sugli futures dell’indice azionario small cap Russell 2000.9⁄11, guadagnato abbastanza da trasferirmi in Asia nel 2001 e da allora sono qui.</p>
<p>Ha lavorato per il più grande fondo speculativo in Vietnam come Direttore del <a href="/price/quant-qnt" target="_blank" class="blog_inner_link">Quant</a> Trading, ha scoperto che la liquidità è un fattore critico per <a href="/price/quant-qnt" rel="nofollow noopener noreferrer" target="_blank">Quant</a> modelli di trading, in particolare modelli basati sul momentum.</p>
<p>Sono entrato nel DeFi circa 3 anni fa e ho provato tutto. Il mio ultimo interesse, oltre a lavorare su OpenSky, è l’arbitraggio del tasso di finanziamento tra perpDEXes come <a href="/price/gmx-gmx" rel="nofollow noopener noreferrer" target="_blank">GMX</a> su Arbitrum e Drift su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>.</p>
<p>Credere in DeFi, soprattutto nell’idea di eliminare i costosi intermediari umani e concedere alle persone comuni di tutto il mondo la possibilità di effettuare transazioni finanziarie (trasparenza, componibilità, accessibilità e inclusività).</p>
<p>Il team è multiculturale, a fuso orario multiplo. Include persone provenienti dall’Europa occidentale e orientale, dall’America e dall’Asia.</p>
<p>Sviluppatori e designer sono nativi digitali e full-stack.<br>Dima</p>
<h2 id="h2-Qual2020opensky20e20cosa20risolve20e20quali20sono20i20tuoi20obiettivi547395"><a name="Qual è opensky e cosa risolve e quali sono i tuoi obiettivi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è opensky e cosa risolve e quali sono i tuoi obiettivi?</h2><p>OpenSky è il protocollo di prestito omnichain NFT alimentato da <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a>, la nostra visione è quella di aiutare gli appassionati di NFT su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e altre catene leader per sbloccare e mettere in circolazione i loro preziosi NFT con un’elevata efficienza di capitale e senza rischio di liquidazione basato sul prezzo.</p>
<p>5 punti chiave per spiegare ulteriori dettagli</p>
<ol>
<li>Prestito NFT - NFT spazio e futuro RWA, tutto sarà tokenizzato</li><li>omnichain - <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Bitcoin, Solana, Blast e Arbitrum - qualsiasi catena, qualsiasi asset</li><li>Ibrido - offre due tipi di prestiti: peer-to-pool e peer-to-peer, abbiamo risolto i problemi di meccanismo singolo: come l’efficienza peer-to-peer e peer-to-pool non sono buoni per NFT rari e problemi di liquidazione a cascata.</li><li>Liquidazione basata sul tempo - a causa del fatto che gli NFT sono diversi dagli FT, il metodo basato sulla liquidità non è una buona soluzione, non puoi dormire bene. Basato sul tempo: user friendly e senza liquidazione a cascata. I creditori sono protetti con garanzie e aste. Grazie alla liquidazione basata sul tempo, c’è meno rischio di liquidazione a cascata basata su un unico prezzo minimo. Non mettere tutte le uova nello stesso paniere.</li><li>Alimentato da <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> - OpenSky è costruito con DeFi componibilità su Aave. Vantaggio reciproco per Aave e OpenSky.</li></ol>
<h2 id="h2-Potresti20fornire20una20breve20panoramica20di20come20funziona20Quali20vantaggi20offre20questo20design20e20affronta20eventuali20problemi20presenti20negli20attuali20accordi20di20prestito20NFT93602"><a name="Potresti fornire una breve panoramica di come funziona? Quali vantaggi offre questo design e affronta eventuali problemi presenti negli attuali accordi di prestito NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Potresti fornire una breve panoramica di come funziona? Quali vantaggi offre questo design e affronta eventuali problemi presenti negli attuali accordi di prestito NFT?</h2><p>Tutti i depositi vengono passati ad Aave, dove guadagnano istantaneamente e continuamente ricompense Aave e interessi dai prestiti tra pari e pool.</p>
<p>I prestatori possono utilizzare i loro depositi nel pool a rendimento, ciò che chiamiamo oToken, per accettare offerte esistenti o effettuare nuove offerte peer-to-peer per cercare di guadagnare un tasso di interesse più alto o cercare di ottenere la proprietà di un particolare NFT a un prezzo basso.</p>
<p>Altri protocolli di prestito NFT basati su pool sono meno efficienti in termini di capitale.</p>
<p>Altri protocolli di prestito NFT basati su pool affrontano il rischio di liquidazione a cascata. OpenSky risolve questo problema con il nostro innovativo meccanismo di pre-liquidazione.</p>
<p>Altri protocolli di prestito NFT peer-to-peer non sono efficienti perché molti prestatori competono per ogni mutuatario e solo un prestatore finanzierà il prestito e sarà felice.</p>
<h2 id="h2-Molte20persone20sono20interessate20al20modello20economico20del20token20Puoi20descriverlo81088"><a name="Molte persone sono interessate al modello economico del token. Puoi descriverlo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Molte persone sono interessate al modello economico del token. Puoi descriverlo?</h2><p>Tokenomics è semplicemente l’economia dei token. L’economia riguarda principalmente l’offerta e la domanda per vari mercati.</p>
<p>L’offerta è legata al vincolo e alla decentralizzazione della proprietà dei token. Non si desidera che gli investitori iniziali/il team si trovino in una posizione di scaricare tutto su di te. Inoltre, si preferisce che il tuo token sia detenuto da molti piccoli investitori invece di pochi grandi detentori di borse.</p>
<p>La domanda è legata al motivo per cui gli investitori o gli utenti hanno bisogno di HODL il token.</p>
<p>Esempi includono</p>
<p>1) staking per una quota di ricavi reali pagati in ETH, BTC e stables.</p>
<p>2) Diritti di governance preziosi, come il controllo del tesoro, le modifiche alla condivisione dei ricavi, l’inflazione dell’offerta di token e il voto sui parametri del protocollo</p>
<p>3) Sbloccare i potenziali vantaggi per gli utenti, come la riduzione del tasso di interesse per i prestiti o l’aumento del tasso di fornitura.</p>
<p>Per quanto riguarda il modo in cui OpenSky genera ricavi, credo che dovremmo prima delineare i tre principali tipi di utenti all’interno di OpenSky. In OpenSky, ci sono principalmente tre categorie di utenti: Prestatori, Mutuatari e Detentori di OSKY. Per i prestatori, - rendimenti reali su BTC e ETH. Per i mutuatari, - Deposita i loro NFT per prendere in prestito ETH o BTC e possono usarlo altrove in DeFi o persino prestarlo su OpenSky ((Possibile prendere in prestito per guadagnare).</p>
<p>Per i detentori di OSKY, - Piattaforma centrata sulla comunità che riceve il 100% dei ricavi del protocollo saranno condivisi con gli staker di OSKY</p>
<h2 id="h2-Raccontaci20dei20tuoi20partner20e20di20come20hanno20influenzato20positivamente20OpenSky421642"><a name="Raccontaci dei tuoi partner e di come hanno influenzato positivamente OpenSky." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Raccontaci dei tuoi partner e di come hanno influenzato positivamente OpenSky.</h2><p>Partners<br>Aave: DeFI lego<br>Chainlink: Decentralized Oracle Price feed<br>NFTbank: Stime dei prezzi degli NFT basate sull’IA<br>OpenSea: Primo mercato di NFT<br>Layerzero: Collegamento omnichain tra NFT e FT<br>Blast Big Bang competition</p>
<p>6b. Investitori - Elenca qui i nostri VC<br>MetaCartel Ventures, Alphanonce, SnapFingers DAO, FBG Capital, SNZ Holding, Collinstar Capital tra gli altri.</p>
<h2 id="h2-Potresti20fornire20una20panoramica20dei20piani20di20sviluppo20di20OpenSky20Roadmap20per20i20prossimi20sei20mesi60426"><a name="Potresti fornire una panoramica dei piani di sviluppo di OpenSky (Roadmap) per i prossimi sei mesi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Potresti fornire una panoramica dei piani di sviluppo di OpenSky (Roadmap) per i prossimi sei mesi?</h2><ol>
<li>Lancio gratuito su BakerySwap</li><li>quotazione su DEX e scambi centralizzati con il supporto di una società di market making professionale con un focus sulla fornitura di alta liquidità</li><li>Supporto al prestito NFT su BTC per le principali collezioni NFT, come BitcoinCats NFTs.</li><li>Lancio del programma di punti Airdrop. I prestatori e i mutuatari possono fare farming di $OSKY e di altri token partner (ad es. $1CAT), e la tesoreria guadagnerà BTC ed ETH, parte dei quali verrà condivisa con gli stakers di OSKY.</li><li>Lancio del programma di staking a rendimento reale per $OSKY. Gli stakers di $OSKY possono condividere il ricavo del protocollo BTC ed ETH</li><li>Supporto al prestito NFT su <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> per le principali collezioni NFT di Solana.</li><li>Collaborazione con Blast per implementare il nostro prestito NFT omnichain sulla chain di Blast con tariffe gas basse. Una dAPP può gestire il prestito NFT omnichain.</li></ol>
<div class="blog-details-info"><br><div>Autore: <strong>GateLive</strong>, Team 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 ripubblicare l'articolo a condizione che venga menzionato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>