RGUgTG9naWNhIEFjaHRlciBkZSBSZWNlbnRlbGlqa2UgU3RpamdpbmcgZW4gRGFsaW5nIHZhbiBUUkI=

2023-09-20, 03:42
<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR142405"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Tellor staat op de tweede plaats, na Chainlink, qua marktwaarde op het orakelspoor, met als voordeel dat het meer gedecentraliseerd is en zijn bedrijfsvoering in een stabiele exploitatiecyclus verkeert, zonder significante nieuwe verhalen zoals technologische innovatie of financieringsactiviteiten.</p>
<p>Vanwege de voortdurende krimp van de TRB-spotvolume blijven bullish investeerders kopen, wat leidt tot een synchrone toename van het handelsvolume op de futuresmarkt en de rente van het fonds bevindt zich in een sterk negatieve toestand.</p>
<p>De belangrijkste trend van deze stierenmarkt is dat de stieren meer dan 30% van de spotmarkt hebben opgenomen, in combinatie met hoge financieringstarieven voor futures en futures-posities ver boven spotposities, resulterend in een sterke TRB-cyclus.</p>
<p>Beleggers moeten marktomstandigheden grondig en atisch analyseren door grote hoeveelheden gegevens over de keten, handelsvolume van futures en veranderingen in bezit te combineren, om redelijke beleggingsbeslissingen te nemen.</p>
<h2 id="h2-Inleiding197489"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>De persistentie van hotspots op de huidige aandelenmarkt is vaak zeer kort, maar de populariteit van TRB-tokens is de laatste tijd consistent hoog, met een stijging tot 4 keer in de afgelopen halve maand. De fondsrente blijft zich in de buurt van -3% bevinden en het handelsvolume in eeuwigdurende futures heeft op een gegeven moment ETH overtroffen. Wat zijn de krachten achter deze dramatische stijging? Dit artikel zal een diepgaande interpretatie hiervan geven.</p>
<h2 id="h2-Geen20nieuwe20verhaallijn20in20TRB20Fundamentals470369"><a name="Geen nieuwe verhaallijn in TRB Fundamentals" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Geen nieuwe verhaallijn in TRB Fundamentals</h2><p>Teller Tributes is een gedecentraliseerd Oracle-orakelnetwerkplatform gelanceerd in 2019, met als doel een open en ongelicentieerd gegevensrapportage- en validatienetwerk te stimuleren, waardoor gegevenstransparantie en authenticiteit worden gegarandeerd.</p>
<p>Momenteel implementeert het systeem een mining- en tokenuitgiftemodel dat POS en POW combineert. Miners moeten niet alleen node staking maken, maar ook de POW-puzzeluitdaging voltooien. De eerste 5 knooppunten die het antwoord vinden, dienen gegevens in en ontvangen TRB-tokenbeloningen. Het systeem maakt gebruik van controversiële netwerkconcurrentie van miners om het POW-probleem op te lossen, het monitoren van gebruikersgegevensverzoeken op de keten en het monitoren en ontvangen van gegevensverzoeken buiten de keten.<br><img src="https://gimg2.gateimg.com/image/article/16952016379571695180991_.pic.jpg" alt=""><br>Bron: tellor.io</p>
<p>TRB-tokens hebben veel toepassingen en mijnwerkers die deelnemen aan het delven moeten minimaal 1000 TRB inzetten. Ondertussen moeten projectteams die het protocol gebruiken ook TRB-betalingen gebruiken. Ze worden ook gebruikt voor mijnbeloningen, stemmingsbestuur, geschillenvergoeding en netwerkbeveiliging.</p>
<p>De huidige totale voorraad TRB-tokens is ongeveer 2,49 miljoen, met een circulatie van 2,48 miljoen. Het jaarlijkse inflatiepercentage blijft op 17%, en het is momenteel in volledige circulatie.</p>
<p>Over het algemeen staat Tellor op de tweede plaats, na Chainlink, wat betreft marktwaarde in de orakelbranche, met als voordeel dat het meer gedecentraliseerd is en dat het bedrijf zich in een stabiele operationele cyclus bevindt. Op dit moment is er geen significante technologische innovatie of financieringsactiviteit.</p>
<h2 id="h2-TRB20Cash20Face20Spot20Gedreven20Futures149699"><a name="TRB Cash Face Spot Gedreven Futures" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TRB Cash Face Spot Gedreven Futures</h2><p>Bij het observeren van de online overboekingsactiviteit kan worden waargenomen dat er op 21 augustus een grote hoeveelheid online overboekingen was, die het hoogste activiteits- en bedragenniveau sinds dit jaar bereikte. Tegen de ochtend van de 26e was er een aanzienlijke stijging van het handelsvolume en de bezittingen van futures, waarbij de bezittingen van futures met meer dan 90% omhoogschooten.</p>
<p>Volgens de monitoring van Lookonchain heeft een blauwe vinvis (0xCcE7300829f49B8f2E4AEe6123b12DA64662a8b8) sinds 30 augustus 872600 TRB (momenteel ter waarde van $116 miljoen) verzameld van verschillende beurzen, wat ongeveer 34,5% van de huidige circulatie van TRB vertegenwoordigt.</p>
<p>Als voorbeeld nemen we de derivatengegevens van de ochtend van 26 augustus. Het handelsvolume van de futures van de token steeg met 151% en de futurepositie steeg met 93% binnen 24 uur. De positie van de grote account is lang en de verhouding tussen long en short van de account is 0.96, wat wijst op een groot aantal retailbeleggers die short zijn.</p>
<p>De instroom van deze kortlopende fondsen, evenals de stijging van de gegevens van de handel in futures, heeft op korte termijn de prijs van de munt doen stijgen, waarbij effectief de stijging van de spotprijs van de token op het tijdstipknooppunt wordt gematcht.<br><img src="https://gimg2.gateimg.com/image/article/16952016909581695181005_.pic.jpg" alt=""><br>Bron: Gate.io</p>
<p>Het is vermeldenswaardig dat als gevolg van de voortdurende krimp van TRB spotvolume, bullish investeerders blijven kopen, wat leidt tot een synchrone toename van het handelsvolume op de termijnmarkt, en de fondskoers is sterk negatief geweest.<br><img src="https://gimg2.gateimg.com/image/article/16952017089591695181025_.pic.jpg" alt=""><br>Bron: Gate.io</p>
<p>Omdat meerdere partijen de muntprijs geleidelijk opdrijven en hoge kapitaalafwikkelingskosten op de futuresmarkt verkrijgen, worden deze inkomsten gebruikt om de hoge spotprijs te handhaven, waardoor de markt indirect wordt opgedreven, waardoor de shortposities in futures geleidelijk toenemen en een continue positieve cyclus van opwaartse trend wordt ingegaan.</p>
<p>De on-chain data bevestigt deze analyse verder. Op 13 augustus waren er 91130 TRBs aan kortetermijninvesteringen en op 13 september was dit aantal gestegen tot 1,9 miljoen, een stijging van maar liefst 2096%.</p>
<p>Onder deze positieve cyclus van de “perpetuum mobile” overtrof het handelsvolume van de TRB-futuresmarkt op een gegeven moment zelfs het handelsvolume van ETH-futures, waardoor het handelsvolume van BTC-futures direct werd opgedreven.</p>
<h2 id="h2-Toekomstige20vooruitzichten20TRB484843"><a name="Toekomstige vooruitzichten TRB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstige vooruitzichten TRB</h2><p>Over het algemeen is de belangrijkste trend van deze bullmarkt dat bulls meer dan 30% van de spotmarkt hebben geabsorbeerd, in combinatie met hoge futures-financieringspercentages en futuresposities die veel groter zijn dan spotposities, wat resulteert in een sterke TRB-cyclus.</p>
<p>Vergeleken met tokens zoals CYBER, BLZ, RUNE en LPT die in het verleden een wekelijkse markttrend hebben gehandhaafd, is TRB al meer dan 20 dagen blijven stijgen zonder enige positieve fundamentals, wat aangeeft dat de prijsstijging van TRB-tokens voornamelijk wordt gedreven door kortetermijnfondsen.</p>
<p>Hoewel de markt mogelijk wordt beïnvloed door kortetermijnfinanciering, is deze stijging op de lange termijn niet te wijten aan organische groei in de basiswaarde van het Teller-netwerk. De terugval van 16 september tot nu geeft aan dat dit investeringskoorts sentiment begint terug te keren naar kalmte.</p>
<p>Samenvattend bevindt de markt zich nog steeds in een staat van aandelenspel in de richting van incrementeel herstel. Kortetermijnfondsen drijven gemakkelijk sommige projecttokens aan, maar de persistentie van het FOMO-sentiment zonder fundamentele ondersteuning is niet gemakkelijk te voorspellen. Beleggers moeten de marktomstandigheden uitgebreid en atisch analyseren door grote hoeveelheden gegevens over de keten, het handelsvolume van futures en veranderingen in holdings te combineren om redelijke investeringsbeslissingen te nemen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Peter L.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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 zal er juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards