TCdBdXN0cmFsaWEgcHJvbXVvdmUgdW5hIHByb3Bvc3RhIGRpIGxlZ2dlIHByaXZhdGEgcGVyIHJhemlvbmFsaXp6YXJlIGxhIHJlZ29sYW1lbnRhemlvbmUgZGVsbGUgY3JpcHRvdmFsdXRl

2023-05-11, 03:21

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR388142"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il senatore australiano, Andrew Bragg, ha presentato il “Digital Assets (Market Regulation) Bill 2023”, che potrebbe gettare le basi per la regolamentazione delle criptovalute in Australia.</p>
<p>Se approvata, la legge proteggerà gli interessi sia dei consumatori che degli investitori di criptovalute in Australia.</p>
<p>Attualmente, l’Australia applica le regolamentazioni finanziarie esistenti nei mercati cripto australiani.</p>
<h2 id="h2-Introduzione298026"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Nonostante i rischi intrinseci delle criptovalute, la tecnologia blockchain rimane un’innovazione trasformativa. Di conseguenza, i governi stanno lavorando su modi per ridurre i rischi delle criptovalute e proteggere i consumatori. Stanno introducendo leggi rilevanti che regolano le operazioni delle imprese criptate. Oggi vediamo come sta progredendo l’Australia nel creare legislazioni rilevanti.</p>
<h2 id="h2-Il20nuovo20disegno20di20legge20in20materia20di20criptovalute20dellAustralia103983"><a name="Il nuovo disegno di legge in materia di criptovalute dell’Australia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il nuovo disegno di legge in materia di criptovalute dell’Australia</h2><p>Recentemente il senatore Andrew Bragg ha presentato un disegno di legge privato intitolato “Digital Assets (Market Regulation) Bill 2023” il cui obiettivo è proteggere i consumatori e promuovere gli interessi degli investitori. Questo disegno di legge copre varie questioni relative alle criptovalute e alla blockchain come requisiti di custodia, stablecoin e licenze degli scambi di criptovalute, tra gli altri.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16837749971961683774083_.pic.jpg" alt=""><br>Senatore Andrew Bragg - Australifintec</p>
<p>In generale, in Australia i ministri sono responsabili di proporre leggi. Tuttavia, c’è anche spazio per i senatori come Andrew Bragg per presentare le loro proposte di legge che, tuttavia, hanno una possibilità più bassa di approvazione rispetto a quelle dei ministri. Anche se vengono approvate, spesso ci vogliono mesi o addirittura anni per ottenere l’approvazione.</p>
<p>Il disegno di legge di Bragg arriva alcuni mesi dopo le 12 raccomandazioni presentate dal Comitato speciale del Senato sull’Australia come centro tecnologico e finanziario nel mese di ottobre 2021. Inoltre, il senatore incolpa il governo per non aver emanato una normativa criptata rilevante che protegga i consumatori australiani dall’impatto degli eventi su scala industriale. <a href="https://www.gate.io/blog_detail/1804/key-lessons-from-the-collapse-of-ftx-and-the-implosion-of-ftt" target="_blank">come il crollo del FTX</a>.</p>
<p>Nel contempo, il senatore ha dichiarato che l’Australia può diventare un polo di attività digitali se nel paese vi è una regolamentazione crittografica ben elaborata e applicata.</p>
<p>Leggi anche: <a href="https://www.gate.io/de/blog_detail/2567/australia-surpass-asia-in-bitcoin-atm-numbers-a-buoyant-crypto-market" target="_blank">L’Australia supera l’Asia nel numero di bancomat Bitcoin</a></p>
<h2 id="h2-Lobiettivo20principale20della20legge256074"><a name="L’obiettivo principale della legge" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’obiettivo principale della legge</h2><p>Come detto, il disegno di legge sugli asset digitali (regolamentazione del mercato) del 2023 mira a fornire un quadro per il rilascio di licenze agli scambi di criptovalute e a stabilire i servizi che dovrebbero offrire. Inoltre stabilisce chi dovrebbe emettere stablecoin e i requisiti di riserva, nonché la loro custodia. In particolare stabilisce la procedura di governance, i requisiti di sicurezza, i requisiti patrimoniali minimi e la segregazione dei fondi dei clienti.</p>
<p>È importante notare che la legge richiede alle attività criptografiche come gli scambi di registrarsi presso la Commissione per i Titoli e gli Investimenti Australiana. Possono anche avere licenze straniere per operare nel paese.</p>
<p>Inoltre, se approvato il disegno di legge, l’Australian Securities &amp; Investments Commission (ASIC) sarà autorizzato a monitorare e indagare sulle operazioni delle imprese criptate. Pertanto, il suo mandato comprenderà l’applicazione della regolamentazione. Allo stesso modo, verranno definiti i sanzioni civili e penali per le varie violazioni.</p>
<p>In realtà, il disegno di legge comprende altre obbligazioni fondamentali per le aziende e gli utenti di criptovalute. Ad esempio, stabilisce le procedure necessarie per la registrazione e la segnalazione dell’affidamento di asset digitali. Un altro sviluppo importante è che ci sono delle consultazioni pubbliche riguardo alla regolamentazione delle criptovalute in corso.</p>
<h2 id="h2-Le20implicazioni20del20disegno20di20legge20del20Senatore627784"><a name="Le implicazioni del disegno di legge del Senatore" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le implicazioni del disegno di legge del Senatore</h2><p>Se il disegno di legge viene approvato come legge, le imprese criptate dovranno operare in modo specifico. Ad esempio, solo le aziende e i progetti criptati registrati forniranno prodotti e servizi nel paese. I proprietari di imprese non autorizzate saranno perseguiti.</p>
<p>Ancora, le imprese che non rispetteranno la nuova legislazione criptata pagheranno multe o saranno radiate. Questo perché l’autorità regolatrice competente monitorerà i progetti criptati per verificarne la conformità alla legge.</p>
<p>Le borse saranno tenute a detenere le riserve minime previste dalla legge, il che probabilmente impedirà le corse alle banche quando i clienti vogliono riscattare i loro asset digitali.</p>
<p>Gli emittenti di stablecoin dovranno registrare le loro attività e detenere le riserve richieste che sono pari ai valori nominali dei loro token. Ad esempio, un emittente di stablecoin con 10.000 token ancorati all’1,1 al dollaro australiano, dovrebbe avere una riserva di $10.000 AUD.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16837751601971683774097_.pic.jpg" alt=""><br>Gli emittenti di stablecoin devono mantenere riserve - <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.com</p>
<h2 id="h2-Le20attuali20normative20criptate20in20Australia546804"><a name="Le attuali normative criptate in Australia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le attuali normative criptate in Australia</h2><p>Attualmente, l’Australia non ha regolamentazioni specifiche per le criptovalute. Tuttavia, utilizza la legge esistente per regolare le attività legate alle criptovalute nel paese. Ad esempio, ci si aspetta che le imprese criptografiche rispettino le norme antiriciclaggio e antiterrorismo (AML/CTF), il regime dei servizi finanziari ai sensi del Corporations Act 2001 (Cth), il Competition and Consumer Act 2010 (Cth) e la licenza per i servizi finanziari australiana (AFSL).</p>
<p>Ad esempio, secondo la legge sulle società del 2001, gli asset digitali sono classificati come prodotti di investimento o prodotti negoziati in borsa. Anche le imprese che offrono servizi crypto come il prestito dovrebbero avere un credito ai sensi della legge sulla protezione dei consumatori di credito nazionale del 2009 (Cth).</p>
<p>Secondo le normative australiane esistenti sulle criptovalute, le criptovalute come BTC ed ETH sono classificate come proprietà e sono legali nel paese. Pertanto, le persone possono acquistarli, venderli o scambiarli come desiderano. Le aziende possono accettare criptovalute come mezzo di pagamento. Inoltre, le criptovalute e gli altri <a href="https://www.gate.io/blog_detail/2286" target="_blank">asset come NFT</a> sono soggetti a tassazione sulle plusvalenze (CGT).</p>
<p>La Commissione per la Sicurezza e gli Investimenti dell’Australia (ASIC) è l’ente regolatore primario delle criptovalute nel paese e supervisiona tutte le attività connesse alle criptovalute. D’altro canto, l’ATO si assicura che le aziende criptovalutarie rispettino le leggi fiscali del paese.</p>
<h2 id="h2-Conclusione899759"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>La presentazione del “Digital Assets (Market Regulation) Bill 2023” da parte del Senatore Andrew Bragg dimostra l’impegno che i legislatori hanno nell’istituire un chiaro quadro normativo per le criptovalute in Australia. L’attuazione di standard regolamentari per l’industria delle criptovalute in Australia aumenterà l’adozione delle criptovalute nel paese. Attualmente, le normative sulle criptovalute in Australia sono frammentate in quanto si basano sulle leggi finanziarie esistenti.</p>
<h2 id="h2-FAQ868517"><a name="FAQ" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FAQ</h2><h3 id="h3-Le20criptovalute20sono20regolamentate20dalla20legge20in20Australia396210"><a name="Le criptovalute sono regolamentate dalla legge in Australia?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le criptovalute sono regolamentate dalla legge in Australia?</h3><p>Le criptovalute in Australia sono regolate dalle leggi finanziarie esistenti come la legge antiriciclaggio e finanziamento del terrorismo (AML/CTF) e il regime dei servizi finanziari ai sensi del Corporations Act 2001 (Cth). Tuttavia, il paese non dispone di regolamentazioni specifiche sulle criptovalute.</p>
<h3 id="h3-Quali20sono20le20normative20australiane20per20le20criptovalute369668"><a name="Quali sono le normative australiane per le criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono le normative australiane per le criptovalute?</h3><p>Il <a href="https://www.gate.io/learn/articles/what-is-anti-money-laundering/81" target="_blank">Antiriciclaggio</a> e il finanziamento del terrorismo (AML/CTF), il regime dei servizi finanziari ai sensi del Corporations Act 2001 (Cth), del Competition and Consumer Act 2010 (Cth) e della licenza per i servizi finanziari australiani (AFSL) sono esempi di normative che regolano le criptovalute nel paese.</p>
<h3 id="h3-La20criptovaluta2020legale20in20Australia589409"><a name="La criptovaluta è legale in Australia?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La criptovaluta è legale in Australia?</h3><p>Le criptovalute e altri asset digitali sono legali in Australia. Le criptovalute come BTC e ETH sono classificate come proprietà. Pertanto, i cittadini australiani possono acquistare, vendere e scambiare diverse criptovalute.</p>
<h3 id="h3-Quale20banca20permette20la20criptovaluta20in20Australia492859"><a name="Quale banca permette la criptovaluta in Australia?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quale banca permette la criptovaluta in Australia?</h3><p>CommBank offre servizi correlati alla criptovaluta in Australia. Ad esempio, consente ai singoli individui di acquistare criptovalute utilizzando AUD.</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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>