SGV0IGxvdCB2YW4gZGUgYmVtYW5uaW5nIHZhbiBkZSBUaXRhbmljIFN1YiB3b3JkdCBlZW4gZ29ra29vcnRzIHZvb3IgQ3J5cHRvIERlZ2Vucw==

2023-07-05, 05:58

<p><img src="https://gimg2.gateimg.com/image/article/1684401663RDZZ.jpeg" alt=""><br>Crypto-degens hebben meer dan $300.000 ingezet op de vraag of de vermiste bemanning van de Titanic-onderzeeër al dan niet vóór 23 juni gered zou worden.</p>
<p>De bredere crypto-gemeenschap bekritiseerde het wedden op de bemanning van de vermiste Titanic-onderzeeër.</p>
<p>Polymarket verdedigde zijn positie door te zeggen dat wedden een manier was om de sentimenten van mensen te verzamelen over of de bemanning al dan niet op tijd gered zou worden.</p>
<p>De regering van de Verenigde Staten neemt maatregelen om weddenschappen op evenementen te beperken.</p>
<p><strong>Trefwoorden</strong>: Crypto weddenschappen, crypto degens, crypto gokken, crypto weddenschappen, crypto gaming, crypto beperkingen</p>
<h2 id="h2-Introductie535532"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Terwijl de cryptoruimte blijft evolueren, zijn er nieuwe activiteiten zoals evenementenweddenschappen op de markt gekomen. De opkomst van het wedden op live-evenementen heeft gemengde reacties teweeggebracht onder cryptofanaten en de bredere samenleving.</p>
<p>In dit artikel bespreken we een voorbeeld van wedden op een gebeurtenis die verschillende reacties heeft opgeroepen onder cryptocurrency liefhebbers en analisten. Het gaat om wedden op de overlevingskansen van de vermiste bemanning van de Titanic onderzeeër.</p>
<h2 id="h2-Wedden20op20de20Vermiste20Titaniconderzeer953375"><a name="Wedden op de Vermiste Titanic-onderzeeër" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wedden op de Vermiste Titanic-onderzeeër</h2><p>Online crypto-gokkers of ‘degens’ namen deel aan weddenschappen over of de onderzeeër met vijf mensen aan boord, die vermist raakte tijdens een expeditie om de Titanic-wrakstukken te verkennen, zou worden gered met de bemanningsleden nog in leven.</p>
<p>Tegen het einde van juni was de zoektocht naar de onderzeeër en de bemanning nog steeds gaande, hoewel de hoop om het team levend te vinden afnam. Sterker nog, de vraag was of de onderzeeër al dan niet voor 23 juni zou worden geborgen.</p>
<p>De oppervlakteschepen verloren contact met de onderzeeër, bediend door<br><strong>OceanGate Expeditions</strong>. Helaas werd de reddingsmissie gehinderd door slecht weer en de vijandige toestand van de Noord-Atlantische Zee waar de onderzeeër zonk.<br><img src="https://gimg2.gateimg.com/image/article/16885365311.png" alt=""><br>De ontbrekende Titanic-onderzeeër - MirrorUK</p>
<p>Volgens beschikbare informatie bestond de bemanning uit de oprichter van OceanGate Expeditions, een Franse duiker, een Britse avonturier en een Pakistaanse vader en zoon.</p>
<h2 id="h2-Kan20de20bemanning20op20tijd20gered20worden635829"><a name="Kan de bemanning op tijd gered worden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kan de bemanning op tijd gered worden</h2><p>Het was tijdens de lopende zoekmissie dat er een verontrustende gebeurtenis binnen de cryptogemeenschap naar voren kwam, waarbij werd ingezet op de veiligheid van de vermiste bemanning van de Titanic onderzeeër. Sommige cryptodegens gokten op Polymarket of het OceanGate-vaartuig al dan niet zou worden teruggevonden vóór 23 juni, een tijdsbestek waarin werd verwacht dat de bemanningsleden nog in leven zouden zijn, gezien hun zuurstofreserves die naar verwachting slechts 96 uur zouden duren.</p>
<p>De crypto degens hebben meer dan $170 K ingezet op het wedden dat de<br><strong>Ontbrekende Titanic-onderzeeër</strong>, die op 18 juni vermist raakte, zou op 23 juni worden gevonden. In alle crypto <a href="https://www.gate.io/price/view/gambling" target="_blank">gokkers</a> had meer dan $300 K ingezet. Echter, een paar dagen voor het einde van de weddenschap was er slechts 15% kans dat de onderzeeër voor middernacht op 23 juni zou worden gevonden.</p>
<p>Aan de andere kant had de Polymarket-website specifieke voorwaarden voor het weddenschapsevenement. Er stond dat het schip alleen moest worden gelokaliseerd, niet per se hersteld of gered, tegen 23 juni. De andere belangrijke vereiste was dat het schip dat de bemanning vervoerde, niet alleen enkele van zijn onderdelen, moest worden gelokaliseerd.</p>
<p>Als alleen de stukken van het vaartuig worden gevonden zonder de cabine waarin de bemanning zich bevond, zou de onderzeeër niet zijn gevonden. Een paar dagen voor het einde van de weddenschap wedde ongeveer 62% van de weddenschappen dat het cabinevaartuig niet gevonden zou worden tegen 23 juni. Slechts iets minder dan de helft van de weddenschappen was echter optimistisch dat het vaartuig tegen de aangegeven datum zou worden gevonden.</p>
<p>Het is essentieel om op te merken dat de degens inzetten met behulp van cryptocurrencies en $1 per aandeel zouden verdienen als hun gokken correct waren. Echter, tegen 22 juni waren de kansen dat het huttenvaartuig zou worden hersteld negatief. Volgens één analist zou onderkoeling en koolstofdioxidevergiftiging de bemanningsleden beïnvloeden.</p>
<h2 id="h2-Morele20zorgen20over20cryptoinzetten20op20het20lot20van20de20vermiste20onderzeebootbemanning453958"><a name="Morele zorgen over crypto-inzetten op het lot van de vermiste onderzeebootbemanning" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Morele zorgen over crypto-inzetten op het lot van de vermiste onderzeebootbemanning</h2><p>De cryptogemeenschap heeft zorgen geuit over het wedden op live-evenementen zoals het lot van de vermiste onderzeebootbemanning. Sommige mensen hebben gezegd dat het onethisch is om te wedden op mensenlevens. Een Twitter-gebruiker zei dat het “het meest dystopische ding is dat ik heb gezien.”</p>
<p>Op dezelfde manier tweette het videospel publicatie Dexerto:<br><strong>Gokken met levens is eigenlijk krankzinnig.</strong> Een argument tegen wedden op de echte activiteiten van mensen die worden veroorzaakt door omstandigheden buiten hun controle is dat de familieleden van de getroffen personen mogelijk ondraaglijke pijn ondergaan vanwege het wedden op de mogelijkheid van de dood van hun geliefden.</p>
<p>Een andere Twitter-gebruiker zei: “<br><strong>Eigenlijk krankzinnig, stel je voor dat je geld verdient als iemand gaat sterven of niet.</strong>” Echter verdedigde Polymarket zijn positie door te zeggen dat het een natuurlijke manier was om de mogelijkheid van een succesvolle redding te schatten.</p>
<p>In een e-mail aan Gizmodo zei het bedrijf: “<br><strong>Als de families op de hoogte waren van Polymarket, konden ze de markt gebruiken als een manier om de real-time, onbevooroordeelde waarschijnlijkheid van het herstellen van de onderzeeër te verkrijgen.</strong>”</p>
<p>Het voegde eraan toe, “<br><strong>Dat is een veel waardevollere dienst voor hen dan sensationele media-aandacht: tenminste met onze markten, begrijpen ze de ware waarschijnlijkheden.</strong>”</p>
<p>In het g van de vermiste onderzeeër en haar bemanningsleden is het duidelijk dat hun families emotioneel belast zijn door de mogelijkheid hun geliefden te verliezen, en nog erger, mensen die wedden op hun lot.</p>
<h2 id="h2-De20Amerikaanse20regering20overweegt20beperkingen20op20evenementenweddenschappen17625"><a name="De Amerikaanse regering overweegt beperkingen op evenementenweddenschappen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Amerikaanse regering overweegt beperkingen op evenementenweddenschappen</h2><p>Al de Amerikaanse overheid overweegt nu om weddenschappen op bepaalde gebeurtenissen, zoals politieke verkiezingen, te beperken. Sterker nog, in 2022 is de Amerikaanse overheid begonnen met een proces om event-gebaseerd wedden te stoppen door de licenties van wedplatforms die dergelijke diensten aanbieden, zoals PredictIt, in te trekken.</p>
<p>Op dit moment heeft PredictIt een kennisgeving ontvangen van het voornemen om zijn licentie in te trekken. Het heeft de Amerikaanse regering echter juridisch aangeklaagd voor die stap. Over het algemeen toont wedden op evenementen zoals de vermiste Titanic-onderzeeër de noodzaak aan om onverantwoordelijk wedden op sommige echte evenementen te beteugelen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/384/" target="_blank">Cryptowetgeving in de Verenigde Staten en andere landen</a></p>
<h2 id="h2-Conclusie551511"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De wereld getuigde van wat sommige analisten geloven dat een van de meest onethische weddenschapsevenementen is, waar crypto degens wedden op het waarschijnlijke lot van de vermiste bemanning van de Titanic-onderzeeër. Al op 22 juni hadden crypto-gokkers in totaal meer dan $300 K ingezet. Desalniettemin bekritiseerde veel leden van de Twitter-gemeenschap het wedden op het lot van de vermiste bemanning van de Titanic-onderzeeër als onethisch.</p>
<h2 id="h2-Veelgestelde20vragen20over20Crypto20Degens151202"><a name="Veelgestelde vragen over Crypto Degens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Crypto Degens</h2><h3 id="h3-Kun20je20wedden20met20crypto159325"><a name="Kun je wedden met crypto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kun je wedden met crypto?</h3><p>Mensen kunnen wedden met cryptocurrency op verschillende onderwerpen op platforms die ze accepteren als betaalmiddel. Ze kunnen zich bezighouden met sportweddenschappen of weddenschappen over bepaalde gebeurtenissen.</p>
<h3 id="h3-Hoe20werkt20crypto20wedden995831"><a name="Hoe werkt crypto wedden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe werkt crypto wedden?</h3><p>De crypto-weddenschapsplatforms stellen individuen in staat om specifieke cryptocurrencies op hun rekeningen te storten en vervolgens te wedden op de mogelijkheid van een bepaalde uitkomst. Als je een weddenschap wint, kun je <a href="https://www.gate.io/help/guide/deposit_withdrawa/16447/How-to-Withdraw" target="_blank">haal je crypto op</a> activa zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> of ETH.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen wordt er juridische stappen ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>