QXJiaXRydW0gKEFSQikgaGFuZGhhYWZ0IGdyb2VpIDMgbWFhbmRlbiBuYSAkMTIwIG0gQWlyZHJvcA==

<p><img src="https://gimg2.gateimg.com/blog/1679447253722320711jiami.jpeg" alt=""><br>Het Arbitrum-netwerk heeft de afgelopen drie maanden groei doorgemaakt.</p>
<p>De ARB-stieren hebben een kritische ondersteuningsniveau van $1,10 gehandhaafd.</p>
<p>De meeste institutionele DAO’s hebben hun ARB vastgehouden sinds het airdrop-evenement.</p>
<p><strong>Trefwoorden</strong>: Arbitrum-token, Arbitrum-prijs, Arbitrum-airdrop, ARB-prijs, prijs van Arbitrum, ARB-token, Arbitrum-tokenprijs</p>
<h2 id="h2-Introductie722624"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Arbitrum, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Layer-2-protocol’s $120 miljoen airdrop dat <a href="https://www.gate.io/blog_detail/1065/layer-2-project-tour-how-to-prepare-for-arbitrum-airdrop" target="_blank">gebeurde in april</a> was een van de belangrijkste crypto-evenementen tijdens het eerste kwartaal van 2023, omdat het de blockchain transformeerde in een gedecentraliseerde autonome organisatie.</p>
<p>Het creëerde echter ook angst onder ARB-investeerders die dachten dat de airdrop zou kunnen leiden tot een scherpe prijsdaling als gevolg van een toename van het aanbod van de Arbitrum-token. Dit artikel beoordeelt de impact van de airdrop van Arbitrum op de ARB-tokenprijs.</p>
<h2 id="h2-ARB20op20een20opwaartse20prijskoers422496"><a name="ARB op een opwaartse prijskoers" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ARB op een opwaartse prijskoers</h2><p>De Arbitrum-token presteert beter dan wat analisten hadden voorspeld toen het de ARB-luchtdrop uitdeelde. Dit komt doordat er drie maanden zijn verstreken. <a href="https://www.gate.io/blog_detail/505/arbitrum-a-much-needed-solution-to-ethereum-s-inefficiencies" target="_blank">na de Arbitrum airdrop</a> De ARB heeft een gestage netwerkgroei doorgemaakt terwijl de prijs blijft stijgen.<br><img src="https://gimg2.gateimg.com/image/article/16885315801.png" alt=""><br>ARB-token - Moneytimes</p>
<p>Tot nu toe heeft de Arbitrum-token zijn positie boven $1 geconsolideerd als gevolg van een hoge gebruiksgraad. Dit gaat verder dan wat de markt heeft verwacht. In het verleden hebben de meeste crypto-projecten die hun tokens via airdrops hebben gedistribueerd, scherpe dalingen in waarde ervaren tijdens de onmiddellijke post-airdrop periode.</p>
<p>Het verhaal is echter anders voor de <a href="https://www.gate.io/price/arbitrum-arb" target="_blank">ARB token</a> waarvan de waarde kort na het luchtdropevenement begon te stijgen. Het aantal blockchain-gebruikers steeg ook in de drie maanden die daarop volgden. Zo meldden zich bijvoorbeeld 11.312 nieuwe gebruikers aan op het Arbitrum-netwerk toen op 25 april 90 miljoen ARB-tokens werden gedistribueerd via het luchtdropevenement.</p>
<p>Volgens Santiment bleef het aantal nieuwe gebruikers op het Arbitrum-netwerk in juni toenemen. Ter illustratie, tegen 16 juni had het netwerk 12.451 nieuwe portemonnee-adressen, wat een nieuw hoogtepunt werd. Daarnaast registreerde het ook 3.252 nieuwe adressen op 18 juni en nog eens 4.747 op 21 juni. De volgende grafiek toont veranderingen in het aantal nieuwe portemonnee-adressen tussen april en juni.<br><img src="https://gimg2.gateimg.com/image/article/16885316152.png" alt=""><br>Wijzigingen in walletadressen op het Arbitrum Network - Santiment</p>
<h2 id="h2-Waarom20heeft20het20Arbitrumnetwerk20groei20doorgemaakt20na20de20airdrop943567"><a name="Waarom heeft het Arbitrum-netwerk groei doorgemaakt na de airdrop?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom heeft het Arbitrum-netwerk groei doorgemaakt na de airdrop?</h2><p>De aard van de Arbitrum airdrop verklaart waarom het netwerk groei zag gedurende de post-airdrop periode. Het grootste deel van de ARB-tokens werd gedistribueerd naar gedecentraliseerde autonome organisaties (DAO’s) als airdrop.</p>
<p>Specifiek, <a href="https://t.co/AwCGeTIX1G" rel="nofollow noopener noreferrer" target="_blank">Arbitrum verdeelde 113 ARB</a> tokens naar in aanmerking komende DAO’s, waaronder SushiSwap Treasure DAO, <a href="/price/gmx-gmx" rel="nofollow noopener noreferrer" target="_blank">GMX</a>, Dopex, <a href="/price/balancer-bal" rel="nofollow noopener noreferrer" target="_blank">Balancer</a> en stralend. Aangezien institutionele DAO’s op de lange termijn houders zijn, hebben er maar heel weinig van hen hun tokens verkocht. In plaats daarvan geven ze er de voorkeur aan om passief inkomen te verdienen door ze vast te houden.</p>
<p>Bovendien verkopen de meeste institutionele DAO’s hun tokens niet impulsief vanwege het tijdrovende stemproces. Daarom is er door de keuze van DAO’s om hun ARB-tokens lang vast te houden, een kleine kans op prijscorrectie in de nabije toekomst.</p>
<h2 id="h2-ARBinvesteerders20tonen20langdurige20betrokkenheid143919"><a name="ARB-investeerders tonen langdurige betrokkenheid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ARB-investeerders tonen langdurige betrokkenheid</h2><p>Opmerkelijk is dat de meeste ARB-houders hebben laten zien dat ze bereid zijn om de tokens langdurig vast te houden. Dit blijkt uit de afnemende ARB Age Consumed in de afgelopen drie maanden. Zo is het bijvoorbeeld gedaald van 4,9 miljard op 31 mei tot 250,71 miljoen op 21 juni, een vermindering van 95%.</p>
<p>Een scherpe daling in de Age Consumed geeft aan dat de investeerders hun cryptocurrency voor een lange periode vasthouden. Dit toont ook aan dat de investeerders vertrouwen hebben in de langetermijn levensvatbaarheid en groei van het Arbitrum-netwerk.</p>
<p>Gezien de bovenstaande factoren zijn de ARB-stieren zeer waarschijnlijk van plan het ondersteuningsniveau van $1,10 te handhaven om een opwaartse prijsstijging in stand te houden. Ook geeft de ARB Market Value to Realized Value (MVRV) ratio aan dat de investeerders die de ARB-tokens hebben gekocht tijdens mei en juni een ongerealiseerd verlies van ongeveer 3% hebben. Dit betekent dat ze alleen winst kunnen genereren als ze hun ARB-tokens verkopen tegen een prijs van minstens $1,20.</p>
<p>Als de prijs van Arbitrum stijgt boven $1.20, kan het zich opmaken voor een stijging richting $1.35. Desalniettemin, als de verkoopdruk in de nabije toekomst toeneemt, kan de ARB-prijs onder $1.10 dalen, wat het mogelijk dwingt verder te dalen richting $1.</p>
<h2 id="h2-Conclusie507199"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Drie maanden na de airdrop van Arbitrum ter waarde van $120 miljoen blijft de waarde van de Arbitrum token stabiel tot stijgend van aard. De belangrijkste reden hiervoor is dat de institutionele DAO’s vasthouden aan hun ARB-tokens. Als gevolg van het vertrouwen dat ARB-investeerders hebben in de levensvatbaarheid en potentiële groei van het Arbitrum-netwerk, is het aantal nieuwe portemonnee-adressen sinds april gestegen.</p>
<h2 id="h2-Veelgestelde20vragen20over20Arbitrum572166"><a name="Veelgestelde vragen over Arbitrum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Arbitrum</h2><h3 id="h3-Wat20is20de20toekomst20van20het20ARBtoken80172"><a name="Wat is de toekomst van het ARB-token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de toekomst van het ARB-token?</h3><p>De ARB-token, die een governance-token is voor de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> scaling oplossing Arbitrum, heeft een hoog vooruitzicht omdat het wordt ondersteund door veel institutionele investeerders en zal worden gebruikt voor het ontwikkelen van de blockchain. De waarde ervan zal waarschijnlijk constant toenemen over een lange periode.</p>
<h3 id="h3-Is20Arbitrum20crypto20een20goede20investering76728"><a name="Is Arbitrum crypto een goede investering?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Arbitrum crypto een goede investering?</h3><p>De Arbitrum-crypto is een goede investeringsactiva, aangezien het waarschijnlijk veel waarde zal winnen in de loop van de tijd, aangezien het een governance-token is en ook wordt gebruikt voor het ontwikkelen van de blockchain. Het feit dat veel DAO’s het ondersteunen, betekent dat het een hoge liquiditeit heeft.</p>
<h3 id="h3-Hoeveel20zal20Arbitrum20waard20zijn176021"><a name="Hoeveel zal Arbitrum waard zijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel zal Arbitrum waard zijn?</h3><p>De Arbitrum-token zal naar verwachting schommelen tussen $1,62 en $2,11 tegen het einde van 2023. Sommige analisten voorspellen dat de waarde ervan zal schommelen tussen $27,35 en $35,56 tegen 2030. Lees ook prijsvoorspellingen <a href="https://www.gate.io/price-prediction/arbitrum-arb" target="_blank">voor ABR in 2023-2030</a>.</p>
<h3 id="h3-Wat20is20het20gebruik20van20ARBtoken499925"><a name="Wat is het gebruik van ARB-token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het gebruik van ARB-token?</h3><p>De ARB-token <a href="https://www.gate.io/learn/articles/a-deep-dive-into-arbitrum/487" target="_blank">is een governance-token voor de Arbitrum blockchain</a>. Het wordt ook gebruikt voor de financiering van de ontwikkeling van de blockchain.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<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 is toegestaan om het artikel opnieuw te plaatsen mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>