Z2F0ZUxpdmUgQU1BIFJlY2FwLUxhbmRYIEZpbmFuY2U=

2023-12-22, 06:26

<p><img src="https://gimg2.gateimg.com/image/article/1703226233blog.jpg" alt=""></p>
<h2 id="h2-Cos20LandX767546"><a name="Cos’è LandX?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è LandX?</h2><p><strong>LandWalker (Co-Fondatore di LandX Finance):</strong><br>LandX è un protocollo DeFi che colma il divario tra il finanziamento agricolo e gli asset del mondo reale tokenizzati.</p>
<p>LandX è un progetto che collega il divario tra il finanziamento agricolo e gli investitori di criptovalute. Collegando questi due settori insieme, i contadini del mondo reale sono in grado di ottenere il finanziamento di cui hanno bisogno in cambio della fornitura dei raccolti che hanno. Questi raccolti vengono quindi tokenizzati e resi disponibili agli investitori nativi di criptovalute alla ricerca di un rendimento reale e sostenibile.</p>
<h2 id="h2-Perch20LandX477368"><a name="Perché LandX?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché LandX?</h2><p><strong>LandWalker (Co-Fondatore di LandX Finance):</strong><br>LandX risolve due problemi critici.</p>
<p>Innanzitutto, forniamo un canale per i contadini per accedere al finanziamento. La mancanza di finanziamenti equi nel settore agricolo è un problema ben noto e ampiamente discusso nei circoli agricoli. Moltissime aziende agricole in dozzine di regioni in tutto il mondo semplicemente non hanno modo di prendere in prestito perché l’infrastruttura finanziaria richiesta non è semplicemente presente. Nelle aree ‘fortunate’ abbastanza da avere accesso alle istituzioni finanziarie, le condizioni di prestito che ricevono i contadini sono al massimo scandalose e nella maggior parte dei casi sono esclusive. Connettere questi contadini in cerca di prestiti con gli investitori crypto sta aprendo la strada a un futuro più luminoso e sostenibile che combatte direttamente le crisi alimentari globali.</p>
<p>In secondo luogo, gli investitori tradizionali hanno dimostrato in modo inequivocabile una forte domanda di materie prime agricole per decenni a causa dei loro vantaggi inflazionistici, non correlati e diversificati. Trilioni di dollari circolano nel settore agricolo ogni anno, ma fino ad ora gli investitori digitali non hanno avuto modo di ottenere esposizione a questo mercato. LandX funge da condotto diretto dalla classe di attività delle materie prime agricole tradizionali ai mercati di criptovalute.</p>
<h2 id="h2-Approfondimento20su20LNDX555493"><a name="Approfondimento su LNDX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Approfondimento su LNDX</h2><p><strong>LandWalker (Co-Founder di LandX Finance):</strong><br>$LNDX è il token di governance nativo del nostro protocollo. Viene fornito con tre utilità principali:</p>
<p>Governance - Gli utenti possono scommettere $LNDX per ricevere veLNDX. Questo consente loro di votare sui protocolli di governance che controllano il futuro del protocollo.</p>
<p>Yield - Gli stakeholder di $LNDX ricevono il 60% delle commissioni di protocollo come rendimento. Requisito per diventare un Originator - Per diventare un originator (le parti compensate responsabili dell’acquisizione di nuovi agricoltori del mondo reale), è necessario fare stake di $LNDX. Questo scoraggia fortemente qualsiasi comportamento scorretto da parte loro, poiché sarebbe altamente svantaggioso finanziariamente impegnarsi in condotte dannose.</p>
<p>Con un’offerta massima di 80 milioni di token, bloccaggi estesi e termini di vesting per il team e gli investitori precoci, abbiamo progettato deliberatamente $LNDX per attrarre detentori a lungo termine, non speculatori spinti dall’effervescenza. Non abbiamo dubbi che LandX risolva un problema assolutamente cruciale nel panorama industriale e stiamo costruendo una comunità di investitori con mentalità simili che sanno che i fondamentali solidi e un caso d’uso innegabile sono le parti più importanti di qualsiasi progetto.</p>
<p>Offerta massima: 80.000.000<br>Offerta circolante iniziale: 5.400.000<br>Standard dei token: ERC-20<br>Prezzo di vendita al pubblico: $ 0,50 (senza lucchetto o giubbotto)<br>Prezzo di vendita privata: $ 0,23 (blocco di 3 mesi, giubbotto di 9 mesi)<br>Prezzo di vendita del seme: $ 0.18 (blocco di 4 anni, giubbotto di 4 anni)</p>
<h2 id="h2-Approfondimento20su20xTokens466855"><a name="Approfondimento su xTokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Approfondimento su xTokens</h2><p><strong>LandWalker (Co-Fondatore di LandX Finance):</strong><br>I quattro xTokens (xWheat, xSoy, xRice, xCorn) rappresentano i pagamenti ricorrenti che gli agricoltori effettuano al protocollo LandX dopo aver finanziato con noi. Ogni xToken scommesso da un utente produce 1 chilogrammo del suo corrispondente prodotto reale. Gli xToken mettono in contatto gli investitori con un rendimento ricorrente che proviene direttamente dalle fattorie reali.</p>
<p>Ci sono tre motivi principali per cui le materie prime agricole sono così ricercate:</p>
<p>Il prezzo delle materie prime agricole non si comporta come altre classi di attività come azioni e criptovalute. Questa forte mancanza di correlazione, unita all’aumento costante del prezzo delle materie prime agricole nel corso dei decenni, le rende una scelta eccellente per gli investitori responsabili che cercano di bilanciare parte di quella volatilità che gli appassionati di criptovalute conoscono e amano.</p>
<p>Tutti sappiamo che l’inflazione rende il denaro meno efficace. I periodi di alta inflazione svalutano le valute e danneggiano gravemente il potere d’acquisto. In altre parole, semplicemente tenere contanti inutilizzati è un modo sicuro per farli perdere valore. Nel frattempo, le materie prime mantengono (e spesso aumentano) il loro valore in modo notevole durante questi periodi.<br>MSNBC ha pubblicato un articolo a gennaio che ha rivelato che oltre la metà delle prime 10 categorie di prodotti che sono aumentate di prezzo erano gli alimenti… ad esempio le materie prime agricole. Ci sarà sempre domanda per i raccolti coltivati dagli agricoltori finché gli esseri umani mangeranno cibo, quindi è abbastanza sicuro dire che l’orizzonte della domanda per questa classe di asset è garantito.</p>
<h2 id="h2-Qual2020il20prossimo20passo20e20dove20posso20trovare20ulteriori20informazioni20su20LandX896911"><a name="Qual è il prossimo passo e dove posso trovare ulteriori informazioni su LandX?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è il prossimo passo e dove posso trovare ulteriori informazioni su LandX?</h2><p><strong>LandWalker (Co-Fondatore di LandX Finance):</strong><br>Ora che abbiamo esaurito i nostri round privati e pubblici $LNDX, esaurito il nostro primo lotto di xTokens di xBasket in meno di 7 ore, quotati su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Utilizzando l’impulso generato dalla nostra presenza su due importanti CEX e DEX, stiamo sfruttando ancora di più per completare ulteriori obiettivi della nostra roadmap.</p>
<p>Andando avanti, rimaniamo guidati da tre obiettivi principali:<br>Portare l’esposizione alle materie prime agricole tokenizzate a tutti gli investitori nativi di criptovalute.</p>
<p>Fornire una piattaforma sicura, stabile e intuitiva per accedere a tutti i servizi e prodotti.</p>
<p>Incidere positivamente su ogni azienda agricola con cui lavoriamo per incoraggiare pratiche rigenerative.</p>
<p>In cima alle nostre priorità ci sono l’integrazione con più reti, il potenziamento delle misure di sicurezza e trasparenza, e l’espansione delle nostre offerte di prodotti per includere xUSD e xNFTs.</p>
<div class="blog-details-info"><br><div>Autore:<strong> GateLive</strong>, Gate.io Team<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Il repostaggio dell'articolo sarà consentito a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>