SWwgdG9rZW4gbmF0aXZvIGRpIEZyaWVuZC5UZWNoIGNyb2xsYSBkb3BvIGlsIGxhbmNpbw==

2024-05-15, 01:44

<p><img src="https://gimg2.gateimg.com/image/article/1715736891sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR483539"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Friend.Tech ha lanciato la sua piattaforma versione 2 che ha potenziato la scalabilità, la sicurezza e la privacy dell’utente.</p>
<p>Il token nativo di Friend.Tech, che ha debuttato con un alto valore di $169, ha subito un forte calo in un breve periodo di tempo. Gli investitori che puntano ETH sul contratto intelligente di Friend.Tech guadagneranno il suo token di utilità, POINTs.</p>
<h2 id="h2-Introduzione61701"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Friend.tech, una piattaforma sociale decentralizzata, si è trasformata in un giocatore di primo piano <a href="https://www.gate.io/blog_detail/414/what-is-socialfi" target="_blank">nel settore SocialFi</a>. Per posizionarsi come un grande concorrente nel settore, il protocollo ha avviato diverse attività per attirare più utenti e servire diverse regioni geografiche. Di recente, ha lanciato la sua versione 2 del protocollo e ha distribuito in modo gratuito la sua criptovaluta nativa, FRIEND. Questo articolo illustra come Friend ha progredito con la sua distribuzione gratuita e il lancio della versione 2. Discuteremo anche le sue caratteristiche e prospettive.</p>
<h2 id="h2-Il20debutto20del20token20di20FriendTech20e20la20immediata20diminuzione20del20prezzo719578"><a name="Il debutto del token di Friend.Tech e la immediata diminuzione del prezzo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il debutto del token di Friend.Tech e la immediata diminuzione del prezzo</h2><p>Maggio è diventato un mese simbolico per Friend.Tech, una piattaforma sociale decentralizzata <a href="https://www.gate.io/learn/articles/what-is-base-blockchain/743" target="_blank">basato su Base</a>, dopo il lancio del suo protocollo versione 2 e dell’airdrop, mirato a attirare molti utenti sulla piattaforma. Friend.Tech ha lanciato sia il suo airdrop che il protocollo versione 2 il 4 maggio. Anche se la comunità crittografica si aspettava che i due sviluppi portassero Friend.Tech al livello successivo, la piattaforma SocialFi ha affrontato sfide con il suo airdrop.</p>
<p>DexScreener, un aggregatore di dati on-chain <a href="https://dexscreener.com/base/0x7cfc830448484cdf830625373820241e61ef4acf" rel="nofollow noopener noreferrer" target="_blank">concentrandosi sull’analisi dei dati in tempo reale</a> da molteplici scambi decentralizzati (DEX), indica che poco dopo il lancio del Friend.Tech airdrop il prezzo del token FRIEND è salito rapidamente prima di crollare. L’aggregatore di dati mostra che il prezzo del <a href="https://www.gate.io/article/36464/gate.io-will-list-friend.tech-friend &quot;Friend.Tech native token (FRIEND" rel="nofollow noopener noreferrer" target="_blank">Token nativo di Friend.Tech (FRIEND)</a> Il prezzo del Token FRIEND è sceso del 98% a 2,50 dollari dopo essere stato quotato a 169 dollari. Bitrue ha anche catturato il momento in cui il Token FRIEND è salito a 169 dollari, come indica il grafico seguente.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/top-10-popular-nfts-in-the-base-eco/2568" target="_blank">Le 10 NFT più popolari nell’ecosistema di Base</a><img src="https://gimg2.gateimg.com/image/article/17157370991.jpeg" alt=""><br>Picco Momentaneo del Prezzo FRIEND - <a href="https://support.bitrue.com/hc/article_attachments/32095576871705" rel="nofollow noopener noreferrer" target="_blank">Bitrue</a></p>
<p>Come <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> come indica, il prezzo di FRIEND è aumentato solo per un breve periodo. Questo è il motivo per cui altre società di analisi criptovalutarie come CoinGecko e CoinMarketCap non lo hanno indicato. <a href="https://www.gate.io/trade/FRIEND_USDT" target="_blank">prezzo del token FRIEND</a> è mai salito a $169. Ad esempio, dati su <a href="https://www.coingecko.com/en/coins/friend-tech" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a> mostra che dopo il lancio, il prezzo di FRIEND è salito a $3.26 prima di scendere del 48.52% da quel picco.</p>
<p>Al momento, CoinGecko indica che l’ATH di FRIEND era di $3,26 con un minimo storico di $0,8332. D’altra parte, il suo prezzo attuale è inferiore del 32,2% rispetto all’ATH. Nel frattempo, <a href="https://www.gate.io/price/base-protocol-base" target="_blank">Rete di base</a> Il contratto mostra che FRIEND ha un’offerta massima di 93.033.081,900000 e 53.779 detentori.</p>
<p>Quando scrivo, FRIEND sta scambiando a $2.21 dopo aver guadagnato il 12.1% nelle ultime 24 ore. Il token è in un trend ribassista poiché ha perso il 4.3% negli ultimi sette giorni come indica il grafico successivo.<br><img src="https://gimg2.gateimg.com/image/article/17157372052.jpeg" alt=""><br>Movimento dei prezzi FRIEND tra il 4 e il 12 maggio - <a href="https://www.coingecko.com/en/coins/friend-tech/usd#:~:text=to%20USD%20Chart-,Friend.,the%20total%20volume%20of%20Friend." rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a></p>
<p>Come osservato dal diagramma, FRIEND si trova in un mercato in range poiché il suo valore è oscillato tra $1,59 e $3,04 nelle ultime due settimane.</p>
<h2 id="h2-FRIEND20Token20Airdrop20e20lancio20della20piattaforma20Versione202176291"><a name="FRIEND Token Airdrop e lancio della piattaforma Versione 2" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FRIEND Token Airdrop e lancio della piattaforma Versione 2</h2><p>Dopo la versione <a href="https://www.gate.io/learn/articles/will-the-five-new-layer-2-forces-bring-new-opportunities-each-one-is-not-simple/1284" target="_blank">2 piattaforme lanciate su Ethereum Layer2 di Coinbase</a>(BASE) gli utenti della piattaforma sociale decentralizzata hanno riscontrato diversi problemi. In effetti, gli utenti del protocollo hanno segnalato varie sfide legate all’airdrop.</p>
<p>Innanzitutto, gli utenti si sono lamentati del sistema di ricompense cripto utilizzato per l’airdrop, dove i creatori hanno ricevuto molti più token FRIEND degli investitori al dettaglio. La causa di tali enormi discrepanze è stata l’uso di un sistema centralizzato di distribuzione dell’airdrop.</p>
<p>Come per <a href="https://m.odaily.news/en/post/5195032" rel="nofollow noopener noreferrer" target="_blank">Odaily News, Hitesh Malviya</a> Il fondatore di DYOR, una piattaforma di analisi crittografica, ha spiegato la causa di un sistema di distribuzione di airdrop così inequitativo. Ha detto: “La maggior parte degli utenti ha ricevuto 10 volte meno di quanto si aspettassero, quindi non l’hanno neanche richiesto perché per la maggior parte degli investitori al dettaglio era inferiore a 200 dollari. Allo stesso tempo, pochissime persone hanno finito per fare un sacco di soldi, quindi è stato un caso molto concentrato di airdrop.”</p>
<p>Di conseguenza, alcuni investitori al dettaglio hanno rifiutato di richiedere l’airdrop in quanto al di sotto delle loro aspettative. Uno di questi individui è Reetika Malik, un analista e trader di criptovalute con sede a Dubai. Pubblicando su X <a href="https://twitter.com/ReetikaTrades/status/1786275184627880373" rel="nofollow noopener noreferrer" target="_blank">Malik ha detto</a>, “NON sto vendendo la mia distribuzione aerea di $FRIEND (perché non posso neanche richiederla).”</p>
<p>È anche importante notare che l’airdrop di criptovaluta FRIEND aveva delle condizioni allegate. Ad esempio, ogni utente poteva ricevere il 10% dell’airdrop senza alcuna condizione. Tuttavia, per richiedere il resto dell’airdrop, un utente doveva unirsi al Money Club e seguire almeno altre 10 persone.</p>
<p>La piattaforma ha anche avuto problemi API che impediscono ad altri utenti di reclamare il loro token airdrop FRIEND. Ad esempio, alcuni utenti hanno avuto problemi nell’accesso all’interfaccia di Money Club. Cygaar, un investitore di criptovalute, è stato una delle persone che ha riscontrato problemi nel backend di Friend.Tech come mostrato nella seguente schermata.<br><img src="https://gimg2.gateimg.com/image/article/17157372823.jpeg" alt=""><br>Origine: <a href="https://twitter.com/0xCygaar/status/1786277839135989806" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<h2 id="h2-Problemi20di20liquidit20dietro20al20crollo20del20prezzo20di20FRIEND165938"><a name="Problemi di liquidità dietro al crollo del prezzo di FRIEND" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Problemi di liquidità dietro al crollo del prezzo di FRIEND</h2><p>Gli investitori al dettaglio e i creatori che hanno ottenuto con successo il Friend.Tech native token airdrop hanno affrontato un’altra sfida, quella dell’alta volatilità del mercato cripto. Sebbene il valore di FRIEND sia salito a $169 al suo lancio, il calo del prezzo della criptovaluta che è seguito ha scoraggiato molti appassionati di FRIEND. La loro speranza di un improvviso guadagno finanziario è svanita quando il prezzo di FRIEND è sceso a $2,50 poco dopo una forte impennata.</p>
<p>Diversi analisti cripto sostengono che la volatilità del mercato cripto FRIEND sia stata causata da problemi di liquidità simili a quelli che si sono verificati per Renzo la settimana precedente. Il problema principale era che il token FRIEND non era trasferibile ed era disponibile solo per il trading su BunnySwap. In modo più significativo, come confermato da McSleauth su X, gli sviluppatori avevano aggiunto solo $0.01 di liquidità.<br><img src="https://gimg2.gateimg.com/image/article/17157373294.jpeg" alt=""><br>Source: <a href="https://twitter.com/0xSleuth_/status/1786295247217246590" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Un’insufficiente liquidità significava che anche piccoli ordini di vendita avevano un grande impatto sulla fluttuazione del prezzo del token FRIEND. Ciò che ha reso la situazione peggiore è che un gran numero di persone ha scelto di vendere i propri token ricevuti tramite airdrop in risposta all’alto valore di debutto del FRIEND. Di conseguenza, l’alto pressione di vendita risultante ha portato a un brusco calo del prezzo del FRIEND.<br><img src="https://gimg2.gateimg.com/image/article/17157373595.jpeg" alt=""><br>Origine: <a href="https://twitter.com/0xSleuth_/status/1786295247217246590" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Presentazione della versione 2: nuove funzionalità e il Money Club<br>Inizialmente, Friend.Tech, <a href="https://www.gate.io/learn/articles/rapid-rise-and-fall-is-friend-tech-another-socialfi-bubble/866" target="_blank">lanciato nell’agosto del 2023</a>, ha utilizzato un servizio su invito e un sistema di punti premio. Ora, il lancio della sua versione V2 include nuove funzionalità come il Money Club e un sistema di punti rivisto. In particolare, la funzionalità Money Club Friend Tech ha uno spazio di comunicazione esclusivo per discussioni finanziarie.</p>
<p>D’altra parte, il sistema di punti rivisto premierà gli utenti di Friend.Tech per il loro coinvolgimento e altre contribuzioni sulla piattaforma. Secondo <a href="https://dune.com/whale_hunter/friend-tech-ultimate-analytics" rel="nofollow noopener noreferrer" target="_blank">Dune, una piattaforma di analisi dei dati</a>, dal 4 maggio, quando Friend.Tech ha rilasciato V2 ci sono più di 112.346 club con un volume totale di transazioni di oltre 16.899.404 FRIEND. Allo stesso modo, le commissioni di transazione hanno superato i 252.651 token FRIEND.</p>
<p>Nel frattempo, un contratto intelligente FRIEND trapelato indica che la piattaforma sociale decentralizzata intende introdurre token v2 non trasferibili. Allo stesso tempo, introdurrà anche una tassa del 1,5% per i trasferimenti con l’obiettivo di preservare il valore di FRIEND. <a href="https://twitter.com/Cbb0fe/status/1785927823909179858" rel="nofollow noopener noreferrer" target="_blank">CBBOFE</a> ha indicato su X, gli utenti utilizzeranno i punti per comprare i club.<br><img src="https://gimg2.gateimg.com/image/article/17157374386.jpeg" alt=""><br>Origine: <a href="https://twitter.com/Cbb0fe/status/1785927823909179858" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>POINTS sarà un token di utilità nativo che i titolari possono depositare e guadagnare una ricompensa. In modo ancora più significativo, i POINTs saranno scambiati su BunnySwap, il DEX nativo di Friend.Tech. La funzione principale di POINTS è consentire la creazione di club sociali sulla piattaforma. Tuttavia, i titolari di POINTS possono trasferire il token solo a indirizzi di portafoglio in whitelist, il che potrebbe aiutare a preservarne il valore. Gli utenti guadagneranno principalmente POINTS depositando i loro ETH nel contratto intelligente Friend.tech.</p>
<h2 id="h2-Coinvolgimento20e20Ricompense20Strategia20di20FriendTech207711"><a name="Coinvolgimento e Ricompense: Strategia di Friend.Tech" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Coinvolgimento e Ricompense: Strategia di Friend.Tech</h2><p>Friend.Tech ha ideato un modo per premiare i suoi utenti più attivi come sviluppatori e creatori di contenuti. Per raggiungere questo obiettivo, la piattaforma dispone di strumenti avanzati che consentono agli utenti di creare e condividere contenuti in modo conveniente.</p>
<p>Inoltre, Friend.Tech offre opportunità uniche di monetizzazione per i creatori di contenuti. In tal modo, i partecipanti possono guadagnare il suo token nativo che ha un valore reale nel mondo reale. I detentori di token possono utilizzare l’asset criptato per accedere a servizi premium o convertire le loro posizioni in altre criptovalute.</p>
<h2 id="h2-Qual2020il20prossimo20passo20per20FriendTech20e20il20token20FRIEND20387"><a name="Qual è il prossimo passo per Friend.Tech e il token FRIEND?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è il prossimo passo per Friend.Tech e il token FRIEND?</h2><p>Il recente lancio della versione 2 di Friend.Tech ha suscitato un rinnovato interesse nella piattaforma SocialFi. Di conseguenza, dopo il lancio, il numero di utenti attivi è aumentato notevolmente, mentre sono stati creati più di 15.000 club. Tuttavia, l’analisi dei dati mostra che la maggior parte degli utenti attivi sono membri che tornano.</p>
<p>Una delle cose che sta frenando gli utenti è la mancanza di una comunicazione chiara da parte del team di Friend.Tech. Pertanto, per promuovere la crescita della piattaforma e l’apprezzamento di FRIEND, il team dovrebbe rimanere costantemente in contatto con i suoi membri per mantenere il loro interesse e motivazione nel progetto.</p>
<p>Il futuro di Friend.Tech dipende dalla sua recente distribuzione gratuita e dall’aggiornamento V2 che l’ha posizionata come una piattaforma leader di social networking decentralizzato nel settore delle criptovalute. Le sue nuove funzionalità innovative e l’interazione della comunità probabilmente porteranno ad un aumento della domanda dei suoi servizi e della criptovaluta nativa.</p>
<p>L’atteso aggiornamento V2 è fondamentale per l’autonomia degli utenti che dovrebbe guidarne la crescita. Ad esempio, l’aggiornamento V2 ha migliorato la scalabilità, la sicurezza e la privacy, il che probabilmente ne aumenterà l’usabilità e la soddisfazione degli utenti.</p>
<h2 id="h2-Conclusione891165"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Dopo il lancio della Versione 2 di Friend.Tech e la sua distribuzione gratuita, il valore di FRIEND è salito a $169 prima di crollare a $2.50. Le principali cause del brusco calo del prezzo sono state la liquidità insufficiente e una forte vendita. La piattaforma della versione 2 supporta la creazione di club sociali e un nuovo token di utilità, POINTs. Nel frattempo, gli utenti hanno già creato oltre 15.000 club che aumentano l’interazione sociale.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista 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 sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>