Qml0Y29pbiAyMDI1IENvbmZlcmVudGllOiBXYW5uZWVyIGRlIEFtZXJpa2FhbnNlIHZpY2UtcHJlc2lkZW50IGJvbmRnZW5vdGVuIHdvcmR0IG1ldCBlbmNyeXB0aWUtZ2Vla3M=

2025-06-03, 07:45

<p><img src="https://gimg2.gateimg.com/image/btc202506031542563391989069.png" alt="">
</p><p>Binnen het Las Vegas Convention Center, een groot scherm achter <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> CEO Paolo Ardoino toonde het beeld van Goku uit “Dragon Ball,” en 45.000 toeschouwers juichten oorverdovend. “Bitcoin is mijn Goku,” verklaarde de Italiaanse techneut, “en <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> is een betrouwbare metgezel op de reis.</p>
<p>Van 27 tot 29 mei 2025, de wereld <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> de gemeenschap zal zich richten op de Venetiaanse Expo in Las Vegas. De <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> 2025-conferentie zal 30.000 deelnemers, vertegenwoordigers van 5.000 bedrijven en meer dan 400 sprekers bijeenbrengen, wat het meest politiek beladen en strategisch belangrijke evenement in de geschiedenis van Bitcoin-conferenties markeert.</p>
<p>De Amerikaanse vice-president deelt het podium met encryptie-anarchisten, voetbalclubs werken samen met investeringsbanken aan investeringsstrategieën, en toezichthouders steken een olijftak uit naar ontwikkelaars. Deze ogenschijnlijk tegenstrijdige combinaties schetsen de contouren van een nieuwe wereldwijde financiële orde.</p>
<h2 id="h2-Machtsoverdrachten20het20nieuwe20politieke20verhaal20van20Code20amp20Country139813"><a name="Machtsoverdrachten, het nieuwe politieke verhaal van Code &amp; Country" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Machtsoverdrachten, het nieuwe politieke verhaal van Code &amp; Country</h2><p>Toen David Sacks, de directeur van encryptie- en AI-zaken van het Witte Huis, en Bo Hines, de uitvoerend directeur van de Raad van de President, de locatie van de Bitcoin-conferentie binnenliepen, had de politieke status van Bitcoin een significante transformatie ondergaan.</p>
<p>Het gloednieuwe hoogtepunt van de conferentie van 2025, het “Code &amp; Country” project, markeert de eerste keer dat de Bitcoin-wereld zijn deuren opent voor beleidsmakers. Dit initiatief, gelanceerd door de Bitcoin-conferentie in samenwerking met de America250 Commissie, brengt Amerikaanse kabinetsleden, leden van het Congres en leiders uit de Bitcoin-industrie op hetzelfde podium.</p>
<p>“Bitcoin ontvangt ongekende erkenning van de hoogste niveaus van de overheid,” benadrukte David Bailey, medeoprichter en CEO van BTC Inc., in zijn openingsspeech. “De oprichting van een strategische Bitcoin-reserve door president Trump is een van de vele initiatieven die gericht zijn op het bevorderen van innovatie in de Verenigde Staten.”</p>
<p>Deze hooggeprofileerde besloten bijeenkomst, beperkt tot houders van een industrie-pas en walvis-pas, besprak hoe openbaar beleid de innovatie van Bitcoin kan versnellen, wat de ongekende belangrijkheid weerspiegelt die encryptie heeft verworven in de machtsstructuur van de Verenigde Staten.</p>
<h2 id="h2-Overheidsfunctionarissen20steunen20Bitcoin20als20een20nationale20strategische20activa306583"><a name="Overheidsfunctionarissen steunen Bitcoin als een nationale strategische activa." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Overheidsfunctionarissen steunen Bitcoin als een nationale strategische activa.</h2><p>De verschijning van de Amerikaanse vicepresident JD Vance bracht de conferentie tot een climax. Terwijl hij binnenkwam via een pad dat door zijn beveiligingsteam was vrijgemaakt, verklaarde Vance: “Cryptocurrency is een middel om je te beschermen tegen het falen van het beleid van Washington,” wat een drie minuten durende staande ovatie van het publiek uitlokte.</p>
<p>Vance schetst een duidelijke strategische positionering van de Amerikaanse machtsstructuur met betrekking tot Bitcoin: het bevorderen van de “GENIUS Act” om de juridische status van stablecoins vast te stellen, het creëren van een nationale Bitcoin-strategische reserve, en het erkennen van de burgerrechten van 50 miljoen Amerikaanse Bitcoin-houders.</p>
<p>“Digitale activa zijn een symbool en drijvende kracht van persoonlijke vrijheid voor Amerikanen,” benadrukte Vance in zijn toespraak, terwijl hij steun aankondigde voor de GENIUS Act, die heeft als doel een duidelijke regelgevende structuur voor stablecoins te bieden.</p>
<p>Senator Cynthia Lummis bracht meer significant nieuws: “President Trump steunt het Bitcoin-wetsvoorstel,” dat de Verenigde Staten autoriseert om binnen vijf jaar 1 miljoen bitcoins aan te schaffen om een nationale strategische reserve op te bouwen.</p>
<p>Aan de andere kant van de Atlantische Oceaan heeft Nigel Farage, leider van de Reform Partij in het VK, via video aangekondigd: “Als ik tot Premier word gekozen, zal ik Bitcoin-reserves oprichten bij de Bank of England en de vermogenswinstbelasting op encryptie-activa verlagen tot 10%.”</p>
<h2 id="h2-De20verklaring20van20de20encryptierevolutie20van20de20Trumpfamilie900629"><a name="De verklaring van de encryptierevolutie van de Trump-familie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De verklaring van de encryptierevolutie van de Trump-familie</h2><p>Leden van de Trump-familie veroorzaakten ook opschudding met hun toespraken op de conferentie. Trump’s twee zonen, Eric en Donald Trump Jr., spraken zich uit en onthulden dat ze naar de encryptiesector zijn overgestapt nadat ze door traditionele banken geen service kregen.</p>
<p>“Het traditionele financiële systeem is een ‘Ponzi-schema’,” bekritiseerde Little Donald botweg, “We hopen grote banken ‘uitgestorven’ te zien door hun langdurige wangedrag.”</p>
<p>De familie Trump bezit momenteel een belang van 60% in het $2,2 miljard waard encryptiebedrijf World Liberty Financial en is van plan $2,5 miljard in Bitcoin te investeren via Trump Media &amp; Technology Group.</p>
<p>Rumble CEO Chris Pavlovski heeft een plan aangekondigd om een encryptietreasury van $2,5 miljard op te richten in samenwerking met de oudste zoon van Trump, waarbij Bitcoin wordt gepositioneerd als een “publiek goed”, wat de opkomst van een nieuw bedrijfsmodel aangeeft.</p>
<h2 id="h2-Bedrijfsmatige20Bitcoinisatie20Saylors202120Vermogensprincipes769603"><a name="Bedrijfsmatige Bitcoinisatie, Saylor’s 21 Vermogensprincipes" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bedrijfsmatige Bitcoinisatie, Saylor’s 21 Vermogensprincipes</h2><p>De toespraak van Michael Saylor, de uitvoerende voorzitter van MicroStrategy, trok de dichtste menigte in de hoofdlocatie. Deze leider van een beursgenoteerd bedrijf dat meer dan 580.000 bitcoins bezit, publiceerde 21 regels voor vermogensopbouw op basis van bitcoin:</p>
<p>“Het configureren van een Bitcoin-balans heeft een kans van 90% op succes binnen 5 jaar,” stelde Saylor. Hij suggereerde dat bedrijven ondermaatse aandelen en vastgoed verkopen om in ruil daarvoor Bitcoin te verwerven, langetermijnkapitaal omzetten in Bitcoin, en familie-trusts gebruiken om intergenerationele Bitcoin-reserves op te bouwen.</p>
<p>Saylor voorspelt dat de marktwaarde van Bitcoin 1 biljoen USD zou kunnen bereiken, wat betekent dat Bitcoin een aanzienlijk aandeel van de wereldwijde rijkdom zal innemen.</p>
<p>De wapenwedloop voor Bitcoin in de zakenwereld bereikt een hoogtepunt: Paris Saint-Germain in Frankrijk heeft aangekondigd dat het zijn fiatreserves zal omzetten in Bitcoin, waarmee het de eerste topvoetbalclub wordt die Bitcoin houdt; de investeringsbank Cantor Fitzgerald op Wall Street heeft een goudgedekte Bitcoin-fonds gelanceerd; Blockstream CEO Adam Back voorspelt dat Bitcoin binnen 5 jaar $1 miljoen zal bereiken.</p>
<h2 id="h2-Bitcoin20is20geland20van20fastfoodrestaurants20tot20nationale20strategische20reserves983539"><a name="Bitcoin is geland, van fastfoodrestaurants tot nationale strategische reserves." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin is geland, van fastfoodrestaurants tot nationale strategische reserves.</h2><p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> CEO Paolo Ardoino heeft aangekondigd dat het bedrijf meer dan 100.000 bitcoins en 50 ton goudreserves heeft, wat de publiekelijk gehouden positie van MicroStrategy van $9,1 miljard overtreft.</p>
<p>“Twee dagen geleden, toen ik de PPT aan het voorbereiden was, waren de activa nog $150 miljard, maar toen ik deze morgen wakker werd, was het veranderd in $153 miljard,” zei Ardoino met een glimlach terwijl hij de slidegegevens bijwerkte. 95% van deze rijkdom is herbelegd in de bouw van het Bitcoin-netwerk, in plaats van als dividenden aan aandeelhouders te worden uitgekeerd.</p>
<p>Ardoino schetste een compleet ecosysteem voor een gede-intermediaire infrastructuur: een volledig peer-to-peer communicatietool Keet; een gedecentraliseerd AI-platform KUBA gebaseerd op lokale inferentie; een Bitcoin-miningbedrijf, en de WDK-ontwikkelkit die AI-agents in staat stelt om autonome Bitcoin-portefeuilles te hebben.</p>
<p>De praktijken van de fastfoodketen Steak ‘n Shake zijn meer tastbaar. COO Dan Edwards toonde de gegevens aan: “Bitcoin-betalingen zijn sneller dan creditcards, terwijl we ongeveer 50% besparen op transactiekosten.” Sinds de lancering van Bitcoin-betalingen op 16 mei, was de eerste dag goed voor 1⁄500van het wereldwijde BTC-transactieverkeer.</p>
<h2 id="h2-Technologische20doorbraken20van20schaalbaarheidsoplossingen20tot20duurzame20mijnbouw963142"><a name="Technologische doorbraken, van schaalbaarheidsoplossingen tot duurzame mijnbouw" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Technologische doorbraken, van schaalbaarheidsoplossingen tot duurzame mijnbouw</h2><p>Naarmate het aantal Bitcoin-gebruikers meer dan 420 miljoen overschrijdt, is netwerk schaalbaarheid een kernuitdaging geworden voor ontwikkelaars. Ark Labs introduceerde Arkade op de conferentie - een nieuwe uitvoeringslaag die gericht is op het verbeteren van de programmeerbaarheid van Bitcoin zonder het kernprotocol te veranderen, en heeft samengewerkt met <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> en Boltz.</p>
<p>De oplossingen die door ontwikkelaars worden getoond zijn opmerkelijk: BitVM 2.0 bereikt Turing-complete slimme contracten op Bitcoin; het RGB-protocol verbetert de privacy van off-chain transacties; en zero-knowledge bewijzen zijn geïntegreerd in het Lightning Network.</p>
<p>Als reactie op milieuproblemen verklaarde Ardoino: “Tether is een van de grootste Bitcoin-miners ter wereld, maar wij bevorderen duurzame mijnbouw.” Het gebruikt 96% hernieuwbare energie in zijn mijnfaciliteit in Uruguay en heeft een wereldwijde opzet van waterkrachtcentrales voor de energievoorziening.</p>
<p>De CEO van Marathon Digital Holdings, Fred Thiel, stelde een nieuw idee voor nationale strategische reserves voor: “De Verenigde Staten zouden rechtstreeks moeten deelnemen aan Bitcoin-mining, in plaats van alleen op marktinkopen te vertrouwen. Tenzij we daadwerkelijk Bitcoin gaan verkrijgen, is alles gewoon praat.”</p>
<h2 id="h2-Global20Awakening20de208020miljoen20missie20van20de20Human20Rights20Foundation338563"><a name="Global Awakening, de $80 miljoen missie van de Human Rights Foundation" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Global Awakening, de $80 miljoen missie van de Human Rights Foundation</h2><p>De humanitaire waarde van Bitcoin heeft substantiële financiële steun ontvangen. De Human Rights Foundation heeft een investering van $80 miljoen aangekondigd om de toepassing van Bitcoin in onderontwikkelde gebieden te ondersteunen, met als doel financiële empowerment te bieden aan economisch onstabiele gebieden door middel van open-source ontwikkeling en educatieve activiteiten.</p>
<p>Block Inc. heeft een strategie aangekondigd om het Lightning Network uit te breiden, met plannen om Bitcoin-betalingen diep te integreren in platforms zoals Cash App, waardoor goedkope en schaalbare transacties een realiteit worden in alledaagse financiële scenario’s.</p>
<p>De burgemeester van Panama-Stad, Mayer Mizrachi, brengt schokkend nieuws: “Overweegt voorkeurstoegang te bieden voor schepen die kanaaltoeslagen in Bitcoin betalen.” Deze scheepvaarthub die de twee oceanen verbindt, richt een gemeentelijke Bitcoin-reserve op volgens het Salvadoriaanse model.</p>
<p>Blueprint medeoprichter Bryan Johnson biedt investeringsinzichten vanuit een gezondheidsperspectief: “Als je goed slaapt, zul je meer geld verdienen met Bitcoin-investeringen,” waardoor fysiologische gezondheid wordt verbonden met de wetenschap van investeringsbesluitvorming.</p>
<p>Toen Tether CEO Paolo Ardoino zijn toespraak afsluitte met “De cloud is niet onze vriend, Bitcoin is,” stond het publiek op en applaudisseerde. Deze verklaring is niet alleen een kritiek op gecentraliseerde technologie, maar ook een viering van individuele soevereiniteit.</p>
<p>gehouden in de woestijn van Las Vegas <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De conferentie van 2025 weerspiegelt de ontwikkeling van de overdracht van financiële macht. Nationale strategische reserves beginnen Bitcoin te accumuleren, bedrijfsbalansen ondergaan een “Bitcoinisatie” transformatie, en gewone mensen gebruiken stablecoins om de devaluatie van hun lokale valuta te weerstaan.</p>
<p>De poort naar Bitcoin is geopend. Deze rookvrije revolutie herdefinieert het financiële machtslandschap van de 21e eeuw op een manier die dieper gaat dan welke oorlog dan ook.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, solicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Let op 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="6">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>