VHV0dG8gY2nDsiBjaGUgZGV2aSBzYXBlcmUgc3VsIGZ1dHVybyBtZXJjYXRvIGRlbCB0cmFjY2lhbWVudG8gZGVpIHJvYm90IHRlbGVncmFmaWNp

2023-11-24, 02:17

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR326898"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Il bot di Telegram si riferisce a un robot di trading di criptovalute collegato al software sociale Telegram, che è un programma software automatizzato che esegue transazioni attraverso algoritmi e regole predefinite.</p>
<p>Mentre il mercato si riprende gradualmente quest’anno, la comunità di crypto Twitter sta cercando di cogliere più opportunità α. Il Telegraph Robot fornisce una funzione di trading più semplice, efficiente e conveniente rispetto all’esistente DeFi.</p>
<p>Poiché sempre più robot si spostano dalle funzioni di transazione singola su Telegram ai trasferimenti aggregati su molteplici piattaforme social, il valore del settore fiorirà ulteriormente.</p>
<h2 id="h2-Introduzione99232"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Da luglio di quest’anno, il Telegram Robotics Circuit è stato in uno stato caldo, fornendo nuove soluzioni per esplorare una partecipazione degli utenti più semplice ed efficiente negli investimenti criptati, e la dimensione del mercato continua a crescere.</p>
<p>L’articolo fornirà una spiegazione dettagliata a tutti sulla base dei progressi dei progetti del settore TG-BOT e del mercato valutario.</p>
<h2 id="h2-Mercato20del20settore20dei20bot20di20Telegram634953"><a name="Mercato del settore dei bot di Telegram" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato del settore dei bot di Telegram</h2><p>Il Telegram Bot si riferisce a un robot di trading di criptovalute collegato al software sociale Telegram, che è un programma software automatizzato che esegue transazioni attraverso algoritmi e regole predefinite.</p>
<p>Secondo i dati in tempo reale compilati da Dune, alla data di scrittura, la traccia ha coinvolto 277.588 utenti con un volume di transazioni totale di oltre 11 miliardi di dollari.</p>
<p>Dal numero medio giornaliero di utenti attivi, volume delle transazioni, entrate e altri dati, i tre giganti MaestroBot, Banana Gun e Unibot in questo settore hanno un vantaggio assoluto.<br><img src="https://gimg2.gateimg.com/image/article/170079207415271700791996_.pic.jpg" alt=""><br>Origine: Dune</p>
<p>Successivamente, diamo un’occhiata all’attività di trading di questa traccia. Dalla figura qui sotto, si può vedere che il volume di trading di Bots è gradualmente diminuito da agosto ai primi di ottobre. Tuttavia, con sempre più progetti Bot che entrano nel mercato e il mercato delle criptovalute che si prepara a metà ottobre, la domanda degli investitori per funzioni come l’acquisto e la vendita automatica e l’acquisizione di nuovi ordini di valuta è aumentata, e il volume di trading è rapidamente ripreso e ha raggiunto un nuovo massimo.<br><img src="https://gimg2.gateimg.com/image/article/170079209515281700792010_.pic.jpg" alt=""><br>Origine: Dune</p>
<p>Secondo la sezione più ampia del Bot di Telegram di CoinMarketCap, attualmente ci sono circa 77 progetti legati ai robot, di cui 57 hanno emesso pubblicamente token, con un valore di mercato totale di $300 milioni e un volume di scambi nelle ultime 24 ore di quasi $47 milioni.</p>
<h2 id="h2-Confronto20dei20progetti20del20bot20di20Telegram721705"><a name="Confronto dei progetti del bot di Telegram" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Confronto dei progetti del bot di Telegram</h2><p>In realtà, la traccia non è apparsa solo quest’estate. Il principale MaestroBot è stato lanciato già nel luglio 2022, ma a causa della sua maturità tecnologica e del contesto di mercato ribassista, non ha attirato abbastanza attenzione pubblica in quel momento.</p>
<p>La popolarità del Bot Telegram di quest’anno non è certamente casuale. Mentre il mercato si riprende gradualmente quest’anno, la comunità crypto di Twitter cerca di cogliere più α opportunità. Il Robot di Telegram fornisce una funzione di trading più semplice, efficiente e conveniente rispetto all’esistente DeFi.</p>
<p>Il decollo di questa traccia quest’anno è attribuito per la prima volta a Unibot. Dall’avvio a maggio di quest’anno, Unibot ha attratto un gran numero di trader grazie alle sue funzionalità convenienti e intuitive, rappresentando inizialmente il 70% del market share, superando il consolidato MaestroBot in termini di costi di transazione e volume degli utenti.</p>
<p>In questo modo, su Telegram con fino a 800 milioni di utenti attivi mensili, il prodotto Bot è diventato il gateway per il nuovo traffico.</p>
<p>Tuttavia, la fedeltà dell’utente ovviamente non è così veloce e facile da stabilire. Seguendo la tendenza, Banana Gun ha rapidamente recuperato e la sua innovazione risiede nel suo attacco Sniper all’apertura della nuova moneta, con un focus sul First Block.</p>
<p>In seguito, Unibot e Banana Gun hanno approfittato del calore per lanciare i rispettivi token, completando così la spirale positiva del progetto attraverso l’economia dei token, come la distribuzione dei profitti e la riduzione delle commissioni. Maestro non ha ancora emesso monete, ma la sua quota di mercato detiene comunque un posto.<br><img src="https://gimg2.gateimg.com/image/article/170079213815291700792026_.pic.jpg" alt=""><br>Fonte: Medium@Kunallegend</p>
<p>Inoltre, c’è anche PAAL AI con ulteriori concetti di intelligenza artificiale, così come BonkBot, un’applicazione contraffatta del <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> il progetto di meme on-chain Bonk, del quale non si parlerà qui.</p>
<p>Sebbene lo sviluppo di questi progetti abbia le sue caratteristiche specifiche, le loro funzioni effettive sono simili. Tutti si impegnano a migliorare la domanda degli utenti di semplicità, efficienza e velocità nell’investire in cripto-asset, con le seguenti caratteristiche specifiche.</p>
<p>-Facile accesso: acquisto e vendita di criptovalute direttamente tramite Telegram Bot</p>
<p>-Velocità: Più veloce di <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> velocità di transazione di ‘s</p>
<p>-Order grabbing: compensazione delle transazioni di apertura con nuova valuta</p>
<p>-Analisi e monitoraggio: può identificare la qualità del progetto e seguire le tendenze del portafoglio intelligente</p>
<p>-Airdrop: Effettua una serie di operazioni basate su una strategia prestabilita per ottenere un airdrop</p>
<p>-Protezione della sicurezza: contro MEV, RUG, ecc.</p>
<h2 id="h2-Il20percorso20per20rompere20lo20spazio20cripto20ha20ancora20bisogno20di20tempo840315"><a name="Il percorso per rompere lo spazio cripto ha ancora bisogno di tempo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il percorso per rompere lo spazio cripto ha ancora bisogno di tempo</h2><p>Non è difficile capire che molti utenti stanno entrando nel campo del trading di asset cripto e persino DeFi attraverso Bot. Questo è grazie ai prodotti Bot che semplificano notevolmente i processi operativi degli utenti.</p>
<p>I prodotti che soddisfano gli interessi e le esigenze di un gran numero di utenti, come il tracciamento delle transazioni, il nuovo currency sniping e l’interazione automatizzata con gli airdrop, sono facili da uscire rapidamente dal mercato. Tuttavia, la concorrenza nel Bot track è ancora lontana dallo stadio in cui la situazione complessiva è stata determinata.</p>
<p>Nel complesso, il lancio della traccia del Bot di Telegram aiuta a abbassare la soglia per gli utenti tradizionali per entrare nel mondo della crittografia, e l’aumento continuo dei numeri degli utenti e delle dimensioni delle transazioni indica che si sta raggiungendo l’adozione su larga scala di Web3.</p>
<p>Ma allo stesso tempo, questi prodotti comportano anche rischi intrinseci. Quando gli utenti utilizzano Telegram Bot, devono salvare la chiave del portafoglio nel robot stesso, e molti prodotti robot non sono ancora open source. In altre parole, gli utenti potrebbero essere esposti a potenziali rischi come attacchi hacker e furto di progetti causati da vulnerabilità dei contratti intelligenti.</p>
<p>In effetti, molti prodotti, tra cui i tre robot leader sopra menzionati, hanno riscontrato problemi di varia entità. Ad esempio, il 31 ottobre di quest’anno, UNIBOT ha subito un attacco hacker a causa di una vulnerabilità nell’approvazione del codice, con conseguente perdita di $640000 in asset e un rapido calo dei suoi token nel breve termine. Fortunatamente, tali problemi sono stati prontamente affrontati e il team del progetto ha anche risarcito gli utenti per le loro perdite.<br><img src="https://gimg2.gateimg.com/image/article/170079218215301700792039_.pic.jpg" alt=""><br>Sorgente: Gate.io</p>
<p>In sintesi, la recente crescita dei token correlati ai bot indica la visione a lungo termine del mercato. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> verso il settore, ma ci vorrà comunque del tempo per raggiungere una crescita sostenuta nel mercato. Credo che il settore dei Bot di Telegram possa avere i seguenti tre principali trend di sviluppo:</p>
<ol>
<li><p>Oltre a Telegram, si prevede che alcuni progetti di robot saranno lanciati anche su piattaforme social come Discord e WhatsApp, che amplificheranno ulteriormente l’influenza di questi strumenti di assistenza alle transazioni intelligenti e forniranno scelte più diverse e variegate per un numero maggiore di utenti.</p>
</li><li><p>Le funzioni del Bot verranno ulteriormente ottimizzate e migliorate. Attualmente, Bot fornisce principalmente transazioni di acquisto e vendita, che è simile al percorso di sviluppo di DEX. In futuro, saranno gradualmente integrate nel Bot funzioni di Yield Farm, transazioni di contratti derivati on-chain, transazioni di strategie basate sugli eventi, chat room e funzioni multi-chain simili ai portafogli di contratti intelligenti.</p>
</li></ol>
<p>3.Nuove funzionalità di sicurezza potrebbero apparire sulla memorizzazione della chiave privata per ridurre il rischio di perdita e furto della chiave privata.</p>
<p>In breve, il trend di sviluppo del Bot di Telegram è chiaramente eccitante. Crediamo che man mano che sempre più robot passeranno da funzioni di transazione singola su Telegram a transazioni aggregate su più piattaforme social, assisteremo a maggiori innovazioni di prodotto e alla prosperità del valore tracciato.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</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 repost dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>