TEJSWSB0ZWdlbiBkZSBTRUM6IEVlbiBuYWRlcmUgYmxpayBvcCBoZXQgRVRGIGJlcm9lcHNwcm9jZXM=

2023-09-19, 09:25

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>LBRY heeft beroep aangetekend tegen een SEC-uitspraak dat zijn cryptocurrency, LBC, een effect is.</p>
<p>Naast het verbieden van de handel in LBC legde de SEC een zware financiële boete op aan LBRY.</p>
<p>LBRY-gebruikers kunnen content maken, uploaden, delen en bekijken met behulp van de applicatie.</p>
<p>Trefwoorden: SEC-rechtszaken, SEC vs. LBRY, LBRY-zaak, LBRY-uitspraak, SEC klaagt SEC aan, LBRY-rechtszaak-update, LBRY-protocol</p>
<h2 id="h2-Introductie295771"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Juridische geschillen met betrekking tot cryptocurrencies zijn gebruikelijk in de Verenigde Staten, aangezien verschillende regelgevende instanties strijden om hun bevoegdheden vast te stellen over verschillende crypto-activa en diensten. Er zijn veel glen waarin verschillende regelgevende instanties hebben bevolen dat sommige cryptocurrency-projecten de verkoop van cryptoproducten zoals DeFi-derivaten moeten staken.</p>
<p>In dit artikel bespreken we het beroep van LBRY tegen de SEC en de mogelijkheid van succes.</p>
<h2 id="h2-LBRY20strijdt20met20SEC335718"><a name="LBRY strijdt met SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LBRY strijdt met SEC</h2><p><a href="https://www.gate.io/how-to-buy/lbry-credits-lbc" target="_blank">LBRY</a>, een gedecentraliseerd platform voor het publiceren en delen van inhoud, heeft beroep aangetekend tegen de recente uitspraak van de Securities and Exchange Commission (SEC) van de Verenigde Staten waarin werd verklaard dat hun token, LBRY, een effect is. Volgens de SEC is het feit dat LBRY L heeft gecreëerd <a href="https://www.gate.io/price/lbry-credits-lbc/ars" target="_blank">BRY munten</a>, vastgehouden en later verkocht <a href="https://www.gate.io/de/blog_detail/2708/sec-labels-37-cryptocurrencies-as-securities-implications-for-trading" target="_blank">hen omzetten in effecten</a>.</p>
<p>Desalniettemin heeft LBRY op 7 september zijn voornemen bekendgemaakt om de uitspraak van de SEC aan te vechten bij het United States Court of Appeals for the First Circuit, nadat de U.S. District Court for the District of New Hampshire op 11 juli zijn definitieve oordeel had uitgesproken dat de beslissing van de SEC om de verkoop van zijn munt te verbieden, steunde.</p>
<p>LBRY is feitelijk sinds 2021 in een juridische strijd verwikkeld tegen de SEC, nadat deze had verklaard dat de verkoop van LBRY-credits (LBC) illegaal was omdat ze deze niet bij het regelgevende orgaan hadden geregistreerd. Deze beslissing dwong LBRY om zijn activiteiten af te bouwen en te sluiten.</p>
<p>Daarnaast vorderde de SEC een teruggave van $22 miljoen, waar LBRY bezwaar tegen maakte op grond van de enorme operationele kosten die het had gemaakt. Als gevolg hiervan heeft de uitspraak van de rechtbank van het Amerikaanse district voor het district New Hampshire de boete verlaagd tot $111.614.</p>
<p>Verder heeft de rechtbank LBRY permanent verboden om direct of indirect een niet-geregistreerde crypto security aan te bieden. In feite verklaarde de federale rechter Paul Barbadoro, van de districtsrechtbank voor het district New Hampshire, ‘Geen redelijke feitenrechter zou de bewering van de SEC kunnen verwerpen dat LBRY LBC als een security heeft aangeboden, en LBRY heeft geen verdediging dat het geen eerlijke kennisgeving heeft gekregen.’</p>
<p>Ondanks het eerdere signaal dat het zijn activiteiten en de verkoop van LBC zou stopzetten, heeft LBRY op 7 september beroep aangetekend tegen het vonnis van de rechtbank.</p>
<h2 id="h2-Reactie20van20LBRY417617"><a name="Reactie van LBRY" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reactie van LBRY</h2><p>In de eerste plaats is het management van LBRY van mening dat de SEC en de daaropvolgende gerechtelijke uitspraken over de LBC onjuist waren, en daarom streeft het ernaar ze teniet te doen. Jeremy Kauffman, de oprichter van het LBRY-protocol, is van mening dat de uitkomst van de zaak SEC vs. LBRY ingrijpende gevolgen heeft voor de hele crypto-industrie.</p>
<p>Via een e-mail aan Coindesk verklaarde Kauffman: “De zaak SEC vs. LBRY schept een precedent dat de gehele Amerikaanse cryptocurrency-industrie bedreigt. Volgens de standaard van SEC vs. LBRY valt bijna elke cryptocurrency, inclusief <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en Doge, zijn effecten. De toekomst van cryptocurrency in de VS rust nu bij een organisatie die nog erger is dan de SEC: het Congres van de Verenigde Staten.</p>
<h2 id="h2-Redenen20voor20het20beroep915809"><a name="Redenen voor het beroep" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Redenen voor het beroep</h2><p>Zoals eerder gezegd, gelooft het LBRY-management dat het LBRY-vonnis gebrekkig was. Volgens Coindesk zei Kauffman: “LBRY gaat in beroep tegen de [rechtbank]beslissing omdat deze onrechtvaardig en onjuist is.”</p>
<p>Hij voegde eraan toe: ‘De SEC heeft duidelijke bedoelingen getoond om met deze uitspraak de cryptocurrency-industrie breder te schaden. We zullen ze niet laten.</p>
<p>Bovendien zouden recente overwinningen van cryptoprojecten in rechtszaken tegen de SEC LBRY kunnen hebben gemotiveerd om zijn eigen beroep aan te spannen. Bijvoorbeeld, <a href="https://www.gate.io/uk/blog_detail/2960/xrp-climbs-on-the-4th-spot-among-cryptocurrencies-following-ripple-s-sec-triumph" target="_blank">Ripple Labs’ gedeeltelijke overwinning tegen de SEC</a> heeft LBRY misschien hoop gegeven dat het er ook tegen kan winnen.</p>
<p>Onlangs oordeelde een federale rechter dat Ripple munten ( <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Op crypto-beurzen verkochte munten vormen geen effecten. De munten die echter rechtstreeks aan institutionele beleggers worden verkocht, zijn crypto-effecten.</p>
<p>Daarom heeft de gedeeltelijke overwinning van Ripple tegen de SEC een precedent geschapen dat sommige cryptocurrencies geen effecten zijn. Het is zeer waarschijnlijk dat LBRY vergelijkbare argumenten zal gebruiken tegen de toezichthoudende autoriteit.</p>
<p>Evenzo, <a href="https://www.gate.io/blog_detail/158/the-1st-cryptocurrency-investments-grayscale-what-is-gbtc" target="_blank">Grayscale heeft een kleine overwinning behaald</a> Toen een panel van drie rechters van het DC Circuit Court of Appeals de SEC opdroeg om de aanvraag van het digitale activabeheerbedrijf te beoordelen om zijn trust om te zetten in een spot. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF.</p>
<p>Lees ook: <a href="https://www.gate.io/live/video/a327841641b5beddfe67506a5c382fd7" target="_blank">Impact van Grayscale-evenement en spot ETF</a></p>
<p>Ondertussen volgen veel crypto-leiders en insiders de ontwikkelingen van de SEC-rechtszaken tegen LBRY, Ripple en <a href="https://www.gate.io/blog_detail/3140/daily-news-grayscale-won-the-lawsuit-btc-rose-wu-jihan-cautiously-bullish-on-the-market-long-term-holders-continue-to-increase-their-holdings-of-btc" target="_blank">Grayscale</a>. De reden hiervoor is dat hun resultaten een grote invloed hebben op de toekomst van de cryptosector, niet alleen in de Verenigde Staten maar ook wereldwijd.</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/xrp-xrp" target="_blank">XRP Prijsvoorspelling &amp; Voorspelling voor 2023, 2025, 2030</a></p>
<p>Het beroep van LBRY tegen de SEC zal waarschijnlijk een goede aanwijzing geven voor de aanpak die de toezichthoudende autoriteit gebruikt om cryptocurrencies te reguleren. Het kan de consistentie of inconsistenties van de SEC aangeven bij het toezicht houden op cryptogerelateerde activiteiten in het land.</p>
<p>Al een grote gemeenschap van XRP-aanhangers en investeerders steunt de stand van LBRY tegenover de SEC, zoals blijkt uit het beroep. Zo zei advocaat Bill Morgan, een sympathisant van Ripple: ‘Iedereen staat aan jouw kant, vooral de houders van de LBC-token. Ik heb altijd gezegd dat het geen goede uitspraak was.’</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3195/-ripple-price-surge-indicators &quot;Ripple (XRP" rel="nofollow noopener noreferrer" target="_blank">Ripple (XRP) klaar voor een prijsstijging van 20%</a> Klaar voor een prijsstijging van 20%”})</p>
<h2 id="h2-Wat20is20LBRY20en20wat20biedt20het20aan936440"><a name="Wat is LBRY en wat biedt het aan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is LBRY en wat biedt het aan?</h2><p>Nu om onze discussie over de LBRY-rechtszaakupdate af te sluiten, laten we eens kijken wat LBRY is. LBRY is een gedecentraliseerd protocol dat mensen in staat stelt om digitale inhoud te publiceren en te delen. Het ondersteunt verschillende media zoals audio’s, video’s en e-books.</p>
<p>Het heeft zijn eigen blockchain die gebruik maakt van een bewijs-van-werk consensusmechanisme. Hierdoor kunnen de gebruikers van het protocol hun eigen native cryptocurrency verdienen, LBRY-coin ook wel Library Credits (LBC) genoemd, door middel van mining. Bovendien stelt LBC gebruikers in staat om hun digitale inhoud te maken, publiceren en delen.</p>
<p>Dit protocol is gedecentraliseerd, wat betekent dat het iedereen toestaat om digitale inhoud op het platform te maken, publiceren, delen en bekijken. Aangezien de blockchain een proof-of-work consensusmechanisme gebruikt, verdienen miners LBC voor het verifiëren van transacties. Daarom heeft de ‘SEC sue LBRY case’ veel ongemak veroorzaakt onder zijn gebruikers.</p>
<h2 id="h2-Conclusie689662"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>LBRY heeft beroep aangetekend tegen de uitspraak van de SEC dat zijn munt, LBC, een crypto-effect is dat registratie vereist voordat het aan de investeerders wordt aangeboden. Verschillende evenementen, zoals de gedeeltelijke overwinningen van Ripple en <a href="https://www.gate.io/live/video/280322cbbe007ada7b702ff053776e27" target="_blank">Grayscale over de SEC</a> heeft het gemotiveerd om in beroep te gaan tegen het vonnis. De LBC stuurt de LBRY blockchain aan die wordt gebruikt voor het opslaan en delen van digitale inhoud.</p>
<h2 id="h2-Veelgestelde20vragen20over20LBRY442377"><a name="Veelgestelde vragen over LBRY" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over LBRY</h2><h3 id="h3-Wat20is20de20zaak20van20de20Library20vs20SEC185638"><a name="Wat is de zaak van de Library vs. SEC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de zaak van de Library vs. SEC?</h3><p>Library is verwikkeld in een juridische strijd tegen de SEC. In 2021 verklaarde de Securities and Exchange Commission (SEC) van de Verenigde Staten dat de verkoop van LBRY credits (LBC) illegaal was omdat ze niet geregistreerd waren bij de toezichthoudende instantie. Op 11 juli bevestigde de U.S. District Court for the District of New Hampshire in zijn definitieve uitspraak dat LBC een effect is. Echter, op 7 september tekende LBRY beroep aan tegen het vonnis.</p>
<h3 id="h3-Wat20was20het20samenvattende20oordeel20van20de20SEC20vs20LBRY20zaak605590"><a name="Wat was het samenvattende oordeel van de SEC vs. LBRY zaak?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat was het samenvattende oordeel van de SEC vs. LBRY zaak?</h3><p>De rechtbank van het arrondissement New Hampshire heeft verklaard dat de LBRY coin (LBC) een effectentoken is dat geregistreerd moet worden voordat het te koop wordt aangeboden. De rechtbank heeft LBRY daarom verzocht om te stoppen met de verkoop van LBC en een boete van $111.614 te betalen.</p>
<h3 id="h3-Heeft20LBRY20de20rechtszaak20gewonnen553632"><a name="Heeft LBRY de rechtszaak gewonnen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Heeft LBRY de rechtszaak gewonnen?</h3><p>LBRY heeft het proces tegen de SEC verloren omdat het vonnis het bedrijf verbiedt om zijn munt (LBC) te verkopen. Bovendien heeft de Amerikaanse districtsrechtbank voor het district New Hampshire opgedragen dat LBRY een boete van $111.614 moet betalen.</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 mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>