Qml0Y29pbiBnYXNwcmlqemVuIGJlcmVpa2VuIHJlY29yZGhvb2d0ZSwgd2F0IHdpanN0IG9wIGVlbiBncm90ZSBzdHJ1Y3R1cmVsZSB2ZXJzY2h1aXZpbmcgaW4gZGUgbWFya3QgdmFuIDIwMjU=

2025-07-08, 09:54

<p><img src="https://gimg2.gateimg.com/image/bcct202507081752395612688795.jpg" alt="">
</p><p>In mei 2025 ontstond er een historisch paradox in de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> netwerk: de gemiddelde transactiefee steeg naar $2,40, waarmee een nieuw hoogtepunt voor het jaar werd bereikt, terwijl het dagelijkse aantal transacties met 35% daalde.</p>
<p>Dit fenomeen werpt de traditionele opvatting om—gewoonlijk komen stijgende kosten overeen met een toename van de netwerkactiviteit. De markstructuur ondergaat diepgaande veranderingen, waarbij de uitbreiding van institutionele deelnemers en de aanstaande aanbodschok sleutel-rijdfactoren worden.</p>
<h2 id="h2-De20Drieledige20Logica20van20Hoge20Kosten20Walvissen20Domineren20de20Markt644485"><a name="De Drieledige Logica van Hoge Kosten, Walvissen Domineren de Markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Drieledige Logica van Hoge Kosten, Walvissen Domineren de Markt</h2><p>Achter de stijging van de Bitcoin-transactiekosten ligt een fundamentele verschuiving in de structuur van marktdeelnemers. Instellingen en “whales” hebben de detailhandelaren vervangen als de belangrijkste kracht in netwerkactiviteit, en zij zijn bereid een premie te betalen om prioriteit te krijgen bij de bevestiging van transacties.</p>
<p>Van april tot mei 2025 tonen Santiment-gegevens een toevoeging van 76 “walvisadressen” (elk met ≥ 1000 BTC). Bedrijven zoals Metaplanet en Strategy hebben grootschalige aankopen van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> gedaan en deze in koude portemonnees gestort, waardoor de liquiditeit is bevroren.</p>
<p>De voorraad Bitcoin op de beurs is gelijktijdig gedaald van 25.000 munten in januari naar 21.000 munten in mei, een daling van 16%. De toenemende schaarste vormt een positieve feedbacklus met de instroom van institutionele beleggers.</p>
<p>Wanneer <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> Met een waarde van $105.000 beschouwen investeerders de gemiddelde kosten van $2,40 als de “koffiekosten” - een triviale prijs voor handelszekerheid.</p>
<h2 id="h2-Halving20Effect20en20Technologische20Evolutie20Kosten20zijn20de20Levenslijn20van20Miners131553"><a name="Halving Effect en Technologische Evolutie, Kosten zijn de Levenslijn van Miners" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Halving Effect en Technologische Evolutie, Kosten zijn de Levenslijn van Miners</h2><p>Na de <a href="/explore/bitcoin-halving-countdown" rel="nofollow noopener noreferrer" target="_blank">Bitcoin halvering</a> In 2024 zal de blockbeloning met nog eens 50% worden verminderd, en zal het aandeel van transactiekosten in het inkomen van miners stijgen tot 38%. Dit markeert een transformatie in het beveiligingsmodel van het Bitcoin-netwerk: transactiekosten zijn een nieuwe pijler geworden voor miners om hun operaties te onderhouden.</p>
<p>Netwerktechnologie-upgrades beïnvloeden ook de kostenstructuur. Het Lightning Network is goed voor 43% van de off-chain transacties, waardoor de druk op de mainnet wordt verlicht. Echter, transacties die op de mainnet blijven hebben hogere kosten gezien door de verscherpte concurrentie om blockruimte.</p>
<p>De populariteit van het Ordinals-protocol en BRC-20-tokens heeft de blokbelasting verhoogd, waarbij complexe operaties (zoals geldoverdrachten en derivateninvesteringen) goed zijn voor 62%. Hoewel technologische evolutie sommige kosten heeft verlaagd, heeft het ook de prijzen van kern-on-chain activiteiten opgedreven.</p>
<h2 id="h2-Horizontale20Vergelijking20Het20Pad20van20Kostenverlaging20van20Ethereum745671"><a name="Horizontale Vergelijking: Het Pad van Kostenverlaging van Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Horizontale Vergelijking: Het Pad van Kostenverlaging van Ethereum</h2><p>Wanneer de Bitcoin-kosten stijgen, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> toont de tegenovergestelde trend. In het eerste kwartaal van 2025 daalden de totale transactiekosten van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> met bijna 60%, wat het laagste niveau sinds 2020 bereikte.</p>
<p>Dit contrast is te wijten aan de succesvolle gelaagde strategie van Ethereum. De Dencun-upgrade heeft de transactiekosten van Layer-2 met 95% verlaagd, waarbij de reguliere overdrachtstarieven zijn gedaald van $86 naar $0,39.</p>
<p>Base verwerkt meer dan 80 transacties per seconde, wat de Layer-2 netwerken leidt. Platforms zoals Arbitrum en zkSync hebben transactiekosten die zelfs lager zijn dan $0,01.</p>
<p>De hoge kosten van Bitcoin benadrukken de eigenschap van “digitaal goud”, terwijl Ethereum de transformatie van een “betaalbare afrekenlaag” bereikt via L2, wat de verschillende ecologische positionering van de twee paden weerspiegelt.</p>
<h2 id="h2-De20Moeilijke20Balans20van20Mining20Kostendruk20Dwingt20tot20Transformatie563372"><a name="De Moeilijke Balans van Mining: Kostendruk Dwingt tot Transformatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Moeilijke Balans van Mining: Kostendruk Dwingt tot Transformatie</h2><p>Mijnwerkers hebben moeite om te overleven in de kloof tussen beloningshalvering en fluctuerende kosten. In de eerste helft van 2025 zullen de kosten voor het minen van één Bitcoin meer dan $70.000 bedragen, een stijging van meer dan 34% ten opzichte van het voorgaande jaar.</p>
<p>De eenheids hash rate-inkomsten (hashprijs) kelderden van 0,12 USD/TH naar 0,049 USD/TH. Winstcompressie veroorzaakte een golf van fusies en overnames in de industrie. Core Scientific kan worden overgenomen door het AI-cloudcomputingbedrijf CoreWeave, en na het uitlekken van het nieuws steeg de aandelenkoers met 18,5% op één dag.<br>Mijnbouwbedrijven breken door met een driedelige strategie:
</p><ul>
<li>Kapitaaloperatie: Marathon, Riot en CleanSpark hebben meer dan 3,7 miljard USD opgehaald</li><li>Technologie-upgrade: De efficiëntie van de nieuwe generatie ASIC verbeterde met 35%</li><li>Energietransitie: Waterkracht, windenergie en overtollige energie uit aardgas worden de belangrijkste energiebronnen.</li></ul>
<p>De meer kritieke doorbraak is de gecoördineerde indeling met AI-datacenters, waar mijnboerderijen tegelijkertijd mijn- en AI-reken taken uitvoeren, wat de hulpbronnenbenutting verbetert.</p>
<h2 id="h2-Toekomstperspectief20L220en20Regulering20die20het20Vergoedingssysteem20Hervormen152299"><a name="Toekomstperspectief, L2 en Regulering die het Vergoedingssysteem Hervormen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstperspectief, L2 en Regulering die het Vergoedingssysteem Hervormen</h2><p>Fluctuaties in Bitcoin-kosten signaleren diepere veranderingen. Forbes voorspelt dat het Bitcoin DeFi-ecosysteem tegen 2025 een vergrendelde waarde van meer dan $24 miljard zal bereiken via L2-netwerken. Bitcoin L2’s op basis van ZK-technologie (zoals Citrea of Alpen Labs) worden verwacht te worden geïmplementeerd, waardoor programmeerbaarheid wordt bereikt terwijl de capaciteit wordt uitgebreid.</p>
<p>De regulatorische omgeving verbetert in sync. Als Trump wordt gekozen, kan dit cryptocurrency-vriendelijke beleidsmaatregelen bevorderen, en het EU MiCA-kader is geïmplementeerd. De benoeming van de nieuwe SEC-voorzitter zal een einde maken aan “Operation Chokepoint 2.0,” waardoor de VS zijn status als centrum voor crypto-innovatie kan herwinnen.</p>
<p>De kostenstructuur zal een gelaagd kenmerk vertonen:</p>
<ul>
<li>Mainnet: Institutionele grootschalige afwikkeling, tolerant voor hoge kosten</li><li>L2: Dagelijks handelen en DeFi, het behouden van lage kosten</li><li>Cross-chain: Activa bruggen, gemiddelde kostenrange</li></ul>
<p>De bronnen van minerinkomsten zijn gediversifieerd, verschuivend van pure blokbeloningen naar een combinatie van “blokbeloningen + transactiekosten + AI-computingdiensten.” Crypto-analisten wijzen erop dat het tijdperk van hoge kosten voor Bitcoin de adoptie van gelaagde netwerken zal versnellen. Teams zoals Starknet ontwikkelen Bitcoin L2-oplossingen op basis van ZK-technologie, en de testnets van Citrea en Alpen Labs hebben al hun eerste transacties verwerkt.</p>
<p>De proportie van transactie fees in het inkomen van miners is gestegen tot 38%, wat duidt op een fundamentele transformatie van het netwerkbeveiligingsmodel. Wanneer de blockbeloning in 2140 op nul komt, zullen transactie fees de enige pijler worden voor het onderhouden van het Bitcoin-netwerk. Het huidige hoge fee dilemma is slechts een vroege repetitie voor de toekomstige norm.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blog Team</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 alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="5">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>