RGUgT3JhY2xlIFNlY3RvciBzdGlqZ3QsIHppam4gZXIgbm9nIHN0ZWVkcyBiZWxlZ2dpbmdzbW9nZWxpamtoZWRlbj8=

2024-01-24, 01:25

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR947504"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Volgens de Gate-markt heeft het UMA (UMA) orakelproject in de afgelopen 5 dagen een piekstijging van bijna 240% gezien, met de laatste offerte van $5.26 en een stijging van 4.04% in de afgelopen 24 uur.</p>
<p>Ondanks zijn goede fundamenten en minimale verkoopdruk, kreeg UMA snel veel aandacht en schoot de marktwaarde omhoog naar de derde plaats in de sector, op één na alleen <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> en PYTH.</p>
<p>Als een brug die blockchain en de echte wereld verbindt, heeft de oracle brede ontwikkelingsvooruitzichten en oneindige mogelijkheden in de toekomst. Deze bullmarkt zal investeerders veel fantasieruimtes en handelsmogelijkheden bieden voor kortetermijnspeculatie en langetermijnbelegging.</p>
<h2 id="h2-Introductie573935"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De afgelopen tijd is de oracle sector in opkomst, waarbij tokenprojecten zoals UMA, API3 en anderen hoge groeipercentages ervaren. Dit artikel zal een diepgaande analyse van de oracle markt uitvoeren en investeringsmogelijkheden verkennen.</p>
<h2 id="h2-UMA20en20API320hebben20een20significante20toename20gezien20wat20heeft20geleid20tot20een20stijging20op20de20markt20voor20Oracle127074"><a name="UMA en API3 hebben een significante toename gezien, wat heeft geleid tot een stijging op de markt voor Oracle." class="reference-link"></a><span class="header-link octicon octicon-link"></span>UMA en API3 hebben een significante toename gezien, wat heeft geleid tot een stijging op de markt voor Oracle.</h2><p>Als een van de eerste blockchain-orakelprojecten heeft Chainlink sinds vorig jaar de aandacht van de markt getrokken, terwijl een ander orakel TRB vorig jaar 50 keer steeg en een van de valuta met de grootste groei werd in het crypto-veld.</p>
<p>Vorig jaar trok de welvaart van blockchain-orakelmachines zoals Chainlink en TRB opnieuw de aandacht naar het concept van blockchain-orakel. Dit jaar zijn echter ook ervaren orakel tokens zoals UMA en API3 gestegen, waarmee ze een ander heet gebied worden na de inies en <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosysteem.<img src="https://gimg2.gateimg.com/image/article/1706059330img_v3_027d_97d01ca2-4223-4841-ada1-5a634e9a5eix.jpg" alt=""><br>Bron: Gate.io</p>
<p>Volgens de Gate-markt is UMA (UMA) sinds de schrijfdatum bijna 240% gestegen in de afgelopen 5 dagen, met de laatste koers van $5.26 en een stijging van 4.04% in de afgelopen 24 uur.<br><img src="https://gimg2.gateimg.com/image/article/1706059352img_v3_027d_2168aa52-2399-4d62-9cee-67bb9fe19eix.jpg" alt=""><br>Bron: Gate.io</p>
<p>Naast enkele lagere marktwaarde orakeltokens die aanzienlijke prijsstijgingen hebben gezien, hebben we ook gemerkt dat oude tokens met hoge marktwaarde zoals PYTH (PYTH), API3 (API3) en RLC (I RLC) ook verbazingwekkende groei hebben doorgemaakt en populaire projecten zijn geworden die door investeerders in de recente tijd worden nagestreefd.</p>
<p>Volgens realtime gegevens van CoinGecko bedroeg de totale marktwaarde van crypto-activa behorende tot de orakelcategorie $11,3B, inclusief 42 tokens, en staat op de 25e plaats wat betreft de totale marktwaarde.</p>
<h2 id="h2-Nieuwe20productlanceringen20en20een20lage20verkoopdruk20stimuleren20UMA20om20te20stijgen196333"><a name="Nieuwe productlanceringen en een lage verkoopdruk stimuleren UMA om te stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nieuwe productlanceringen en een lage verkoopdruk stimuleren UMA om te stijgen</h2><p>De recente officiële aankondiging van nieuwe producten door UMA is een belangrijke trigger geworden voor recente fondsspeculatie in UMA.</p>
<p>UMA Protocol heeft op 19 januari een tweet uitgebracht waarin werd gehint op de lancering van een nieuw product volgende week, gericht op het herstellen van tientallen miljoenen dollars aan jaarlijkse verliezen van het uitleenprotocol veroorzaakt door MEV. Dit nieuws heeft de UMA-prijzen met 241% doen stijgen, van $1,97 naar $6,73, waarmee de hoogste marktwaarde sinds medio 2022 werd bereikt.<br><img src="https://gimg2.gateimg.com/image/article/1706069997image.jpg" alt=""><br>Bron: @UMAprotocol</p>
<p>In feite hebben UMA-functionarissen volgens latere waarnemingen aangegeven dat dit toekomstige product zich zal richten op het beschermen van uitleenprotocollen, terwijl medeoprichter Hart Lambur expliciet heeft verklaard dat deze oplossing naar verwachting volgende week wordt gelanceerd.</p>
<p>Achteraf gezien wordt 87% van de UMA-circulatie vastgehouden door de top drie adressen, waaronder cross-chain bruggen, het stemmenpool en officiële adressen, die beperkt zijn door stakingsbeleid en op korte termijn niet kunnen worden voorgesteld; En de overige 13% van de tokens worden voornamelijk vastgehouden door een paar munt-houdende adressen.<img src="https://gimg2.gateimg.com/image/article/1706059414img_v3_027d_ac809f94-dee0-4c93-a0f2-6560a2b0f2ix.jpg" alt=""><br>Bron: AICoin</p>
<p>Als gevolg hiervan, met de voortdurende verbetering van de cryptomacro-omgeving, de goede basisrichting van UMA en minimale verkoopdruk, kreeg de munt snel hype en steeg zijn marktwaarde naar de derde plaats in de sector, alleen achter <a href="/price/link-ln" target="_blank" class="blog_inner_link">LINK</a> en PYTH.</p>
<p>Echter hebben ook PYTH, API3 en anderen aandacht en populariteit gekregen vanwege de verwachte airdrop, wat hetzelfde idee is als de marktspeculatie van TIA-staking om onlangs airdrops te verkrijgen. We zullen hier niet verder op ingaan.</p>
<h2 id="h2-Roterende20hotspots20Onveranderlijke20Orakels620625"><a name="Roterende hotspots, Onveranderlijke Orakels" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Roterende hotspots, Onveranderlijke Orakels</h2><p>Zoals bekend is, is een oracle een sleuteltechnologie voor het integreren van real-world data met blockchain, waardoor blockchain de mogelijkheid heeft om externe data te verkrijgen en te verifiëren.</p>
<p>In de vorige bullmarkt cyclus, steeg Chainlink, de leider op het gebied van oracle, als gevolg van de populariteit van DeFi Summer.</p>
<p>Tegenwoordig zal de vraag naar orakels toenemen met de populariteit van RWA, Gamble, nieuwe DeFi en andere tracks, evenals de opleving van opkomende gebieden zoals DID en NFT.</p>
<p>Als brug die blockchain en de echte wereld met elkaar verbindt, heeft oracle enorm potentieel voor toekomstige ontwikkeling. Met de voortdurende vooruitgang van blockchaintechnologie en de uitbreiding van toepassingsscenario’s, zullen de toepassingsgebieden van oracle ook verder worden uitgebreid. Naast gebieden zoals financiën, verzekeringen, supply chain en het Internet of Things, wordt ook verwacht dat oracle een belangrijke rol zal spelen in interoperabiliteit tussen verschillende blockchains.</p>
<p>Met de toenemende vraag naar interoperabiliteit tussen verschillende blockchain-netwerken wordt verwacht dat Oracle een van de belangrijkste technologieën zal worden voor het bereiken van gegevensoverdracht en verificatie tussen verschillende blockchain-netwerken. Via Oracle kunnen verschillende blockchain-netwerken met elkaar worden verbonden, waardoor gegevensuitwisseling en verificatie mogelijk worden, waardoor de bestaande isolatie wordt doorbroken en de liquiditeit en efficiëntie van het gehele blockchain-ecosysteem worden verbeterd. Dit zal meer mogelijkheden bieden voor de toepassing en ontwikkeling van blockchain-technologie.</p>
<p>Op dit moment is het grootste probleem waarmee oracle wordt geconfronteerd hoe de betrouwbaarheid en geloofwaardigheid van gegevensbronnen te waarborgen. Omdat veel orakels nog steeds vertrouwen op off-chain gegevens, die worden gegenereerd onder gecentraliseerde mechanismen, vereist het bereiken van een perfecte oracle nog steeds een lang ontwikkelingsproces.<img src="https://gimg2.gateimg.com/image/article/1706059453img_v3_027d_966efad1-04da-4eaf-bde4-1293b522c4ix.jpg" alt=""><br>Bron: Chainlink</p>
<p>Om dit probleem aan te pakken, zijn veel ontwikkelaars op zoek naar efficiëntere en veiligere oracle-oplossingen. Dit geeft aan dat er nog veel potentieel is voor ontwikkeling en innovatie in oude prijsen zoals Chainlink, maar ook in niche-oracleprojecten zoals UMA. Natuurlijk biedt dit ook speculanten de mogelijkheid om deel te nemen aan speculatie met de nodige verbeelding.</p>
<p>Kortom, als brug tussen blockchain en de echte wereld heeft oracle brede ontwikkelingsperspectieven en oneindige mogelijkheden in de toekomst. Door middel van voortdurende exploratie en innovatie verwachten we de opkomst van meer efficiënte, veilige en praktische oracle technologie te zien, die meer kansen en uitdagingen brengt voor de toepassing en ontwikkeling van blockchain technologie.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor 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 wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>