TGEgbG9naWNhIGRpZXRybyBpbCByZWNlbnRlIFRSQiBjaGUgc2kgw6ggYWx6YXRvIGUgY2FkdXRv

2023-09-20, 03:42
<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR356223"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Tellor è seconda solo a Chainlink in termini di valore di mercato sulla traccia degli oracoli, con i suoi vantaggi che sono più decentralizzati e la sua attività in un ciclo operativo stabile, senza significative nuove narrazioni come l’innovazione tecnologica o le attività di finanziamento.</p>
<p>A causa della continua contrazione del volume spot di TRB, gli investitori rialzisti continuano ad acquistare, portando a un aumento sincronizzato del volume di scambi del mercato dei futures, e il tasso del fondo è stato in uno stato fortemente negativo.</p>
<p>La principale tendenza di questo mercato rialzista è che i tori hanno assorbito più del 30% del mercato spot, unito a tassi di finanziamento futures elevati e posizioni futures nettamente superiori alle posizioni spot, risultando in un forte ciclo TRB.</p>
<p>Gli investitori dovrebbero analizzare in modo completo e sistematico le condizioni di mercato combinando grandi quantità di dati sulla catena, il volume di scambi futures e le variazioni delle detenzioni, per prendere decisioni di investimento ragionevoli.</p>
<h2 id="h2-Introduzione586497"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La persistenza dei punti caldi nel mercato azionario attuale è spesso molto breve, ma la popolarità dei token TRB è stata costantemente alta di recente, con un aumento fino a 4 volte nel corso dell’ultimo mezzo mese. Il tasso del fondo ha continuato ad avvicinarsi al -3% e il volume di trading dei futures perpetui ha superato ETH in un certo momento. Quali sono le forze dietro questa drammatica ascesa? Questo articolo fornirà un’interpretazione approfondita di questo.</p>
<h2 id="h2-Nessuna20nuova20narrazione20nei20fondamentali20di20TRB259163"><a name="Nessuna nuova narrazione nei fondamentali di TRB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nessuna nuova narrazione nei fondamentali di TRB</h2><p>Teller Tributes è una piattaforma di rete Oracle decentralizzata lanciata nel 2019, impegnata a incoraggiare una rete di segnalazione e convalida dati aperta e non autorizzata, garantendo trasparenza e autenticità dei dati.</p>
<p>Attualmente, il sistema implementa un modello di mining e emissione di token che combina POS e POW. I minatori devono fare sia lo staking del nodo che completare la sfida del puzzle POW. I primi 5 nodi a trovare la risposta inviano i dati e ricevono ricompense in token TRB. Il sistema utilizza la competizione di rete dei minatori controversi per risolvere il problema POW, monitorando le richieste di dati degli utenti sulla catena e monitorando e ricevendo le richieste di dati fuori dalla catena.<br><img src="https://gimg2.gateimg.com/image/article/16952016379571695180991_.pic.jpg" alt=""><br>Fonte: tellor.io</p>
<p>I token TRB hanno molteplici utilizzi e i minatori che partecipano al mining devono scommettere almeno 1000 TRB. Nel frattempo, le squadre di progetto che utilizzano il protocollo hanno anche bisogno di utilizzare i pagamenti TRB. Sono inoltre utilizzati per le ricompense di mining, la governance del voto, la compensazione delle controversie e la sicurezza della rete.</p>
<p>L’attuale offerta totale di token TRB è di circa 2,49 milioni, con una circolazione di 2,48 milioni. Il tasso di inflazione annuale rimane al 17%, ed è attualmente in piena circolazione.</p>
<p>Nel complesso, Tellor è seconda solo a Chainlink per valore di mercato nella categoria degli oracoli, con il vantaggio di essere più decentralizzata e con un business in un ciclo operativo stabile. Attualmente, non ci sono significative innovazioni tecnologiche o attività di finanziamento.</p>
<h2 id="h2-TRB20Cash20Face20Spot20Driven20Futures365226"><a name="TRB Cash Face Spot Driven Futures" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TRB Cash Face Spot Driven Futures</h2><p>Osservando l’attività di trasferimento online, si può notare che c’è stata una grande quantità di trasferimenti online il 21 agosto, che ha raggiunto il livello più alto di attività e importo da quest’anno. Al mattino del 26, c’è stato un aumento significativo del volume e delle detenzioni del trading futures, con le detenzioni futures che sono schizzate oltre il 90%.</p>
<p>Secondo il monitoraggio di Lookonchain, dal 30 agosto, una balena blu (0xCcE7300829f49B8f2E4AEe6123b12DA64662a8b8) ha accumulato 872600 TRBs (attualmente del valore di 116 milioni di dollari) da varie borse, corrispondenti a circa il 34,5% della circolazione attuale di TRB.</p>
<p>Prendendo come esempio i dati sui derivati della mattina del 26 agosto, il volume degli scambi di futures del token è aumentato del 151% e la posizione dei futures è aumentata del 93% in 24 ore. La posizione del conto large è lunga e il rapporto long short del conto è 0,96, indicando un gran numero di investitori al dettaglio short.</p>
<p>L’afflusso di questi fondi a breve termine, così come l’aumento dei dati sul trading futures, ha spinto il prezzo della moneta nel breve termine, effettivamente corrispondendo all’aumento del prezzo spot del token al momento del nodo.<br><img src="https://gimg2.gateimg.com/image/article/16952016909581695181005_.pic.jpg" alt=""><br>Origine: Gate.io</p>
<p>Vale la pena notare che a causa della continua contrazione del volume spot di TRB, gli investitori rialzisti continuano ad acquistare, portando a un aumento sincronizzato del volume di scambi del mercato dei futures, e il tasso del fondo è stato in uno stato altamente negativo.<br><img src="https://gimg2.gateimg.com/image/article/16952017089591695181025_.pic.jpg" alt=""><br>Origine: Gate.io</p>
<p>A causa del graduale aumento del prezzo della moneta da parte di molteplici parti e dell’ottenimento di commissioni di regolamento di alto capitale nel mercato dei futures, questo reddito viene utilizzato per mantenere l’alto prezzo spot, spingendo indirettamente al rialzo il mercato, causando un graduale aumento delle posizioni corte sui futures e entrando in un ciclo positivo continuo di tendenza al rialzo.</p>
<p>I dati on-chain confermano ulteriormente questa analisi, infatti al 13 agosto gli investimenti a breve termine hanno accumulato 91130 TRB, e entro il 13 settembre questo numero è schizzato a 1,9 milioni, un aumento fino al 2096%.</p>
<p>Sotto questo ciclo positivo della “macchina a moto perpetuo”, il volume di trading del mercato dei futures TRB ha addirittura superato il volume di trading dei futures ETH in un momento, spingendo direttamente il volume di trading dei futures BTC.</p>
<h2 id="h2-Prospettive20future20di20TRB501246"><a name="Prospettive future di TRB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future di TRB</h2><p>In generale, la tendenza principale di questo mercato rialzista è che i tori hanno assorbito oltre il 30% del mercato spot, unito a tassi di finanziamento dei futures elevati e posizioni future nettamente superiori alle posizioni spot, dando luogo a un forte ciclo TRB.</p>
<p>Rispetto ai token come CYBER, BLZ, RUNE e LPT che hanno mantenuto un trend di mercato settimanale in passato, TRB è continuato a salire per più di 20 giorni senza alcun fondamento positivo, indicando che l’aumento del prezzo dei token TRB è principalmente guidato da fondi a breve termine.</p>
<p>Sebbene il mercato possa essere influenzato dal finanziamento a breve termine, a lungo termine questo aumento non è dovuto a una crescita organica del valore di base della rete Teller. Il ritiro dal 16 settembre ad oggi indica che questo sentimento di surriscaldamento degli investimenti sta iniziando a tornare alla calma.</p>
<p>In sintesi, il mercato è ancora in uno stato di gioco azionario verso una ripresa incrementale. I fondi a breve termine guidano facilmente alcuni token di progetto, ma la persistenza del sentiment FOMO senza un supporto fondamentale non è facile da prevedere. Gli investitori dovrebbero analizzare in modo completo e sistematico le condizioni di mercato combinando grandi quantità di dati sulla catena, il volume di trading dei futures e le variazioni delle partecipazioni, per prendere decisioni di investimento ragionevoli.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Peter L.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<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 il ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards