Z2F0ZUxpdmUgQU1BIFJlY2FwLVVtZWU=

2023-05-10, 07:30

<p><img src="https://gimg2.gateimg.com/image/article/1683703355Blogum.png" alt=""></p>
<h2 id="h2-Kunt20u20ons20alstublieft20vertellen20waarom20u20UMEE20wilt20maken559649"><a name="Kunt u ons alstublieft vertellen waarom u UMEE wilt maken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kunt u ons alstublieft vertellen waarom u UMEE wilt maken?</h2><p><strong>Brent Xu (Oprichter en CEO van Umee):</strong><br>Ik heb de hypotheekcrisis van 08-09 meegemaakt, het gebroken tradfi-systeem - we zagen 50 biljoen waarde vernietigd worden</p>
<p>Mensen zoals mijn vader verloren hun banen, en hij was een kankeronderzoeker - wat heeft dat te maken met door hypotheken gedekte effecten? Dat kan worden opgelost met betere open source-infrastructuur.</p>
<p>Wat betekent het? Crypto is nog steeds vroeg. Crypto is momenteel klein als een beleggingscategorie. In de wereld is de obligatiemarkt 130 biljoen. De Amerikaanse aandelenmarkt is 40 biljoen.<br>Goud is 11 biljoen. Crypto als geheel is slechts 1,2 biljoen. Btc is slechts 1/20e van goud.</p>
<p>Maar waarom zijn we hier? Omdat we geloven in de toekomst van het web3. De volgende stap voor crypto is om de rest van de wereld aan boord te krijgen. De visie van Umee is nu om de volgende 100 miljoen web2-gebruikers aan boord te halen naar web3.</p>
<p>Umee’s umeemania testnet had meer dan 100k deelnemers en meer dan 1 miljard tvl.</p>
<p>We zullen een nog grotere markt veroveren en open source technologie en gedecentraliseerde infrastructuur gebruiken om alle toekomstige mondiale crises te voorkomen, zoals we zagen in 2008-2009.</p>
<h2 id="h2-Wat20is20de20routekaart20voor20Umee353101"><a name="Wat is de routekaart voor Umee?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de routekaart voor Umee?</h2><p><strong>Brent Xu (oprichter en CEO van Umee):</strong><br>Het meest opwindende op dit moment zijn LSD’s en Stablecoins</p>
<p>Marktindex is enorm</p>
<p>Index Producten<br>Doel Stablecoins<br>vloeibare stakingsprotocollen</p>
<p>Razendsnelle groei van LSD-producten zoals Lido, Rocket en Coinbase. Stablecoins en het rendement dat ze opleveren.</p>
<p>We zullen een index-derivaat creëren dat blootstelling geeft aan de mand met activa, risico diversifieert en meer rendementskansen creëert voor munters.</p>
<p>We geloven dat de markt erop zal springen zodra we lanceren en het zal veel protocolopbrengsten genereren voor de Umee-keten, wat allemaal zal resulteren in tokenwaarde voor de tokenhouders.</p>
<p>Markt voor leningen met meerdere ketens. We staan toe dat activa worden uitgeleend en geleend van elke blockchain. Dit creëert een universele kapitaalfaciliteit waar iedereen toegang heeft tot liquiditeit</p>
<p>We zullen een AMM-keten onthullen die een Layer 2 is voor beide <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> dat native interoperabel is met Umee.</p>
<p>Een Oracle-keten die slimme prijsstelling en manipulatiebestendige gegevens levert aan ibc-ketens, rollups en elke L1. De mobiele portemonnee integreert alle functies voor cross-chains in één interface, zodat gebruikers niet langer hoeven te jongleren tussen verschillende websites.</p>
<p>Het Umee-ecosysteem zal het allereerste ecosysteem zijn dat een volledige productreeks van alle essentiële onderdelen van lenen, handelen, portemonnee, oracle incubeert. Dit is nog niet eens het beste gedeelte.</p>
<p>Het beste is dat elk van de producten over een paar maanden zal worden uitgebracht, elk van hen zal een token, NFT’s, een combinatie van een token en NFT’s hebben, en ze zullen allemaal worden gedropt naar de Umee-stakers.</p>
<h2 id="h2-Welke20markt20probeer20je20te20repliceren267514"><a name="Welke markt probeer je te repliceren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke markt probeer je te repliceren?</h2><p><strong>Brent Xu (oprichter en CEO van Umee):</strong><br>Ik heb meer dan een half decennium besteed aan tradfi. Vertrouw je erop dat je geld in de bank nog steeds aanwezig zal zijn in de toekomst?</p>
<p>De inspiratie van Umee kwam toen ik werkte op een obligatiehandelsdesk.<br>-Alles gecentraliseerd<br>-Zeer ondoorzichtige markt<br>-Inefficiënte oude en</p>
<p>Maar de obligatiemarkt is de grootste markt ter wereld en vormt de basis van het kapitalisme. De obligatiemarkt is de sleutel tot het bankenecosysteem: daarom bouwen we een <a href="/price/neo-neo" rel="nofollow noopener noreferrer" target="_blank">NEO</a> Bank voor de toekomst van de wereldwijde obligatiemarkten.</p>
<p>Net zoals banken verschillende vestigingen hebben, zal Umee vertakken en soevereine ketens creëren met vergelijkbare functionaliteiten als de hoofdketen.<br>-Uitgifte van bedrijfsobligaties<br>-Kredietproducten<br>-Vaste renteleningen aan web2-bedrijven</p>
<p>Enkele KYC’s, enkele privéketens voor privéplaatsingen - voor Fortune 500-bedrijven en grote kapitaalinstituten.</p>
<p>Het gedeelde eigendom hier is dat elke van de chains zal worden aangedreven door interchain-beveiliging via de Umee-token, wat betekent dat alle protocol-inkomsten, alle transactiekosten, alle waarde die elk van de chains vastlegt, worden vastgelegd door de Umee-token.</p>
<p>Het schuldecosysteem is zo slecht - we moeten het kapotte legacy systeem vervangen<br>-Umee bouwt de obligatiemarkt opnieuw op<br>-Begin met kortlopend lenen zoals een repo-markt<br>-Ga over naar langlopend lenen, wat een rendementscurve zal ontwikkelen<br>-Creëer een termijnstructuur van rentetarieven om alle tijdswaarde in de wereld te prijzen<br>-Bouw de basis voor krediet</p>
<p>Het idee is dat alle kapitaalmarkten zullen overstappen op DeFi en open source technologie. En we zullen een instroom zien van enorme hoeveelheden kapitaal in het crypto-native ecosysteem.</p>
<h2 id="h2-Wat20is20het20uiteindelijke20doel20van20Umee223815"><a name="Wat is het uiteindelijke doel van Umee?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het uiteindelijke doel van Umee?</h2><p><strong>Brent Xu (oprichter en CEO van Umee):</strong><br>We hebben de afgelopen maanden de vernietiging van het banksysteem gezien.<br>-De bank van de vallei van Silicon<br>-Handtekening<br>-Silvergate<br>-Credit Suisse<br>-Eerste Republiek<br>-Stille Oceaan West</p>
<p>Het uiteindelijke doel van Umee is om de Nieuwe Wereld te worden <a href="/price/neo-neo" rel="nofollow noopener noreferrer" target="_blank">NEO</a> bank van Crypto.<br>-Door een DeFi-basislaag te bouwen<br>-Betere markt voor schuldobligaties<br>-Betere kapitaalallocatie<br>-Betere open source code<br>-Beter, transparanter banksysteem</p>
<p>Platforms zoals Umee zullen de volgende bankencrisis oplossen. Door het bouwen van een fundament <a href="/price/neo-neo" rel="nofollow noopener noreferrer" target="_blank">NEO</a> Om de kloof te overbruggen tussen de web2- en web3-werelden verandert Umee de manier waarop de wereld naar technologische infrastructuur zou moeten kijken.</p>
<p>Deze visie is enorm, maar waar Umee in eerste instantie op mikt, is niet om alles in één keer over te nemen.</p>
<p>We beginnen eerst met bedrijfsschuldenuitgifte en privéplaatsingen - Umee heeft hierin al een voorsprong opgebouwd. Elk van onze zelfsoevereine blockchains zal alle producten, technologie en infrastructuur bevatten die passen bij de behoeften van alle zakelijke klanten.</p>
<p>Terwijl we de schuldmarkt vanaf nul opbouwen, zal Umee zijn positie als belangrijk bankinfrastructuur van Web3.0 versterken. En we zullen doorgaan met het opbouwen van waarde voor het Umee-netwerk.</p>
<h2 id="h2-Welke20aankondigingen20kunnen20we20de20komende203620maanden20verwachten779159"><a name="Welke aankondigingen kunnen we de komende 3-6 maanden verwachten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke aankondigingen kunnen we de komende 3-6 maanden verwachten?</h2><p><strong>Brent Xu (oprichter en CEO van Umee):</strong><br>Wat er later dit jaar op ons afkomt, heeft Umee een topteam van ontwikkelaars en we hebben een aantal geliefde producten geleverd en we willen blijven innoveren.</p>
<p>We kondigen aan… We hebben een alfalek dat nog nergens anders is aangekondigd:</p>
<ul>
<li>We zullen ons richten op het introduceren van de nieuwe Umee 2.0 Tokenomics in dit ecosysteem</li><li>Nieuwe vaste aanbodlimiet voor de UMEE-token</li><li>Dit zal ontworpen zijn om de gemeenschap verder af te stemmen op de groei en ontwikkeling van de UMEE-token</li><li>We zullen morgen onze eerste bestuursdiscussie plaatsen en u kunt meer aankondigingen verwachten in de komende dagen!</li></ul>
<div class="blog-details-info"><br><div>Auteur: <strong>GateLive</strong>, Gate.io Team<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 opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>