Tm90aXppZSBxdW90aWRpYW5lIHwgTCdBdXN0cmFsaWEgcmFmZm9yemEgbGEgcmVnb2xhbWVudGF6aW9uZSBkZWxsZSBjcmlwdG92YWx1dGUsIEZlcnJhcmkgYWNjZXR0YSBwYWdhbWVudGkgaW4gY3JpcHRvdmFsdXRlLCBBWFMgZSBBUEUgc2Jsb2NjaGVyYW5ubyBncmFuZGkgcXVhbnRpdMOgIHF1ZXN0YSBzZXR0aW1hbmE=

2023-10-16, 04:51

<p><img src="https://gimg2.gateimg.com/image/article/16974345861016.jpg" alt=""></p>
<h2 id="h2-Riassunto20quotidiano20delle20criptovalute20lAustralia20aumenta20la20regolamentazione20degli20scambi20Ferrari20accetta20pagamenti20in20criptovalute887944"><a name="Riassunto quotidiano delle criptovalute: l’Australia aumenta la regolamentazione degli scambi, Ferrari accetta pagamenti in criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto quotidiano delle criptovalute: l’Australia aumenta la regolamentazione degli scambi, Ferrari accetta pagamenti in criptovalute</h2><p>Il Ministero delle Finanze australiano ha dichiarato in un documento di consultazione dal titolo ‘Piattaforme di asset digitali regolamentati’, pubblicato lunedì, che gli individui che detengono piattaforme di asset digitali superiori a AUD 5 milioni ($3,2 milioni) o AUD 1500 devono ottenere un permesso dalla Commissione Australiana per gli Investimenti e i Titoli (ASIC). Il documento di consultazione propone di regolare le piattaforme di trading di criptovalute ai sensi delle leggi esistenti sui servizi finanziari, anziché sviluppare nuove regole specifiche per le criptovalute.</p>
<p>Il mercato sta dicendo che l’approvazione degli ETF spot è sostanzialmente garantita, dipende da quando viene rilasciato.</p>
<p>La giornalista di Fox Business, Eleanor Terrett, ha dichiarato sulla sua piattaforma di social media che Grayscale ha dichiarato la decisione della SEC statunitense di non presentare appello, affermando: “il termine di 45 giorni per chiedere un nuovo processo ai sensi delle regole federali di procedura d’appello è scaduto. Il tribunale rilascerà l’autorizzazione finale entro 7 giorni. Il team di Grayscale è pronto a convertire GBTC nell’ETF una volta approvato dalla SEC”.</p>
<p>Il tasso di premio negativo attuale del Gray <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il tasso premio negativo del Trust Fund (GBTC) è del 15,88%. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Trust Fund (EETH) è del 25,54%.</p>
<p>Anthony Scaramucci, fondatore di Skybridge Capital, ha recentemente dichiarato in un’intervista che, sebbene la Federal Reserve sembri attualmente funzionare bene, il suo sistema operativo è fondamentalmente collassato.</p>
<p>Anthony Scaramucci ha proposto una soluzione alternativa con una scarsità definita di asset immutabili e, a parte Bitcoin, nessun altro asset ha tali caratteristiche. Crede che <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> stia evolvendo in un mezzo di conservazione del valore più prezioso dell’oro. Ed è previsto che in caso di collasso del sistema finanziario degli Stati Uniti, il valore di mercato di Bitcoin raggiungerà i 15 trilioni di dollari.</p>
<p>Ieri, secondo Reuters, il direttore marketing e commerciale di Ferrari (RACE. MI) ha dichiarato che la sua attività di auto sportive di lusso negli Stati Uniti ha iniziato ad accettare pagamenti in criptovaluta e espanderà il piano in Europa in base alle esigenze dei clienti. Attualmente, la criptovaluta sta lavorando per ridurre la sua impronta di carbonio introducendo nuovi software e aumentando l’uso di energia rinnovabile.</p>
<p>Paolo Ardoino, che sta per diventare <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Cavezza</a> Il CEO di Gate.io ha dichiarato sui social media che il Real World Eco (RWE) di <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> sta per essere lanciato.</p>
<p>Paolo Ardoino ha dichiarato in un’intervista a The Block che, sebbene lo stablecoin USDT di Tether rimanga un prodotto chiave e l’azienda si concentrerà saldamente sulla sua crescita, l’azienda si sta anche espandendo in nuove aree. Tether annuncerà presto una nuova piattaforma che sfrutta l’esperienza di Tether nella costruzione di tecnologia finanziaria e si concentra su asset del mondo reale (RWAs).</p>
<p>Il 16 ottobre, i dati di Token Unlocks hanno mostrato che questa settimana quattro progetti saranno sbloccati una tantum dai token, con un valore totale di rilascio superiore a 87,8 milioni di dollari. Tra questi, AXS e APE sperimenteranno un grande sblocco una tantum:</p>
<p>Alle 0:00 (UTC) del 16 ottobre, <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> sbloccherà 7,29 milioni di FLOW, del valore di circa 3,23 milioni di dollari, pari allo 0,7% dell’offerta circolante;</p>
<p>Alle 0:00 (UTC) del 17 ottobre, <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> sbloccherà 15,6 milioni di APE, del valore approssimativo di $16,6 milioni, pari al 4,23% dell’offerta circolante;</p>
<p>Alle 13:10 (UTC) del 20 ottobre, Axis Infinity sbloccherà 1513 AXS, del valore di circa 64,59 milioni di dollari, pari all’11,5% dell’offerta circolante;</p>
<p>Alle 0:00 (UTC) del 22 ottobre, SPACE ID sbloccherà 18,49 milioni di ID, del valore approssimativo di 3,41 milioni di dollari, pari al 6,46% dell’offerta in circolazione.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi617559"><a name="Tendenze principali dei token di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze principali dei token di oggi</h2><h3 id="h3-BTC141172"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1697434619btc.png" alt=""><br>Nonostante la fine del terzo trimestre, Bitcoin ancora forma un modello testa e spalle. Recentemente ha testato il livello di supporto di $28.000 con un secondo ritracciamento, rimbalzando esattamente dal livello di ritracciamento menzionato della scorsa settimana di $26.510. A breve termine, ci si aspetta un periodo di consolidamento prima di un continuo rimbalzo. Gli obiettivi per questa settimana sono $27.283 e $28.125.</p>
<h3 id="h3-ETH311699"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1697434640ETH.png" alt=""><br>La struttura a medio termine di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> è costantemente ribassista. Coloro che hanno seguito la posizione corta raccomandata al livello di $1,631 hanno ottenuto consistenti profitti. Nel breve termine, è probabile un graduale rimbalzo mentre il mercato più ampio mostra segnali di lenta ripresa. Il continuo calo dei prezzi del gas indica che i chip stanno diluendo la domanda per altre blockchain pubbliche. L’obiettivo a breve termine rimane a $1,631.</p>
<h3 id="h3-BIGTIME520838"><a name="BIGTIME" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BIGTIME</h3><p><img src="https://gimg2.gateimg.com/image/article/1697434659BIGTIME.png" alt=""><br>I punti di ingresso della scorsa settimana a $0,07140 e $0,09350 hanno portato ad un massimo di $0,3450, rappresentando un guadagno sostanziale del 384%. Le strategie a breve termine possono uscire con profitto a questi livelli elevati, mentre le strategie a medio-lungo termine possono continuare a mantenere le posizioni e utilizzare lo stop-loss trailing per garantire i guadagni.</p>
<p>Nel breve termine, è in corso un consolidamento orario del triangolo, con indicazioni di una risoluzione intorno alle prime ore del 17 ottobre (ora solare di Pechino). Il prezzo di supporto a medio termine è stimato a 0,18350$, senza ulteriori cali previsti al di sotto di questo livello. Il volume delle chip si sta riducendo e la possibilità di una seconda ondata di movimenti rialzisti è prevista entro la fine di questo mese.</p>
<p>Stiamo traendo ispirazione da GMT e MANA (poiché GMT è diventato leader nel settore dei giochi blockchain nel 2022 e il fondatore di MANA è anche il CEO di Bigtime). GMT ha raggiunto il suo picco iniziale di 0,8420$ in sole due settimane e successivamente ha ritracciato a 0,598$.</p>
<p>GMT è alla fine salito a $3,1311, segnando un aumento di 311 volte rispetto al prezzo di apertura di $0,01, con una capitalizzazione di mercato di $2 miliardi. Questo stupefacente aumento di 311 volte è avvenuto in soli 23 giorni (durante un periodo di mercato non rialzista).</p>
<p>MANA, d’altra parte, ha mostrato un modello di incrementi graduali e ritracciamenti. Inizialmente è salito da $0.0582 al suo primo obiettivo di $1.5792, segnando un aumento del valore del 2.717% e raggiungendo una capitalizzazione di mercato massima di $9 miliardi, offrendo un ampio margine per la speculazione nel settore del Metaverso.</p>
<p>Confrontando la capitalizzazione di mercato di Bigtime con i valori di picco di GMT e MANA, la capitalizzazione attuale di Bigtime è di soli $40 milioni. In un ambiente di mercato calmo con una concorrenza limitata, c’è un significativo potenziale per Bigtime di raggiungere una bolla di capitalizzazione di mercato che è 50 volte più alta del picco di GMT ($12.25) o addirittura 132 volte più alta del picco di MANA ($32.34).</p>
<p>Nell’industria dei giochi blockchain, indipendentemente dal fatto che segua un modello a doppia moneta o a tripla moneta, non è ancora stato visto un modello di token bilanciato triangolare completamente stabilito. Date le esperienze di GMT e MANA, entrambi dei quali hanno sperimentato bolle significative ai loro massimi, è chiaro che il mercato è maturo per il prendere profitto. Se fossi un market maker oggi, sceglieresti di entrare in un progetto con una capitalizzazione di mercato di $40 milioni, $400 milioni o $4 miliardi?</p>
<h2 id="h2-Macro20Lescalation20del20conflitto20israelopalestinese20potrebbe20avere20un20impatto20maggiore20e20la20Federal20Reserve20ha20completato20il20suo20obiettivo20di20aumento20dei20tassi20di20interesse665283"><a name="Macro: L’escalation del conflitto israelo-palestinese potrebbe avere un impatto maggiore e la Federal Reserve ha completato il suo obiettivo di aumento dei tassi di interesse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: L’escalation del conflitto israelo-palestinese potrebbe avere un impatto maggiore e la Federal Reserve ha completato il suo obiettivo di aumento dei tassi di interesse</h2><p>Il conflitto tra Palestina e Israele ha causato oltre 4.100 morti da entrambe le parti; Le notizie dicono che gli Stati Uniti e Israele stanno discutendo della potenziale visita di Biden in Israele; Il ministro degli Esteri iraniano si è incontrato per la prima volta con i leader di Hamas dalla corrente fase del conflitto israelo-palestinese; L’Iran avverte che se Israele continua le sue azioni a Gaza, dovrà intervenire; Le Forze di Difesa di Israele affermano che l’esercito può operare ovunque in Medio Oriente per la sicurezza di Israele. Il confine di Rafah tra Gaza e l’Egitto si è aperto alle 9 del mattino ora locale; Gli Stati Uniti e l’Iran hanno comunicato attraverso… <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">Segreto</a> canali; Antony Blinken visiterà nuovamente Israele lunedì.</p>
<p>Antony Blinken ha visitato uno per uno i paesi del Medio Oriente, ma è ancora difficile per questi paesi condannare Hamas. Attualmente, il conflitto in Libano è ancora controllabile e Hezbollah occasionalmente lancia missili per dissuadere dalla partecipazione formale alla guerra. Tuttavia, dall’opinione pubblica dei paesi arabi, tutti sostengono la Palestina e dobbiamo stare attenti a ulteriori escalation. Una volta che la guerra nel Medio Oriente si intensifica, avrà inevitabilmente un enorme impatto sul circolo finanziario.</p>
<p>L’aumento repentino dell’oro della scorsa settimana è un esempio. Il prossimo punto per l’oro è tornare a 2000 punti, e il sentiment di avversione al rischio ha esacerbato l’aumento dell’oro. Tuttavia, l’oro non ha guidato l’aumento del Bitcoin, e la ragione è semplice. Il Bitcoin si trova attualmente in una fase di mercato ribassista, e i fondi e gli utenti incrementali hanno bisogno di un punto di scatenante ragionevole, quindi è difficile risalire senza un’ampia quantità di intervento di capitale. Ma se la guerra continua, il terrore e il panico mondiale si diffonderanno, e più persone sicuramente presteranno attenzione al Bitcoin.</p>
<p>La Federal Reserve Huck ha dichiarato che la Federal Reserve potrebbe aver completato l’aumento dei tassi di interesse, sostenendo un periodo più lungo di orientamento ad alti tassi di interesse. La crescita economica rallenterà l’anno prossimo, ma non si prevede una recessione. Dopo il discorso della Fed su Huck, i contratti swap hanno ridotto la probabilità che la Fed aumenti i tassi di interesse quest’anno.</p>
<p>Oltre a Huck, abbiamo notato che ci sono anche segnalazioni che suggeriscono che non ci saranno aumenti dei tassi di interesse. Craig Torres, un giornalista che segue la Federal Reserve su Bloomberg, ha riferito che la Federal Reserve non aumenterà più i tassi di interesse a novembre, ma non annuncerà la fine del ciclo di aumenti dei tassi.</p>
<p>Attualmente, la possibilità di aumentare i tassi di interesse a novembre è molto bassa, ma non ci interessa se aumentarli. Questo è stato menzionato più volte, ma non è importante per noi. Quello a cui dobbiamo prestare attenzione è quando abbassare i tassi di interesse l’anno prossimo.</p>
<p>Secondo i dati dell’osservazione della Federal Reserve del CME, la probabilità che la Federal Reserve mantenga invariati i tassi di interesse al 5,25% -5,50% a novembre è del 93,8%, mentre la probabilità di aumentare i tassi di interesse di 25 punti base al 5,50% -5,75% è del 6,2%.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<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. Sarà consentito ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>