Z2F0ZUxpdmUgQU1BIFJlY2FwLUxpZ2h0TGluaw==

2024-05-22, 04:22

<p><img src="https://gimg2.gateimg.com/image/article/1716351710space_Blog.jpg" alt=""></p>
<h2 id="h2-V120Wat20is20LightLink20Beschrijf20het20in20eenvoudige20bewoordingen181133"><a name="V1: Wat is LightLink? Beschrijf het in eenvoudige bewoordingen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Wat is LightLink? Beschrijf het in eenvoudige bewoordingen.</h2><p>LightLink is een <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Layer 2 blockchain die dApps en bedrijven in staat stelt om gebruikers directe, gasloze transacties aan te bieden.</p>
<p>LightLink is gebouwd op eigen technologie waarmee het meer dan 10 duizend transacties per seconde kan bereiken, met minder dan 1 cent aan gasvergoedingen.</p>
<p>We streven naar de massale adoptie van miljoenen zakelijke gebruikers. Ondernemingen kunnen hun Web3-services lanceren op LightLink en deze gratis en zonder technische moeilijkheden van gasvergoedingsmechanismen aan hun gebruikers aanbieden.</p>
<h2 id="h2-Q220Hoe20werken20de20gasloze20transacties20van20LightLink150762"><a name="Q2: Hoe werken de gasloze transacties van LightLink?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Hoe werken de gasloze transacties van LightLink?</h2><p>Gasloze transacties worden bereikt met onze Enterprise Mode. Bedrijven en projecten zetten hun contracten op de whitelist via de Enterprise Mode en kopen gasquota met fiat of de LL-token voor hun gebruikers om uit te geven.</p>
<p>Vervolgens, wanneer gebruikers interageren met gecontracteerde whitelist, gebruikt het netwerk gasquota in plaats van ETH uit de portefeuilles van gebruikers. Op deze manier bereiken we gasloze transacties: gebruikers kunnen USDT voor LL ruilen op DEX, NFT’s claimen of maken, Web3-games spelen en meer zonder ETH in hun portefeuilles te hebben.</p>
<p>Enterprise-modus vereenvoudigt de onboarding van gebruikers van Web2, doordat een combinatie van een bewaarportemonnee en gasloze transacties de blockchain volledig kan verbergen voor gebruikers, zodat ze kunnen profiteren van Web3-technologie zonder technische complexiteit.</p>
<p>Voor ondernemingen en projecten biedt de Enterprise-modus hen de mogelijkheid om hun gasvergoedingen te voorspellen op basis van de activiteit van hun gebruikers en de vergoedingen in fiat-equivalent vast te stellen.</p>
<h2 id="h2-Q320Hoe20verschilt20LightLink20van20andere20L2s509764"><a name="Q3: Hoe verschilt LightLink van andere L2’s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Hoe verschilt LightLink van andere L2’s?</h2><p>LightLink maakt gebruik van een Optimium architectuurontwerp met eigen technologie. Reguliere L2’s gebaseerd op Optimistic Rollups slaan transacties op in L1, terwijl LightLink ze op een aparte Data Beschikbaarheidslaag opslaat en alleen L2 blokkoppen naar L1 verzendt.</p>
<p>DA-opslagkosten zijn 10-100 keer goedkoper dan op L1, dus LightLink slaagt erin transacties op te slaan voor een fractie van de kosten. Een aparte DA stelt ons in staat om gegevens sneller te uploaden en een maximum van 10.000 transacties per seconde te bereiken om miljoenen gebruikers aan boord te krijgen. Bovendien hebben L2-headers die LightLink op L1 plaatst een vaste grootte, dus de opslagkosten voor L1 zijn niet afhankelijk van netwerkactiviteit.</p>
<p>Met deze functies kunnen we te allen tijde &lt;$0.01 transactiekosten aanbieden, ongeacht hoe hoog de activiteit is op het LightLink-netwerk.</p>
<h2 id="h2-Q420Hoe20zou20u20de20tokenomics20van20LightLink20beschrijven398952"><a name="Q4: Hoe zou u de tokenomics van LightLink beschrijven?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Hoe zou u de tokenomics van LightLink beschrijven?</h2><p>We hebben tokenomics ontworpen om gemeenschapsgericht te zijn. In december hebben we de toewijzing van particuliere investeerders verlaagd van 20% naar 14% en de teamtoewijzing van 17% naar 14% om de toewijzing van community-airdrops te verhogen van 2,5% naar 6%.</p>
<p>Vervolgens hebben we de vergrendelingen verlicht voor Airdrop-deelnemers: fase 1-deelnemers ontvingen 20% van hun toewijzing bij TGE en 80% werd vastgezet voor de periode die ze zelf kozen. We zijn verheugd te melden dat 65% hun $LL-tokens voor een jaar hebben vastgezet!</p>
<p>Nu is slechts 8% van $LL in omloop. Het team heeft zijn tokens 15 maanden vergrendeld, terwijl VCs een periode van 12 maanden hebben, gevolgd door een periode van 18 maanden.</p>
<h2 id="h2-Q520Kunt20u20ons20meer20vertellen20over20de20aankomende20verkoop20van20node20NFTs465634"><a name="Q5: Kunt u ons meer vertellen over de aankomende verkoop van node NFT’s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Kunt u ons meer vertellen over de aankomende verkoop van node NFT’s?</h2><p>Node NFT’s zijn NFT’s die zijn uitgegeven door LightLink. Om een validator node te draaien, moeten gebruikers node NFT’s in hun portefeuilles hebben - het is eenvoudig. Node NFT’s worden verkocht voor LL-tokens, wat de LL-functionaliteit moet vergroten. Bovendien zullen de nodes in verschillende zeldzaamheden komen met extra voordelen op basis daarvan.</p>
<p>Nodes zullen ons helpen om staken en delegeren te vereenvoudigen en tegelijkertijd het aantal validators te beperken, wat cruciaal is voor L2s.<br>We voeren ook een lock-and-earn-campagne uit met Gate.io, en we werken aan meer stakingcampagnes terwijl we spreken.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>GateLive</strong>, Team van Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening 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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>