RGUgaW5oZWVtc2UgdG9rZW4gdmFuIEZyaWVuZC5UZWNoIHN0b3J0IGluIG5hIGRlIGxhbmNlcmluZy4=

<p><img src="https://gimg2.gateimg.com/image/article/1715736891sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR817120"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Friend.Tech lanceerde zijn versie 2 platform, dat de schaalbaarheid, beveiliging en privacy van gebruikers heeft verbeterd.</p>
<p>De inheemse token van Friend.Tech, die debuteerde met een hoge waarde van $169, kende een scherpe daling binnen een korte periode.<br>Investeerders die ETH inzetten op het Friend.Tech smart contract zullen hun utility token, POINTs, verdienen.</p>
<h2 id="h2-Introductie498265"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Friend.tech, een gedecentraliseerd sociaal platform, is uitgegroeid tot een belangrijke speler <a href="https://www.gate.io/blog_detail/414/what-is-socialfi" target="_blank">in de SocialFi sector</a>. Om zichzelf te positioneren als een sterke concurrent in de industrie, heeft het protocol verschillende activiteiten gestart om meer gebruikers aan te trekken en verschillende geografische regio’s te bedienen. Onlangs lanceerde het zijn versie 2 protocol en deed het een airdrop van zijn native cryptocurrency, FRIEND. Dit artikel behandelt hoe Friend vooruitging met zijn airdrop en versie 2 lancering. We zullen ook de eigenschappen en vooruitzichten bespreken.</p>
<h2 id="h2-De20introductie20van20FriendTechs20token20en20de20onmiddellijke20prijsdaling434330"><a name="De introductie van Friend.Tech’s token en de onmiddellijke prijsdaling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De introductie van Friend.Tech’s token en de onmiddellijke prijsdaling</h2><p>Mei is een symbolische maand geworden voor Friend.Tech, een gedecentraliseerd sociaal platform <a href="https://www.gate.io/learn/articles/what-is-base-blockchain/743" target="_blank">gebaseerd op Base</a>, na de lancering van zijn versie 2 protocol en airdrop, gericht op het aantrekken van veel gebruikers naar het platform. Friend.Tech lanceerde zowel zijn airdrop als versie 2 protocol op 4 mei. Hoewel de cryptogemeenschap verwachtte dat de twee ontwikkelingen Friend.Tech naar een hoger niveau zouden tillen, werd het SocialFi-platform geconfronteerd met uitdagingen met zijn airdrop.</p>
<p>DexScreener, een on-chain gegevensaggregator <a href="https://dexscreener.com/base/0x7cfc830448484cdf830625373820241e61ef4acf" rel="nofollow noopener noreferrer" target="_blank">gericht op real-time data-analyse</a> uit meerdere gedecentraliseerde beurzen (DEXs) blijkt dat kort na de lancering van de Friend.Tech airdrop de prijs van de FRIEND-token scherp steeg voordat hij kelderde. De gegevensaggregatie toont aan dat de prijs van de <a href="https://www.gate.io/article/36464/gate.io-will-list-friend.tech-friend" target="_blank">Friend.Tech native token (FRIEND)</a> daalde met 98% naar US$2,50 nadat het debuteerde op US$169. Bitrue heeft ook het moment vastgelegd waarop de FRIEND Token steeg naar $169, zoals blijkt uit de volgende grafiek.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/top-10-popular-nfts-in-the-base-eco/2568" target="_blank">Top 10 Populaire NFT’s in het Base-ecosysteem</a><img src="https://gimg2.gateimg.com/image/article/17157370991.jpeg" alt=""><br>FRIEND Tijdelijke prijspiek - <a href="https://support.bitrue.com/hc/article_attachments/32095576871705" rel="nofollow noopener noreferrer" target="_blank">Bitrue</a></p>
<p>Als <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a> Zoals aangegeven, steeg de FRIEND-prijs slechts gedurende een zeer korte periode. Dat is de reden waarom andere crypto-analytische bedrijven zoals CoinGecko en CoinMarketCap dat niet hebben aangegeven. <a href="https://www.gate.io/trade/FRIEND_USDT" target="_blank">FRIEND-tokenprijs</a> ooit steeg tot $169. Bijvoorbeeld, gegevens over <a href="https://www.coingecko.com/en/coins/friend-tech" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a> toont aan dat na de lancering de prijs van FRIEND steeg naar $3,26 voordat deze met 48,52% daalde vanaf dat hoogtepunt.</p>
<p>Op dit moment geeft CoinGecko aan dat het allerhoogste niveau van FRIEND $3,26 was met een dieptepunt van $0,8332. Aan de andere kant ligt de huidige prijs 32,2% lager dan zijn ATH. Ondertussen, <a href="https://www.gate.io/price/base-protocol-base" target="_blank">Basisnetwerk</a> Het contract toont aan dat FRIEND een maximale voorraad heeft van 93.033.081,900000 en 53.779 houders.</p>
<p>Bij het schrijven handelt FRIEND op $2.21 na een winst van 12.1% in de afgelopen 24 uur. De token bevindt zich in een bearish trend omdat hij in de afgelopen zeven dagen met 4.3% is gedaald, zoals de volgende grafiek aangeeft.<br><img src="https://gimg2.gateimg.com/image/article/17157372052.jpeg" alt=""><br>PRIJSBEWEGING van FRIEND tussen 4 en 12 mei – <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>Zoals waargenomen uit het diagram, bevindt FRIEND zich in een zijwaartse markt, aangezien de waarde de afgelopen twee weken schommelt tussen $1,59 en $3,04.</p>
<h2 id="h2-FRIEND20Token20Airdrop20en20Lancering20van20Platform20Versie202442772"><a name="FRIEND Token Airdrop en Lancering van Platform Versie 2" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FRIEND Token Airdrop en Lancering van Platform Versie 2</h2><p>Na de versie <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 platform lancering op Coinbase Ethereum Layer2</a>(BASE) de gedecentraliseerde sociale platformgebruikers ondervonden verschillende problemen. In feite meldden de protocolgebruikers verschillende uitdagingen met betrekking tot de airdrop.</p>
<p>Ten eerste klaagden gebruikers over het crypto-beloningssysteem dat werd gebruikt voor de airdrop, waarbij de makers veel meer FRIEND-tokens ontvingen dan de particuliere beleggers. De oorzaak van dergelijke grote verschillen was het gebruik van een gecentraliseerd airdrop-distributiesysteem.</p>
<p>Zoals per <a href="https://m.odaily.news/en/post/5195032" rel="nofollow noopener noreferrer" target="_blank">Odaily News, Hitesh Malviya</a>, de oprichter van DYOR, een crypto-analyseplatform, legde de oorzaak uit van zo’n onrechtvaardig airdrop-distributiesysteem. Hij zei: “De meeste gebruikers ontvingen 10 keer minder dan ze hadden verwacht, dus ze hebben het niet eens geclaimd omdat het voor de meeste particuliere beleggers minder dan $ 200 was. Tegelijkertijd verdienden maar heel weinig mensen uiteindelijk veel geld, dus het was een heel geconcentreerd g van een airdrop.”</p>
<p>Als gevolg hiervan weigerden sommige particuliere beleggers de airdrop op te eisen omdat deze onder hun verwachtingen lag. Een van deze individuen is Reetika Malik, een in Dubai gevestigde crypto-analist en handelaar. Postend op X. <a href="https://twitter.com/ReetikaTrades/status/1786275184627880373" rel="nofollow noopener noreferrer" target="_blank">Malik zei</a> Ik verkoop mijn $FRIEND-luchtdruppel niet (omdat ik het zelfs niet kan claimen).</p>
<p>Het is ook belangrijk op te merken dat de FRIEND crypto airdrop voorwaarden had. Bijvoorbeeld, elke gebruiker kon 10% van de airdrop ontvangen zonder enige voorwaarden. Echter, om de rest van de airdrop te claimen, moest een gebruiker zich aansluiten bij de Money Club en ten minste 10 anderen volgen.</p>
<p>Het platform had ook API-storingen waardoor andere gebruikers hun FRIEND-token airdrop niet konden claimen. Sommige gebruikers hadden bijvoorbeeld problemen met het openen van de Money Club-interface. Cygaar, een crypto-investeerder, was een van de mensen die te maken kreeg met de backend-problemen van Friend.Tech, zoals te zien is in de volgende screenshot.<br><img src="https://gimg2.gateimg.com/image/article/17157372823.jpeg" alt=""><br>Bron: <a href="https://twitter.com/0xCygaar/status/1786277839135989806" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<h2 id="h2-Liquiditeitsproblemen20achter20de20prijscrash20van20FRIEND84739"><a name="Liquiditeitsproblemen achter de prijscrash van FRIEND" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Liquiditeitsproblemen achter de prijscrash van FRIEND</h2><p>De particuliere beleggers en makers die met succes de Friend.Tech native token airdrop hebben geclaimd, werden geconfronteerd met nog een andere uitdaging, namelijk de hoge volatiliteit van de cryptomarkt. Hoewel de waarde van FRIEND steeg tot $169 bij de lancering, ontmoedigde de daling van de cryptoprijs die volgde veel FRIEND-enthousiastelingen. Hun hoop op een plotselinge financiële winst wankelde toen de FRIEND-prijs kort daarna daalde tot $2.50 na een sterke stijging.</p>
<p>Verschillende cryptanalisten beweren dat de volatiliteit van de FRIEND crypto-markt het gevolg was van liquiditeitsproblemen, vergelijkbaar met wat er vorige week met Renzo gebeurde. Het belangrijkste probleem was dat de FRIEND-token niet overdraagbaar was en alleen verhandelbaar was op BunnySwap. Nog belangrijker is dat, zoals McSleauth bevestigde op X, de ontwikkelaars slechts $0,01 aan liquiditeit hebben toegevoegd.<br><img src="https://gimg2.gateimg.com/image/article/17157373294.jpeg" alt=""><br>Bron: <a href="https://twitter.com/0xSleuth_/status/1786295247217246590" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Onvoldoende liquiditeit betekende dat zelfs kleine verkooporders een grote invloed hadden op de fluctuatie van de FRIEND-tokenprijs. Wat de situatie verergerde, was dat een groot aantal individuen ervoor koos om hun luchtdruppel-tokens te verkopen in reactie op de hoge FRIEND-waarde bij de introductie. Hierdoor leidde de resulterende hoge verkoopdruk tot een scherpe daling van de FRIEND-prijs.<br><img src="https://gimg2.gateimg.com/image/article/17157373595.jpeg" alt=""><br>Bron: <a href="https://twitter.com/0xSleuth_/status/1786295247217246590" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Introductie van Versie 2: Nieuwe Functies en de Money Club<br>In eerste instantie, Friend.Tech, <a href="https://www.gate.io/learn/articles/rapid-rise-and-fall-is-friend-tech-another-socialfi-bubble/866" target="_blank">gelanceerd in augustus 2023</a>, gebruikte een exclusieve service op uitnodiging en een beloningssysteem. Nu bevat de lancering van de V2-versie nieuwe functies zoals de Money Club en een herzien beloningssysteem. Opmerkelijk is dat de Money Club Friend Tech-functie een exclusieve communicatie- en financiële discussieruimte heeft.</p>
<p>Aan de andere kant zal het herziene puntensysteem Friend.Tech gebruikers belonen voor hun betrokkenheid en andere bijdragen op het platform. Volgens <a href="https://dune.com/whale_hunter/friend-tech-ultimate-analytics" rel="nofollow noopener noreferrer" target="_blank">Dune, een platform voor gegevensanalyse</a>, sinds 4 mei, toen Friend.Tech V2 uitbracht, zijn er meer dan 112.346 clubs met een totale transactievolume van meer dan 16.899.404 FRIENDs. Evenzo zijn de transactiekosten de 252.651 FRIEND-tokens overschreden.</p>
<p>In de tussentijd blijkt uit een gelekt FRIEND smart contract dat het gedecentraliseerde sociale platform van plan is om niet-overdraagbare v2 tokens te introduceren. Tegelijkertijd zal het ook een vergoeding van 1,5% invoeren voor overdrachten met als doel de waarde van FRIEND te behouden. Als <a href="https://twitter.com/Cbb0fe/status/1785927823909179858" rel="nofollow noopener noreferrer" target="_blank">CBBOFE</a> heeft aangegeven op X, zullen de gebruikers de punten gebruiken om clubs te kopen.<br><img src="https://gimg2.gateimg.com/image/article/17157374386.jpeg" alt=""><br>Bron: <a href="https://twitter.com/Cbb0fe/status/1785927823909179858" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>POINTS zal een inheemse utility-token zijn waarvan de houders kunnen inzetten en beloningen kunnen verdienen. Belangrijker nog, POINTs worden verhandeld op BunnySwap, de inheemse DEX van Friend.Tech. De belangrijkste functie van POINTS is het mogelijk maken van de oprichting van sociale clubs op het platform. Houders van POINTS kunnen de token echter alleen overdragen naar whitelisted walletadressen, wat kan helpen om de waarde ervan te behouden. Gebruikers zullen voornamelijk POINTS verdienen door hun ETH in te zetten in het Friend.tech smart contract.</p>
<h2 id="h2-Betrokkenheid20en20beloningen20de20strategie20van20FriendTech691554"><a name="Betrokkenheid en beloningen: de strategie van Friend.Tech" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Betrokkenheid en beloningen: de strategie van Friend.Tech</h2><p>Friend.Tech heeft een manier bedacht om zijn meest actieve gebruikers, zoals ontwikkelaars en contentmakers, te belonen. Om dat te bereiken, heeft het platform geavanceerde tools waarmee gebruikers op een handige manier inhoud kunnen maken en delen.</p>
<p>Ook heeft Friend.Tech unieke verdienmogelijkheden voor de inhoudsmakers. Als zodanig kunnen de deelnemers zijn eigen token verdienen, die echte waarde heeft in de echte wereld. De tokenhouders kunnen de cryptomunt gebruiken om toegang te krijgen tot premium diensten of hun bezittingen om te zetten naar andere cryptocurrencies.</p>
<h2 id="h2-Wat20staat20er20te20gebeuren20voor20FriendTech20en20de20FRIEND20Token437337"><a name="Wat staat er te gebeuren voor Friend.Tech en de FRIEND Token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat staat er te gebeuren voor Friend.Tech en de FRIEND Token?</h2><p>De recente lancering van Friend.Tech versie 2 heeft hernieuwde interesse in het SocialFi-platform opgewekt. Als gevolg hiervan is het aantal actieve gebruikers aanzienlijk toegenomen na de lancering, terwijl er meer dan 15.000 clubs zijn aangemaakt. Uit de analyse van de gegevens blijkt echter dat de meeste actieve gebruikers terugkerende leden zijn.</p>
<p>Eén van de dingen die gebruikers tegenhoudt, is het gebrek aan duidelijke communicatie van het Friend.Tech team. Daarom moet het team om de groei van het platform en de waardering voor FRIEND te bevorderen, voortdurend in contact blijven met haar leden om hun interesse en motivatie in het project te behouden.</p>
<p>De toekomst van Friend.Tech hangt af van de recente airdrop en V2-upgrade, waardoor het zich opnieuw positioneert als een toonaangevend gedecentraliseerd sociaal netwerkplatform in crypto. De nieuwe innovatieve functies en communitybetrokkenheid zullen waarschijnlijk leiden tot een stijging in de vraag naar de diensten en de inheemse cryptocurrency.</p>
<p>De langverwachte V2-upgrade is essentieel voor gebruikersautonomie, wat de groei ervan zou moeten stimuleren. Bijvoorbeeld, de V2-upgrade heeft de schaalbaarheid, beveiliging en privacy verbeterd, wat waarschijnlijk de bruikbaarheid en tevredenheid van gebruikers zal verhogen.</p>
<h2 id="h2-Conclusie239727"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Na de lancering van Versie 2 van Friend.Tech en de airdrop steeg de waarde van FRIEND naar $169 voordat deze kelderde naar $2,50. De belangrijkste oorzaken van de sterke prijsdaling waren onvoldoende liquiditeit en een grote verkoopgolf. Het platform van versie 2 ondersteunt de creatie van sociale clubs en een nieuwe utility token, POINTs. Inmiddels hebben gebruikers al meer dan 15.000 clubs aangemaakt, wat de sociale betrokkenheid bevordert.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Mashell C. </strong>, Onderzoeker Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>