TEJSWSBjb250cm8gbGEgU0VDOiBVbm8gc2d1YXJkbyBwacO5IGFwcHJvZm9uZGl0byBhbCBwcm9jZXNzbyBkaSBhcHBlbGxvIGRlbGwnRVRG

2023-09-19, 09:25

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>LBRY ha presentato ricorso contro una decisione della SEC secondo cui la sua criptovaluta, LBC, è considerata un titolo di sicurezza.</p>
<p>Oltre a vietare la negoziazione di LBC, la SEC ha inflitto una pesante sanzione finanziaria a LBRY.</p>
<p>Gli utenti di LBRY possono creare, caricare, condividere e visualizzare contenuti utilizzando l’applicazione.</p>
<p>Parole chiave: cause SEC, SEC vs. LBRY, caso LBRY, sentenza LBRY, SEC querela SEC, aggiornamento causa LBRY, protocollo LBRY</p>
<h2 id="h2-Introduzione892750"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Le battaglie legali che coinvolgono le criptovalute sono comuni negli Stati Uniti poiché vari regolatori competono per stabilire le loro giurisdizioni su diversi asset e servizi cripto. Ci sono molti casi in cui vari organismi di regolamentazione hanno ordinato a progetti di criptovalute di interrompere la vendita di prodotti cripto come derivati DeFi.</p>
<p>In questo articolo, discutiamo dell’appello di LBRY contro la SEC e della possibilità del suo successo.</p>
<h2 id="h2-LBRY20combatte20con20la20SEC205659"><a name="LBRY combatte con la SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LBRY combatte con la SEC</h2><p><a href="https://www.gate.io/how-to-buy/lbry-credits-lbc" target="_blank">LBRY</a>, una piattaforma decentralizzata per la pubblicazione e condivisione di contenuti, ha presentato ricorso contro la recente decisione della Securities and Exchange Commission (SEC) degli Stati Uniti che ha dichiarato che il suo token, LBRY, è un titolo. Secondo la SEC, il fatto che LBRY abbia creato L <a href="https://www.gate.io/price/lbry-credits-lbc/ars" target="_blank">monete BRY</a>, li detenevano e li vendevano successivamente trasformati <a href="https://www.gate.io/de/blog_detail/2708/sec-labels-37-cryptocurrencies-as-securities-implications-for-trading" target="_blank">trasformarli in titoli</a>.</p>
<p>Tuttavia, il 7 settembre LBRY ha presentato la sua intenzione di sfidare la decisione della SEC presso la Corte d’Appello degli Stati Uniti per il Primo Circuito dopo che il Tribunale distrettuale degli Stati Uniti per il Distretto del New Hampshire ha emesso la sua sentenza definitiva l’11 luglio che ha dato ragione alla decisione della SEC di vietare la vendita della sua moneta.</p>
<p>In realtà, LBRY sta combattendo una battaglia legale contro la SEC dal 2021, quando ha dichiarato che la vendita di crediti LBRY (LBC) era illegale in quanto non era stata registrata presso l’organo di regolamentazione. Tale decisione ha costretto LBRY a chiudere le sue operazioni e a chiudere.</p>
<p>Inoltre, la SEC ha chiesto una restituzione di 22 milioni di dollari, che LBRY ha contestato sulla base del fatto di aver sostenuto enormi costi operativi. Di conseguenza, la sentenza della Corte distrettuale degli Stati Uniti per il distretto del New Hampshire ha rivisto al ribasso la sanzione a $ 111.614.</p>
<p>Inoltre, il tribunale ha vietato definitivamente a LBRY di offrire direttamente o indirettamente un titolo crittografico non registrato. In effetti, il giudice federale Paul Barbadoro, del Tribunale distrettuale del New Hampshire, ha dichiarato: ‘Nessun giudice ragionevole potrebbe respingere la contestazione della SEC secondo cui LBRY ha offerto LBC come titolo, e LBRY non ha una difesa processuale che indichi la mancanza di un preavviso equo’.</p>
<p>Nonostante la sua precedente indicazione di interrompere le sue operazioni e la vendita di LBC, il 7 settembre LBRY ha presentato un appello contro la sentenza del tribunale.</p>
<h2 id="h2-Risposta20di20LBRY814954"><a name="Risposta di LBRY" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risposta di LBRY</h2><p>In primo luogo, la gestione di LBRY sostiene che la SEC e le successive sentenze dei tribunali sul LBC siano state erronee, quindi sta cercando di ribaltare la situazione. Jeremy Kauffman, il fondatore del protocollo LBRY, ritiene che l’esito del caso SEC vs. LBRY abbia implicazioni estese sull’intera industria crittografica.</p>
<p>Attraverso un’email a Coindesk, Kauffman ha dichiarato: “Il caso SEC vs. LBRY stabilisce un precedente che minaccia l’intera industria delle criptovalute negli Stati Uniti. Secondo lo standard SEC vs. LBRY, quasi ogni criptovaluta, compresa <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e Doge, sono titoli. Il futuro delle criptovalute negli Stati Uniti ora è nelle mani di un’organizzazione ancora peggiore della SEC: il Congresso degli Stati Uniti.</p>
<h2 id="h2-Motivi20per20lAppello420370"><a name="Motivi per l’Appello" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Motivi per l’Appello</h2><p>Come detto in precedenza, la direzione di LBRY ritiene che la sentenza di LBRY sia stata erronea. Secondo Coindesk, Kauffman ha detto: “LBRY sta appellando la decisione [del tribunale] perché è ingiusta e errata.”</p>
<p>Ha aggiunto: “La SEC ha mostrato chiaramente l’intento di utilizzare questa sentenza per danneggiare l’industria delle criptovalute in modo più ampio. Non lo permetteremo.”</p>
<p>Inoltre, le recenti vittorie dei progetti criptati contro le cause della SEC potrebbero aver motivato LBRY a presentare appello. Ad esempio, <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">La vittoria parziale di Ripple Labs contro la SEC</a> potrebbe aver dato a LBRY la speranza che potrebbe anche vincere contro di essa.</p>
<p>Recentemente, un giudice federale ha stabilito che le monete Ripple ( <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>) Le monete vendute su borse cripto non costituiscono titoli. Tuttavia, le monete vendute direttamente agli investitori istituzionali sono titoli cripto.</p>
<p>Pertanto, la parziale vittoria di Ripple contro la SEC ha stabilito un precedente per cui alcune criptovalute non sono titoli. È molto probabile che LBRY possa utilizzare argomenti simili contro l’autorità di regolamentazione.</p>
<p>Allo stesso modo, <a href="https://www.gate.io/blog_detail/158/the-1st-cryptocurrency-investments-grayscale-what-is-gbtc" target="_blank">Grayscale ha ottenuto una piccola vittoria</a> quando un pannello di tre giudici della Corte d’Appello del Circuito di Washington ha dato un mandato alla SEC per esaminare la richiesta della società di gestione degli asset digitali di convertire il suo trust in uno spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF.</p>
<p>Leggi anche: <a href="https://www.gate.io/live/video/a327841641b5beddfe67506a5c382fd7" target="_blank">Impatto dell’evento Grayscale e dell’ETF spot</a></p>
<p>Nel frattempo, molti leader e addetti ai lavori della crittografia stanno seguendo gli sviluppi delle cause della SEC contro LBRY, Ripple e <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>. Il motivo è che i loro risultati hanno un grande impatto sul futuro dell’industria crittografica, non solo negli Stati Uniti ma anche a livello globale.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/xrp-xrp" target="_blank">Previsione e previsione XRP Prezzo per il 2023, 2025, 2030</a></p>
<p>L’appello di LBRY contro la SEC probabilmente darà un buon punto di riferimento all’approccio che l’autorità di regolamentazione sta utilizzando per regolare le criptovalute. Potrebbe indicare la coerenza o le incongruenze della SEC nella supervisione delle attività cripto nel paese.</p>
<p>Già, una grande comunità di sostenitori e investitori <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> sostiene la posizione di LBRY contro la SEC, come indicato dal suo appello. Ad esempio, l’avvocato Bill Morgan, simpatizzante di Ripple, ha detto: “Tutti sono dalla tua parte, specialmente i detentori del token LBC. Ho sempre detto che non era un buon giudizio.”</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3195/-ripple-price-surge-indicators &quot;Ripple (XRP" rel="nofollow noopener noreferrer" target="_blank">Ripple (XRP) pronto per un aumento del prezzo del 20%</a> Pronto per un rialzo del 20%</p>
<h2 id="h2-Cos20LBRY20e20cosa20offre466361"><a name="Cos’è LBRY e cosa offre?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è LBRY e cosa offre?</h2><p>Per concludere la nostra discussione sull’aggiornamento della causa legale di LBRY, esploriamo cosa sia LBRY. LBRY è un protocollo decentralizzato che consente alle persone di pubblicare e condividere contenuti digitali. Supporta vari media come audio, video ed ebook.</p>
<p>Ha la propria blockchain che utilizza un meccanismo di consenso proof-of-work. Di conseguenza, gli utenti del protocollo possono guadagnare la loro criptovaluta nativa, LBRY coin, anche chiamata Library Credits (LBC) tramite mining. Inoltre, LBC consente agli utenti di creare, pubblicare e condividere i propri contenuti digitali.</p>
<p>Questo protocollo è decentralizzato, il che significa che consente a chiunque di creare, pubblicare, condividere e visualizzare contenuti digitali sulla piattaforma. Poiché la blockchain utilizza un meccanismo di consenso proof-of-work, i miner guadagnano LBC per la verifica delle transazioni. Pertanto, il “caso LBRY della SEC” ha creato molti disagi tra i suoi utenti.</p>
<h2 id="h2-Conclusion641222"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>LBRY ha presentato ricorso contro la sentenza della SEC secondo cui la sua moneta, LBC, è un titolo crittografico che richiede la registrazione prima di offrirla agli investitori. Diversi eventi come le vittorie parziali di Ripple e <a href="https://www.gate.io/live/video/280322cbbe007ada7b702ff053776e27" target="_blank">Grigio sopra la SEC</a> li ha motivato a fare appello contro la sentenza. LBC guida la blockchain di LBRY utilizzata per archiviare e condividere contenuti digitali.</p>
<h2 id="h2-Domande20frequenti20su20LBRY304300"><a name="Domande frequenti su LBRY" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su LBRY</h2><h3 id="h3-Qual2020il20caso20Library20vs20SEC983870"><a name="Qual è il caso Library vs. SEC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è il caso Library vs. SEC?</h3><p>Library è impegnata in una battaglia legale contro la SEC. Nel 2021 la Securities and Exchange Commission (SEC) degli Stati Uniti ha dichiarato che la vendita di crediti LBRY (LBC) era illegale in quanto non registrati presso l’organismo di regolamentazione. L’11 luglio, con la sua sentenza definitiva, la Corte Distrettuale degli Stati Uniti per il Distretto del New Hampshire ha confermato che LBC è un titolo. Tuttavia, il 7 settembre la LBRY ha presentato appello contro la sentenza.</p>
<h3 id="h3-Qual2020stata20la20sentenza20riassuntiva20del20caso20SEC20vs20LBRY231537"><a name="Qual è stata la sentenza riassuntiva del caso SEC vs. LBRY?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è stata la sentenza riassuntiva del caso SEC vs. LBRY?</h3><p>Il tribunale distrettuale degli Stati Uniti per il distretto di New Hampshire ha dichiarato che la moneta LBRY (LBC) è un token di sicurezza che deve essere registrato prima di essere offerto in vendita. Pertanto, il tribunale ha chiesto a LBRY di smettere di vendere LBC e di pagare una multa di $111,614.</p>
<h3 id="h3-LBRY20ha20vinto20la20causa594743"><a name="LBRY ha vinto la causa?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LBRY ha vinto la causa?</h3><p>LBRY ha perso la causa contro la SEC poiché la sentenza del tribunale gli ha vietato di vendere la sua moneta (LBC). Inoltre, il tribunale distrettuale degli Stati Uniti per il distretto del New Hampshire ha ordinato a LBRY di pagare una multa di $111,614.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>