QXJiaXRydW0gQWlyZHJvcCBTcGlrZXMgSW50ZXJlc3QgaW4gRGVGaQ==

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR660383"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Er was in het eerste kwartaal van 2023 een stijging van 37,44% in de totale waarde opgesloten in DeFi.</p>
<p>De ARB airdrop heeft bijgedragen aan de toename van de totale waarde die vergrendeld is in DeFi-protocollen.</p>
<p>Decentralized finance (DeFi) omvat peer-to-peer transacties.</p>
<h2 id="h2-Introductie561469"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>In de loop der jaren is het aantal crypto-projecten dat airdrops uitgeeft aan hun trouwe gemeenschapsleden afgenomen. Sommige projecten hebben airdrops vervangen door ambassadeursprogramma’s om interesse te genereren voor hun cryptocurrencies. Arbitrum, de airdrop van de layer2 blockchain, heeft echter veel interesse gegenereerd. <a href="https://www.gate.io/blog_detail/2333/defi%E8%A7%A3%E8%AA%AC" target="_blank">in DeFi</a>. In dit artikel onderzoeken we het belang van de Arbitrum airdrop en hoe je de ARB-token kunt kopen op Gate.io.</p>
<h2 id="h2-Arbitrum20airdrop20genereert20interesse20in20DeFi87959"><a name="Arbitrum airdrop genereert interesse in DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Arbitrum airdrop genereert interesse in DeFi</h2><p>Volgens Pedro Herrera van DappRadar hebben sommige ontwikkelingen in zowel de cryptosector als TradFi bijgedragen aan de groei van gedecentraliseerde financiën (DeFi). We hebben de sluiting van verschillende banken gezien <a href="https://www.gate.io/de/blog_detail/2246" target="_blank">zoals Silvergate</a> en Signature Banks die veel mensen verleidden om DeFi-producten te zoeken.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2399" target="_blank">USDC Stablecoin Issuer Befriends Cross River Bank</a></p>
<p>Het aanscherpen van het regelgevend toezicht op gecentraliseerde beurzen zoals Binance heeft mensen ook doen beseffen dat gedecentraliseerde financiën voordelen hebben ten opzichte van hen.</p>
<p>Als gevolg daarvan vertelde Pedro Herrera, hoofd onderzoek bij DappRadar, een online winkel voor gedecentraliseerde applicaties, aan CoinDesk’s TV: ‘Als je ziet hoe deze gebruiksscenario’s voor DeFi beginnen te passen en je meer autonomie geven om in feite je eigen activa en investeringen te beheren, is dat het antwoord op waarom DeFi veel wordt gebruikt’.</p>
<p>De toename <a href="https://www.gate.io/blog_detail/196/decentralized-finance-defi-a-technology-that-challenges-centralization" target="_blank">in gedecentraliseerde financiële gebruiksscenario’s</a> en recente airdrops hebben geleid tot een stijging van de totale waarde die is vastgezet voor DeFi. Het recente rapport van DappRadar laat zien dat de totale waarde die is vastgezet voor DeFi met 37,44% is gestegen, van $60 miljard naar $83,3 miljard in het eerste kwartaal van 2023.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16825840191541682583712_.pic.jpg" alt=""><br>Toename van de totale waarde vergrendeld voor DeFi - DappRaddar</p>
<p>Zoals u kunt zien in het diagram, was er een stijging in de totale waarde vergrendeld in DeFi van $60 miljard naar $83 miljard in kwartaal 1, 2023.</p>
<p>De populariteit in <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> schaaloplossingen zoals Arbitrum, <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a>, en <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> heeft bijgedragen aan de toename van de totale waarde die wordt vergrendeld voor DeFi. Bovendien was er een hoog <a href="https://dappradar.com/blog/dappradar-dapp-industry-report-q1-2023-defi-nft-crypto#Chapter-2" rel="nofollow noopener noreferrer" target="_blank">handelsvolume van ARB</a> vanwege de ARB airdrop die de totale vergrendelde waarde heeft verhoogd.</p>
<h2 id="h2-Voordelen20van20de20ARB20airdrop457026"><a name="Voordelen van de ARB airdrop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Voordelen van de ARB airdrop</h2><p>De langverwachte airdrop van Arbitrum-token, ARB, heeft veel betekenis voor de blockchain. Dit komt doordat de ARB airdrop Arbitrum heeft veranderd in een gedecentraliseerde autonome organisatie (DAO) die de ARB-houders de kans geeft om deel te nemen aan het besluitvormingsproces van Arbitrum, aangezien zij ontwikkelingsinitiatieven voor de blockchain kunnen voorstellen of goedkeuren.</p>
<p>DAO’s zoals Arbitrum vergroten het gevoel van loyaliteit bij de gemeenschapsleden, omdat ze input geven aan de ontwikkelaars over hoe ze de producten van het netwerk kunnen verbeteren. Overigens trekt een crypto-project met kwaliteitsproducten veel gebruikers aan om mee te doen.</p>
<p>Het is belangrijk op te merken dat de <a href="https://www.gate.io/blog_detail/2449/arb-airdrop-from-super-airdrop-to-malicious-actors" target="_blank">De ARB airdrop is tot nu toe zeer goed verlopen</a>, behalve het hackincident waarbij een bedrag van de crypto airdrop ter waarde van meer dan $500.000 werd gestolen. In feite heeft de ARB airdrop tot doel 12,75% van zijn 10 miljard Abitrum-tokens te verspreiden. Een in aanmerking komende crypto-portemonnee kan minstens 625 ARB-tokens krijgen met een waarde tussen $400 en $1.250, afhankelijk van de <a href="https://www.gate.io/price/arbitrum-arb" target="_blank">huidige prijs</a> van de cryptocurrency.</p>
<p>Tegen het einde van maart had meer dan 61% van de in aanmerking komende portefeuilles de airdrop ontvangen. Echter, de overgebleven 240.000 crypto-portefeuilles moeten nog steeds hun aandeel opeisen. Deze claim moet binnen de komende zes maanden worden gedaan.</p>
<p>Er was veel opwinding over de airdrop, wat leidde tot veel deelnemers die hun aandeel binnen enkele uren na de lancering opeisten. Als gevolg van het grote aantal gebruikers op de blockchain werd de front-end in de vroege fase afgesloten vanwege dat hoge activiteitsniveau.</p>
<p>Aan het begin van de airdrop waarschuwde Offchain Labs, een bedrijf uit New York dat verantwoordelijk is voor de ARB airdrop, echter gebruikers voor copycat scams. Er werd gezegd: ‘Dit is de veiligste manier om te claimen en je kunt stemmen op je favoriete ecosysteem-delegaat.’</p>
<h2 id="h2-Wat20is20Arbitrum339520"><a name="Wat is Arbitrum?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Arbitrum?</h2><p>Abitrum is een schaaloplossing van laag 2 voor de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain. Hierdoor verbetert het de efficiëntie en mogelijkheden van EVM-toepassingen (dApps). Op dezelfde manier verhoogt het hun schaalbaarheid en snelheid tegen lage kosten.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16825841161551682583727_.pic.jpg" alt=""><br>Arbitrum blockchain - Theblock</p>
<p>Abitrum lost basically de tekortkomingen van de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain, zoals hoge kosten en lage snelheid. Dit wordt bereikt door gebruik te maken van rollups die transacties bundelen en ze als enkele batches indienen bij de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain. Daarom verwijdert het veel berekeningen en opslag op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain.</p>
<h2 id="h2-Wat20is20DeFi886288"><a name="Wat is DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is DeFi?</h2><p>We hebben al genoemd dat de ARB airdrop het totale volume dat vergrendeld is van DeFi heeft verhoogd. In eenvoudige bewoordingen is DeFi een systeem dat cryptocurrencies en de blockchain gebruikt om financiële transacties uit te voeren. Het bereikt dit door peer-to-peer levering van verschillende financiële diensten zoals leningen en hypotheken zonder te vertrouwen op tussenpersonen.</p>
<p>Daarom kunnen mensen overal waar ze internetdiensten hebben, handelen, lenen en uitlenen van digitale activa met behulp van geschikte softwareen die de transacties op de blockchain vastleggen. Mensen kunnen dit systeem gebruiken ongeacht hun geografische locaties.</p>
<h2 id="h2-Hoe20ARB20te20kopen20op20Gateio72203"><a name="Hoe ARB te kopen op Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe ARB te kopen op Gate.io</h2><p>U kunt <a href="https://www.gate.io/how-to-buy/arbitrum-arb" target="_blank">koop ARB-tokens bij Gate.io</a> op elk moment. De eerste stap is echter om een geverifieerd Gate.io-account te hebben. De volgende stap is om uw account te financieren met een van de belangrijkste cryptocurrencies zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, USDT of ETH.</p>
<p>Lees ook: <a href="https://www.gate.io/how-to-buy/arb-protocol-arb &quot;How to Buy ARB Protocol (ARB" rel="nofollow noopener noreferrer" target="_blank">Hoe ARB Protocol (ARB) kopen</a>”</p>
<p>U kunt deze belangrijke cryptocurrencies kopen met een bankoverschrijving of een creditcard. Zodra u een van de cryptocurrencies op uw account heeft, gaat u naar het gedeelte Spot Trade en selecteert u het geschikte paar zoals <a href="https://www.gate.io/trade/ARB_USDT" target="_blank">USDT/ARB</a> zoals hieronder aangegeven.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16825842011561682583740_.pic.jpg" alt=""></p>
<p>Zodra u op dat paar klikt, ARB/USDT, wordt er een nieuw venster geopend waarin u het bedrag van ARB dat u wilt kopen, kunt invoeren.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16825842141571682583754_.pic.jpg" alt=""></p>
<p>Zodra u het bedrag van de ARB-token dat u wilt kopen heeft ingevoerd, klikt u op ‘Koop ARB’. Daarna moet u de transactie bevestigen.</p>
<h2 id="h2-Conclusie666512"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De ARB-airdrop heeft de interesse in DeFi vergroot omdat veel mensen eraan hebben deelgenomen. In de periode richting de start van de Arbitrum airdrop was er een stijging van de totale waarde vergrendeld. Belangrijk is dat de airdrop de Arbitrum-blockchain heeft getransformeerd in een DAO.</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 beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>