U2hpYmFyaXVtIGJlcmVpa3QgbWlqbHBhYWwgdmFuIDEwIG1pbGpvZW4gdHJhbnNhY3RpZXZvbHVtZSB2b29yIFNoaWJhIEludQ==

2023-06-12, 07:55

<p><img src="https://gimg2.gateimg.com/image/article/1686555966RDZZ.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen879594"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Het onlangs gelanceerde Shibarium layer-2 protocol leidde tot een hoog aantal transacties van de <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> token.</p>
<p>Alleen al in de derde week van mei werden meer dan 3 miljoen Shiba-tokens verbrand.</p>
<p>De Shiba Inu-gemeenschap heeft Twitter verzocht om Shiba-tokens in zijn betalingssysteem te integreren.</p>
<h2 id="h2-Kennismaking529688"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>De cryptocurrency-sector, met duizenden tokens/munten op de markt, is een van de meest concurrerende industrieën. Veel memecoins vinden het leuk <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a>, Floki Inu, PEPE en <a href="/price/shiba-inu-shib" target="_blank" class="blog_inner_link">Shiba Inu</a> zijn essentiële activa binnen de cryptoruimte. Sommige van deze memecoins presteren goed op de markt, ondanks dat ze geen intrinsieke waarden hebben. Dit artikel behandelt hoe Shiba Inu heeft gepresteerd tijdens 2023 en de impact van Shibarium op zijn <a href="https://www.gate.io/price-prediction/shiba-inu-shib" target="_blank">toekomstige prijsprestaties.</a></p>
<h2 id="h2-Shibarium20bereikt20de20mijlpaal20van201020miljoen20transactievolume924565"><a name="Shibarium bereikt de mijlpaal van 10 miljoen transactievolume" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Shibarium bereikt de mijlpaal van 10 miljoen transactievolume</h2><p>Shibarium’s Puppynet testnet, Shiba Inu layer-2 netwerk, bereikte in de derde week van mei een record van 10 miljoen transactievolume. Zo’n hoog transactievolume is een teken dat de vraag naar Shiba-tokens groeit vanwege zijn grote gebruikersbasis.</p>
<p>Shibarium is een <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain <a href="https://www.gate.io/blog_detail/357/essentials-for-crypto-newbie-what-is-layer-0-layer-1-and-layer-2" target="_blank">op layer-2 gebaseerde schaaloplossing</a> die inspeelt op het Shiba Inu-ecosysteem. Wat het publiek momenteel gebruikt, is het testnet omdat het team het mainnet nog niet heeft gelanceerd. De Shiba Inu-community heeft echter positief gereageerd op de ontwikkeling.</p>
<p>Lees ook: <a href="https://www.gate.io/how-to-buy/shibarium-name-service-sns &quot;How to Buy Shibarium Name Service (SNS" rel="nofollow noopener noreferrer" target="_blank">Hoe de Shibarium Naamservice (SNS) te kopen</a>”)</p>
<p>Gegevens op Puppyscan tonen aan dat Puppynet in de derde week van mei een transactievolume van 10,3 miljoen en meer dan 921.214 blokken heeft geregistreerd. Andere statistieken tonen aan dat de blockchain meer dan 15 miljoen portemonnee-adressen heeft en een gemiddelde bloktijd van 5 seconden. Sinds 12 mei registreert het protocol een gemiddelde van meer dan 300.000 dagelijkse transacties.</p>
<h2 id="h2-Meer20dan20320miljoen20Shiba20Inu20tokens20verbrand20in20mei900629"><a name="Meer dan 3 miljoen Shiba Inu tokens verbrand in mei" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Meer dan 3 miljoen Shiba Inu tokens verbrand in mei</h2><p>De andere interessante statistieken hebben betrekking op het aantal verbrande tokens en de toename van het verbrandingspercentage. Binnen de derde week van mei werden meer dan 3 miljoen Shiba Inu-tokens verbrand, wat naar verwachting op de lange termijn de prijs zal doen stijgen.</p>
<p>Ondanks de recente verbrandingen blijft de circulerende voorraad van Shiba-tokens hoog, aangezien het nog steeds meer dan 589,3 biljoen is. Bovendien werden tijdens de tweede week van mei meer dan 5 miljoen SHIB verbrand. De volgende statistieken geven een duidelijk beeld van de verbrandingsgeschiedenis van Shiba-token.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1686556164Shibarium 1.png" alt=""><br>Shiba-verbrandingsstatistieken - Trackshib</p>
<p>Zoals het diagram laat zien, zijn er alleen al in mei meer dan 13 biljoen Shiba-tokens verbrand. Het geeft ook aan dat er tot nu toe meer dan 410 biljoen tokens zijn verbrand.</p>
<h2 id="h2-Gemeenschap20dringt20er20bij20Twitter20op20aan20om20Shiba20Token20te20integreren556061"><a name="Gemeenschap dringt er bij Twitter op aan om Shiba Token te integreren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gemeenschap dringt er bij Twitter op aan om Shiba Token te integreren</h2><p>De Shiba Inu-gemeenschap heeft Linda Yaccarino, de nieuwe CEO van Twitter, gevraagd om Shiba-token te integreren in haar betalingssysteem, een stap die de vraag zou vergroten en uiteindelijk de waarde ervan zou verhogen.</p>
<p>Bijvoorbeeld, Ragnar Shib, een van de fervente voorstanders van de Shiba-token, <a href="https://twitter.com/RagnarShiba/status/1657535845593755648" rel="nofollow noopener noreferrer" target="_blank">tweette</a>“Als er problemen zijn bij het integreren van @Shibtoken op Twitter, laat het ons weten. We hebben de meest loyale, behulpzame en grootste gemeenschap in de crypto-wereld.”</p>
<p>Hoewel er geen garantie is dat Twitter de Shiba-token onderdeel zal maken van zijn betalingssysteem, hoopt het Shiba-leger op zo’n stap. Dit komt doordat Yaccarino het officiële SHIB-account volgt en Twitter-accounts van veel andere cryptoprojecten. Als gevolg hiervan wordt gespeculeerd dat Yaccarino mogelijk interesse heeft in Shiba Inu en andere memecoins.</p>
<h2 id="h2-Wat20is20Shibarium20en20hoe20benvloedt20het20de20prijs20van20de20Shibatoken257554"><a name="Wat is Shibarium en hoe beïnvloedt het de prijs van de Shiba-token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Shibarium en hoe beïnvloedt het de prijs van de Shiba-token?</h2><p>We hebben besproken hoe de Shibarium-testnet resulteerde in een record van 10 miljoen transactievolume mijlpaal voor Shiba Inu. Laten we kort bespreken hoe Shibarium werkt en hoe het kan bijdragen aan de groei van het Shiba Inu-ecosysteem.</p>
<p>Primair is Shibarium een Layer-2 protocol dat bestaat op de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> blockchain en zorgt voor het Shiba Inu-ecosysteem. Op dezelfde manier, de <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu crypto</a> project, met Shiba-token als zijn inheemse cryptocurrency, werkt ook op hetzelfde netwerk.</p>
<p>De lancering van Shibarium zal veel nieuwe ontwikkelingen met zich meebrengen voor het Shiba Inu-project. Zo zal het een gedecentraliseerde uitwisseling genaamd ShibaSwap hebben, evenals een metaverse- en gamingplatform.</p>
<p>Daarnaast zal Shibarium hebben <a href="https://www.gate.io/price/bone-shibaswap-bone" target="_blank">BONE</a> als zijn governance-token. Naast BONE zal Shibarium andere cryptocurrencies hebben, waaronder <a href="https://www.gate.io/trade/LEASH_USDT" target="_blank">LEASH</a>, TREAT en SHI. Het is essentieel om op te merken dat validators beloond zullen worden in BONE in plaats van Shiba-tokens.</p>
<p>Shibarium brengt verschillende voordelen met zich mee voor het Shiba Inu ecosysteem, zoals schaalbaarheid, snellere transacties en lage transactiekosten. Dit komt doordat de transactie off-chain wordt verwerkt, wat congestie vermindert. Mensen kunnen ook gedecentraliseerde toepassingen (Dapps) ontwikkelen op de Shibarium blockchain.</p>
<p>Lees ook: <a href="https://www.gate.io/how-to-buy/shiba-inu-shib &quot;How to Buy Shiba Inu (SHIB" rel="nofollow noopener noreferrer" target="_blank">Hoe Shiba Inu (SHIB) kopen - HODL of Crypto Handelen</a></p>
<h2 id="h2-Shiba20Token20prijsprestaties598572"><a name="Shiba Token prijsprestaties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Shiba Token prijsprestaties</h2><p>De Shiba-token heeft niet naar verwachting gepresteerd in de afgelopen maand. Over het algemeen, <a href="https://www.gate.io/price/shiba-inu-shib" target="_blank">Shiba token prijs</a> daalde met 15% binnen mei, wat resulteerde in verliezen onder handelaren. De lancering van nieuwe memecoins zoals <a href="https://www.gate.io/price-prediction/pepe-pepe" target="_blank">PEPE</a> kan hebben bijgedragen aan de slechte prijsontwikkeling van de Shiba-token gedurende de maand.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1686556353Shibarium 2.png" alt=""><br>Shiba koersbewegingen voor mei - Coingecko</p>
<p>De bovenstaande grafiek geeft een duidelijk beeld van de prijsprestaties van Shiba-tokens in mei. Zoals u kunt zien, begon de prijs op 6 mei te dalen tot het einde van de maand. Natuurlijk waren er in die periode enkele terugtrekkingen.</p>
<p>Ondanks de slechte prijsprestaties van de Shiba-token, heeft het op andere vlakken gewonnen. Volgens Glassnode was er een <a href="https://studio.glassnode.com/metrics?a=SHIB&amp;category=&amp;m=addresses.NewNonZeroCount&amp;s=1684021022&amp;u=1684886400&amp;zoom=" rel="nofollow noopener noreferrer" target="_blank">toename van het aantal nieuwe portefeuilles</a> gedurende de maand. De verwachte lancering van nieuwe producten op het netwerk zou hebben kunnen resulteren in een stijging van het aantal portemonneeadressen.</p>
<p>De statistieken tonen aan dat de prijs van de token in de verschillende tijdsbestekken is gedaald, zoals aangegeven in de onderstaande tabel. Helaas schetst dat een zeer bearish scenario.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1686556417Shibarium 3.png" alt=""><br>Negatieve prijswijzigingen van Shiba Inu - CoinGecko</p>
<p>Zoals waargenomen, is de waarde ervan in de afgelopen 30 dagen met 15,2% gedaald, met 0,5% in de afgelopen 7 dagen en met 0,7% in de afgelopen 24 uur. Nog erger is dat de waarde ook met 25,8% is gedaald in het afgelopen jaar. De markt wacht echter af om te zien wat het effect zal zijn van recente tokenverbrandingen en de introductie van nieuwe producten op de prijs tijdens de tweede helft van het jaar.</p>
<h2 id="h2-Conclusie260740"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De Shiba-token registreerde een transactievolume van 10 miljoen in de derde week van mei. Ondanks die positieve ontwikkeling bleef de token de hele maand in het rood. Ook werden er gedurende die periode 3 miljoen tokens verbrand, iets dat in de toekomst mogelijk invloed kan hebben op de prijs.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>