VGV0aGVyIGNvbW1pdHRlZXJ0IHppY2ggdG90ICQ1MDAgTSBhYW4gQml0Y29pbi1taW5pbmc=

2023-11-29, 02:14

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR386629"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> van plan om te investeren in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> mining, met als doel ten minste 1% van het mijnkwartaal te bereiken.</p>
<p>De stablecoin-uitgever (Tether) zal zijn miningfaciliteiten vestigen in Uruguay, Paraguay en El Salvador.</p>
<p>Toename van de mijndifficultieit en daling <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> zijn enkele belangrijke uitdagingen waar <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> mee te maken kan krijgen na de bitcoin-halvering.</p>
<h2 id="h2-Kennismaking410774"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>De nieuwe trend in de cryptoruimte heeft betrekking op diversificatie in productaanbod en innovatie in de bedrijfsstrategie. Crypto-bedrijven met diverse bedrijfsportefeuilles, hoogwaardige producten en concurrerende klantenservice presteren goed in de sector.</p>
<p>We hebben gezien dat bedrijven als PayPal, Grayscale en BlackRock cryptoproducten zoals derivaten introduceren. Ze benutten de voordelen van de blockchain en betreden nieuwe zakelijke gebieden.</p>
<p>Tether Labs, de leverancier van Tether USD (USDT), is een voorbeeld van een crypto-bedrijf dat zijn producten diversifieert. In deze post komen de geplande investering van Tether van $500 miljoen in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> mining aan bod. We zullen ook kijken naar enkele belangrijke uitdagingen waar het bedrijf mee te maken zal krijgen na het bitcoin halveringsevenement van 2024.</p>
<h2 id="h2-Tethers20Bitcoin20Mining20Strategie897161"><a name="Tether’s Bitcoin Mining Strategie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tether’s Bitcoin Mining Strategie</h2><p>Tether heeft een routekaart opgesteld om een van de toonaangevende bitcoin-mijnbouwbedrijven te worden, waarbij het van plan is meer dan $500 miljoen te investeren in de sector. In een interview met Bloomberg, <a href="https://www.bnnbloomberg.ca/biggest-stablecoin-issuer-tether-now-wants-to-become-a-major-bitcoin-miner-1.1999526" rel="nofollow noopener noreferrer" target="_blank">Paolo Ardoino, CEO van Tether, zei</a> dat het bedrijf in de komende 6 maanden zijn eigen mijnbouwinfrastructuur zal bouwen en enkele bestaande zal overnemen.</p>
<p>Ardoino zei: “We zijn toegewijd om deel uit te maken van het Bitcoin-miningecosysteem,” zei hij. “Als het gaat om uitbreidingen, het bouwen van nieuwe onderstations en nieuwe locaties, nemen we ze uiterst serieus.”</p>
<p>Het doel van Tether is om 1% van de bitcoin hash-snelheid te bereiken, te beginnen met 120 MW tegen het einde van het jaar en 450 MW in 2025. Het bedrijf heeft al $150 miljoen gereserveerd voor directe investeringen in de mijnbouwsector. Als Tether zijn BTC-mijnbouwdoel bereikt, wordt het een van de top 20 bitcoin-mijnwerkers ter wereld.</p>
<p>Eén van de infrastructuurstrategieën van Tether is het bouwen van mijnbouwfaciliteiten in grote verplaatsbare containers. Op deze manier is het heel gemakkelijk om de containers te verplaatsen naar landen waar goedkope elektriciteit is.</p>
<h2 id="h2-Gerelateerde20cryptoinvesteringen20van20Tether381691"><a name="Gerelateerde cryptoinvesteringen van Tether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gerelateerde cryptoinvesteringen van Tether</h2><p>Zoals we weten, is het huidige belangrijkste product van Tether de stablecoin USDT, gekoppeld aan een koers van 1,1 met de Amerikaanse dollar. Hierdoor genereert het een groot deel van zijn inkomsten uit zijn miljardenreserve-activa, waaronder Amerikaanse schatkistbiljetten. De reserves zijn belangrijk bij het beheer van USDT omdat ze ervoor zorgen dat de <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether prijs</a> is stabiel.</p>
<p>Het is belangrijk op te merken dat Tether al verschillende crypto-investeringen heeft gedaan op het gebied van bitcoin mining. Bijvoorbeeld, in juni investeerde het in Volcano Energy, een Salvadoraans BTC mining-avontuur.</p>
<p>In september verwierf het opnieuw een aandeel van 20% in Northern Data en verwierf het Nvidia’s op AI gerichte GPU’s in het proces. In een gerelateerde zet heeft Tether bekendgemaakt dat het bitcoin zal opnemen in zijn balans.</p>
<p>Naast haar directe investeringen in de bitcoin mining sector heeft Tether veel fondsen gereserveerd voor onderzoek en ontwikkeling. Alleen dit jaar heeft het bedrijf al meer dan $800 miljoen toegewezen voor onderzoek op het gebied van crypto-mining gerelateerde onderwerpen zoals energieverbruik.</p>
<p>De toetreding van Tether tot de bitcoin mining industrie geeft aan dat er enkele dominante spelers zullen zijn in de sector. Momenteel controleert Marathon Digital Holdings, een beursgenoteerd bedrijf, ongeveer 4% van de totale BTC mining hash rate. Het is echter mogelijk dat Tether in de toekomst meer dan 1% in handen zal hebben, aangezien het over veel financiële middelen beschikt.</p>
<p>Tether’s sterke intrede in de BTC-mijnbouwsector zal het positioneren als een van de grootste cryptoprojecten. Dit zal ook de concurrentie verhogen, wat andere bitcoin-mijnwerkers uit de markt kan duwen.</p>
<h2 id="h2-Locaties20voor20Tether20mining20operaties650067"><a name="Locaties voor Tether mining operaties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Locaties voor Tether mining operaties</h2><p>We hebben al gewezen op Tether’s strategisch plan om zijn mijncentra te verplaatsen naar gebieden waar elektriciteit goedkoop is. Desalniettemin, <a href="https://www.bloomberg.com/news/articles/2023-11-16/stablecoin-issuer-tether-usdt-btc-wants-to-become-a-major-bitcoin-miner" rel="nofollow noopener noreferrer" target="_blank">Ardoino vertelde Bloomberg</a> dat het zijn mijnbouwfaciliteiten zal vestigen, met capaciteiten tussen 40 en 70 megawatt in Uruguay, Paraguay en El Salvador. Een van de belangrijkste factoren voor het kiezen van dergelijke locaties is goedkope elektriciteit en crypto-vriendelijke regelgeving.</p>
<h2 id="h2-De20uitdagingen20van20mining20die20de20Bitcoin20Halving20van20202420zal20creren482557"><a name="De uitdagingen van mining die de Bitcoin Halving van 2024 zal creëren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De uitdagingen van mining die de <a href="/explore/bitcoin-halving-countdown" target="_blank" class="blog_inner_link">Bitcoin Halving</a> van 2024 zal creëren</h2><p>De effecten van de bitcoin-halvering op de mijnbouw zijn complex en divers. Ten eerste biedt de bitcoin-halvering een zeer goede kans voor de mijnwerkers, aangezien deze kan leiden tot een stijging van de prijs.</p>
<p>Na de vorige halveringsevenementen steeg de bitcoinprijs aanzienlijk. Als hetzelfde scenario zich voordoet, zullen de BTC-miners profiteren van de toename van de waarde, omdat ze meer inkomsten zullen genereren uit de verkoop van elke BTC dan nu.</p>
<p>Desalniettemin brengt het halveringsevenement verschillende uitdagingen met zich mee die Tether kunnen beïnvloeden tijdens de eerste paar mijnjaren. Ten eerste zal de bitcoin-halvering in 2024 de beloning van de mijnwerker per blok verminderen van 6,25 BTC naar 3,125. Dit betekent dat mijnwerkers met inefficiënte mijnfaciliteiten levensvatbaarheidsproblemen kunnen ondervinden.</p>
<p>Dit betekent ook dat de bitcoin miners die actief zijn op locaties waar de kosten van elektriciteit zeer hoog zijn, mogelijk zeer lage winsten behalen of zelfs verliezen lijden. Ter context, het delven van een enkele bitcoin vereist ongeveer 266.000 kilowattuur (kWh) aan elektriciteit. Hoe dan ook, de elektriciteitskosten zijn een belangrijke reden dat Tether ervoor heeft gekozen om zijn mijnbouwfaciliteiten te vestigen in landen met relatief lage energiekosten.</p>
<p>Het is waarschijnlijker dat de mijnbouwconcurrentie zal toenemen in het post 2024 halveringseventijdperk. Nick Cote, oprichter van Second Lane, heeft een vergelijkbare mening. <a href="https://twitter.com/mBTCPiz/status/1693607177142104521/" rel="nofollow noopener noreferrer" target="_blank">Hij zei</a> Ik blijf op de heuvel staan waar de meeste mijnwerkers niet effectief zullen kunnen concurreren in de volgende fase van deelname aan de mijnbouwruimte. De hoeveelheid netwerk hash buiten de VS zal blijven groeien, wat leidt tot felle concurrentie.</p>
<p>Het is vermeldenswaard dat de moeilijkheidsgraad van het delven van bitcoin waarschijnlijk zal blijven stijgen in 2024. Gezien het feit dat het dit jaar meerdere keren is gestegen, kan hetzelfde zich voordoen in 2024 en daarna. De mijnbouwmoeilijkheidsgraad meet in feite de rekenkracht die nodig is om nieuwe bitcoin te delven. Het bitcoin-netwerk balanceert het gemiddelde productietempo van de blockchain om zes blokken per uur te krijgen.</p>
<h2 id="h2-Conclusie532918"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Tether breidt zijn cryptocurrency-operatie uit naar bitcoin-mining. Het heeft de intentie om zijn mijnbouwfaciliteiten te vestigen in Uruguay, Paraguay en El Salvador. Het heeft al verschillende crypto-investeringen gedaan in bedrijven zoals Volcano Energy en Northern Data. Als het erin slaagt om 1% van het mijnkwartier te behalen, zoals het van plan is, zal het behoren tot de 20 beste crypto-mijnbouwbedrijven.</p>
<h2 id="h2-Veelgestelde20vragen20over20Tether989623"><a name="Veelgestelde vragen over Tether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Tether</h2><h3 id="h3-Heeft20Tether20een20toekomst132653"><a name="Heeft Tether een toekomst?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Heeft Tether een toekomst?</h3><p>Tether heeft een goede toekomst omdat het de toonaangevende stablecoin, Tether USDT, bezit. Veel investeerders gebruiken USDT om de waarde van hun geld te behouden. Op dit moment investeert Tether ook in bitcoin mining.</p>
<h3 id="h3-Wat20zal20Tether20over201020jaar20waard20zijn129351"><a name="Wat zal Tether over 10 jaar waard zijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zal Tether over 10 jaar waard zijn?</h3><p>Omdat Tether USDT een stablecoin is, is het onwaarschijnlijk dat de waarde in 10 jaar zal veranderen. Dit betekent dat het na 10 jaar een prijs van $1 zal behouden.</p>
<h3 id="h3-Waarom20daalt20USDT763488"><a name="Waarom daalt USDT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom daalt USDT?</h3><p>In de meeste glen daalt de waarde van USDT niet. Er zijn echter momenten waarop de waarde kan afwijken van de $1-koppeling. Dit gebeurt meestal wanneer er slecht nieuws is over Tether of wanneer er ernstige macro-economische uitdagingen zijn, zoals het instorten van grote banken.</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 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>