V2F0IGlzIEFyd2VhdmUgKEFSKT8gV2Vsa29tIGJpaiBwZXJtYW5lbnRlIGJsb2NrY2hhaW5vcHNsYWcgKDIwMjUp

2022-04-07, 07:21

<p><img src="https://gimg2.gateimg.com/image/ar202506181202130398437351.png" alt="">
</p><p><a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">Arweave</a>(AR) biedt permanente blockchain-opslag via het innovatieve eenmalige betalingsmodel en het unieke toegangsbewijs-consensusmechanisme. In 2025 heeft <a href="/price/arweave-ar" target="_blank" class="blog_inner_link">Arweave</a> de SPoRA-protocol geüpgraded, wat 5.000 transacties per seconde mogelijk maakte via de technologie “Blockshadows”. De lancering van het AO-project op 8 februari stelde proxy-applicaties in staat om parallelle berekeningen uit te voeren, waardoor AR-houders AO-tokens konden accumuleren. Strategische partnerschappen met Meta, Solana, Polkadot, Internet Archive en ClimateTrace hebben de positie in het ecosysteem versterkt. De AR-token is gestegen van minder dan $10 naar meer dan $40, waarmee het zich heeft gevestigd. <a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">Arweave</a> Als <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> De status van definitieve opslagoplossingen.</p>
<h2 id="h2-Laatste20ontwikkelingen20in202025875994"><a name="Laatste ontwikkelingen in 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Laatste ontwikkelingen in 2025</h2><p>Sinds de oprichting heeft Arweave aanzienlijke vooruitgang geboekt in zijn technische framework en marktpositie. Het platform maakt nu gebruik van het SPoRA-protocol na de upgrade van RandomX, wat de transactiecapaciteit aanzienlijk verhoogt tot ongeveer 5.000 transacties per seconde dankzij de innovatieve ‘Blockshadows’-technologie.</p>
<p>Een belangrijke ontwikkeling in 2025 is de lancering van de mainnet van het AO-project op 8 februari. AO is gebouwd bovenop Arweave en biedt een parallelle rekenlaag voor proxy-applicaties. AR-tokenhouders hoeven alleen AR in hun wallets te houden om AO-tokens te accumuleren.</p>
<p>Opmerkelijke samenwerkingen hebben de positie van Arweave in het Blockchain-ecosysteem versterkt:</p>
<ul>
<li>Partnerschap met Meta om permanente opslag voor digitale verzamelobjecten op Instagram te bieden</li><li>Met <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> Geïntegreerd voor het opslaan van grootboeken</li><li>Aangenomen door Internet Archive voor webarchivering</li><li>Samenwerking met ClimateTrace om gegevens over broeikasgasemissies op te slaan</li></ul>
<p>AR-tokens hebben uitzonderlijk goed gepresteerd, en zijn gestegen van onder de $10 naar meer dan $40 na de aankondiging van het AO-project. Deze groeicurve heeft Arweave een belangrijke speler gemaakt in de gedecentraliseerde opslagruimte, als een permanente opslagoplossing voor Web3.</p>
<h2 id="h2-Wat20is20Arweave20AR809165"><a name="Wat is Arweave (AR)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Arweave (AR)?</h2><p>Arweave is een gedecentraliseerd gegevensopslag-encryptieproject dat gericht is op het creëren van een oneindig opslagplatform voor gebruikers, waarmee ze alle inhoud die ze willen kunnen opslaan binnen een gedecentraliseerde infrastructuur. Beschouw het als een op Web 3 gebaseerd Dropbox of Google Photos, maar niet beheerd door een enkele entiteit. Arweave bereikt dit door de netwerkinfrastructuur van “permaweb”.</p>
<h2 id="h2-Welke20uitdagingen20heeft20de20Permaweb823820"><a name="Welke uitdagingen heeft de Permaweb?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke uitdagingen heeft de Permaweb?</h2><p>Net als de problemen waarmee het World Wide Web sinds de oudheid te maken heeft gehad, heeft de Permaweb ook te maken met criminele activiteiten en illegale inhoud. Echter, in tegenstelling tot het traditionele internet, zijn de Permaweb-tools voor democratische beoordeling van de inhoud geïntegreerd in de kern van het protocol. Daarnaast werkt het kernontwikkelingsteam van Arweave nauw samen met de Internet Watch Foundation om Arweave-miners de nodige tools en technologieën te bieden om misbruik en illegale inhoud op de Permaweb te elimineren.</p>
<h2 id="h2-ARtoken524598"><a name="AR-token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AR-token</h2><p>Gebruikers kunnen AR-tokens gebruiken voor governance, goederen verkopen om financiering voor het protocol te bieden en transactiekosten betalen voor opslag van permaweb-inhoud. Momenteel zijn er 50 miljoen AR-tokens in omloop, terwijl de maximale voorraad van het project 66 miljoen AR is.</p>
<h2 id="h2-Arweave19808"><a name="Arweave" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Arweave</h2><p>is een cryptocurrency-project dat zich richt op het hosten van gegevens in een gedecentraliseerd wereldwijd netwerk. Het klinkt eenvoudig, maar het is eigenlijk een van de meest ambitieuze projecten in de volledige <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptocurrency markt</a> ecosysteem en een van de meest gewaardeerde activa van 2021. Op een extreem belangrijk aspect van digitale decentralisatie staat Arweave aan de voorhoede, maar in werkelijkheid heeft het bijna geen aandacht gekregen die het verdient.</p>
<p>In het licht hiervan legt dit artikel uit wat Arweave is, details over de AR-token en waarom dit project zo belangrijk is voor de toekomst van Web 3.</p>
<h2 id="h2-Wat20is20Arweave20AR629421"><a name="Wat is Arweave (AR)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Arweave (AR)?</h2><p>Zoals eerder vermeld, is Arweave een gedecentraliseerd gegevensopslagversleutelingsproject dat tot doel heeft een oneindig opslagplatform voor gebruikers te creëren, waarmee ze elke inhoud die ze willen kunnen opslaan binnen een gedecentraliseerde infrastructuur. Tot op zekere hoogte wordt het vaak aangeduid als een collectief eigendom harde schijf die nooit kan worden verwijderd. Daarom zal de gegevens die je kiest om op te slaan permanent bestaan op de Arweave Blockchain, tenzij je het verwijdert.</p>
<p>Arweave opereert via het permaweb. Het permaweb is de naam van het gegevensopslagprotocol voor een gedecentraliseerd Blockchain-platform, bekend als het “permanente web.” Binnen het permaweb zullen er verschillende applicaties beschikbaar zijn voor gebruikers om op aanvraag te gebruiken. Denk aan Dropbox, Google Foto’s, iCloud, alles wat je maar kunt bedenken - deze verschillende opslag- en personalisatieopties bevinden zich allemaal binnen een volledig gedecentraliseerde Blockchain.</p>
<p>Permaweb wordt gerealiseerd door middel van blockweave-technologie, wat de blockchain naam is van Arweave. Het werkingsprincipe is zeer vergelijkbaar met dat van de blockchain van Bitcoin, maar Arweave gebruikt proof of access (PoA) technologie in plaats van proof of work. Bij proof of access, in tegenstelling tot traditionele blockchainmodellen, wisselen miners energiebronnen uit via hun hardware en kunnen zij ook waardevolle gegevens van het World Wide Web direct invoeren en repliceren in ruil voor AR-tokens als compensatie.</p>
<p>Dit mechanisme compenseert miners (die in dit geval schrijvers kunnen worden genoemd) door basisinformatie aan het permaweb te verstrekken — langzaam maar zeker ontwikkelt het zich tot een waardevolle bron in de digitale wereld. In ruil daarvoor ontvangen ze de inheemse cryptocurrency van het project om de relevante informatie op te slaan.</p>
<p>Het is even belangrijk op te merken dat Arweave voor juni 2018 bekend stond als Archain, en het later onder één naam werd verenigd vanwege de aard van de blockweave-technologie zelf, die dezelfde naam gedurende het projectontwikkelingsproces behield. In juni 2018 besloten de ontwikkelaars uiteindelijk de naam te wijzigen naar een naam die dichter bij het oorspronkelijke blockweave-model staat—zo is Arweave geboren.</p>
<h2 id="h2-Welke20uitdagingen20staat20de20Permaweb20voor603001"><a name="Welke uitdagingen staat de Permaweb voor?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke uitdagingen staat de Permaweb voor?</h2><p>Net als de traditionele Wereldwijde Web, kunnen gedecentraliseerde internetopslagplatforms ook verschillende problemen tegenkomen, zoals criminele inhoud, frauduleuze informatie en meer. Deze problemen bestaan al sinds de geboorte van Web 1 in de vroege jaren ‘90 en lijken voorlopig niet te verdwijnen. Maar in tegenstelling tot het traditionele internet zijn tools zoals permaweb geïntegreerd in de kern van het protocol - waardoor de controle over het Web wordt teruggegeven aan de gebruikers en enthousiastelingen op een manier die Web 1 en Web 2 nooit hebben kunnen bereiken.</p>
<p>Wanneer iemand gegevens naar de Arweave permaweb stuurt om op te slaan, kan het gegevensopslagprotocol ervoor kiezen om de relevante gegevens te vervangen. Vervolgens kunnen netwerkmineraars transacties filteren op basis van hun keuzes, gebruikmakend van software-scanners om verborgen informatie te verifiëren, enz., om te controleren of het illegale inhoud bevat. Als er criminele inhoud wordt gevonden, ontvangen miners AR-tokenbeloningen.</p>
<p>Bovendien werkt het kernontwikkelingsteam van Arweave nauw samen met de Internet Watch Foundation om Arweave-miners te voorzien van de nodige tools en technologieën om de permaweb vrij te houden van misbruik en illegale inhoud. Bovendien, als gegevensopslagproviders ontdekken dat inhoud in strijd is met het kader van het project, kunnen zij ervoor kiezen om geen inhoud op het netwerk op te slaan zonder een reden te geven. Als gegevensverzenders opnieuw willen verifiëren, kunnen zij proberen de inhoud opnieuw te verzenden om te zien of deze de tweede verificatie doorstaat.</p>
<h2 id="h2-Investering20in20Arweave786682"><a name="Investering in Arweave" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Investering in Arweave</h2><p>Het whitepaper van Arweave stelt dat Arweave zich inspant om een collectieve capaciteit te waarborgen die individuen in staat stelt om gegevens van begin tot eind op te slaan en te delen met toekomstige generaties. Vergeleken met de doelen van andere cryptocurrency-projecten is het doel van Arweave vrij uniek, en sommige instellingen lijken dit opgemerkt te hebben.</p>
<p>In maart 2020 kondigde Arweave aan dat het 8,3 miljoen dollar aan financiering had opgehaald bij Andreessen Horowitz, Union Square Ventures en zelfs Coinbase Ventures—dit is de tweede ronde van investeringen waarbij Andreessen en Union Square miljoenen injecteerden in 2019. Naast de vermelding van investeerders en de Internet Observation Foundation, heeft Arweave ook partnerschappen opgezet met Techstars, USV, 1kx en MultiCoin Capital.</p>
<h2 id="h2-ARtoken308555"><a name="AR-token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AR-token</h2><p>Momenteel zijn er 50 miljoen AR-tokens beschikbaar op de markt, met een aanbodlimiet van 66 miljoen. Arweave-ontwikkelaars stellen dat het netwerk volledig gedecentraliseerd is - dit betekent dat ze geen autoriteit meer hebben over token governance of distributie.</p>
<p>De native token van het netwerk is een manier om het protocol te financieren door geleidelijk zijn goederen te verkopen, met de winst die wordt gebruikt om Arweave’s durfkapitaal te verbeteren, waardoor de waarde van de token toeneemt en er hoop is op het creëren van een waardevermeerderingscyclus.</p>
<p>De informatie op de officiële Arweave-website toont aan dat de distributie van de protocoltokens als volgt is:</p>
<ul>
<li>19,5% voor particuliere verkopen 2,9%</li><li>13% toegewezen aan projectadviseurs</li><li>Geef het kernteam (5-jarig termijn, daarna elk jaar 20% van de fondsen vrijgeven)</li><li>19,1% voor ecosysteemontwikkeling</li><li>26,5% toegewezen voor toekomstige projecten - ook onderhevig aan dezelfde voorwaarden als de financiering van het kernteam.</li></ul>
<p>De beveiliging van Arweave is ook zeer hoog. Het eerdere miningprotocol, RandomX, heeft consistent succesvolle audits door vier grote bedrijven op het gebied van cyberbeveiliging doorstaan: Trail of Bits, Kudelski Security, Quarks Lab en X41 D-Sec. Sinds februari 2021 heeft Arweave zijn mininginstructies geüpgraded naar het SPoRA-protocol, dat ook meerdere beoordelingen door de NCC Group heeft ondergaan en vaak wordt geprezen door langdurige supporters van het project.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van (een deel van) de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie kunt u de Gebruikersovereenkomst lezen via <a href="https://www.gate.com/legal/user-agreement" data-index="7">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>