Tm90aXppYSBxdW90aWRpYW5hIHwgSWwgdGVhbSBkaSAxaW5jaCBoYSBhY3F1aXN0YXRvIDYwODcsNyBFVEggYSB1biBwcmV6em8gbWVkaW8gZGkgJDEuNjU1OyBMZSBjb21taXNzaW9uaSBkaSB0cmFkaW5nIGRpIEV0aGVyZXVtIGhhbm5vIHJhZ2dpdW50byB1biBtaW5pbW8gZGkgOCBtZXNpLCBsYSBGZWQgw6ggYWNjdXNhdGEgZGkgb3N

2023-08-29, 03:45

<p><img src="https://gimg2.gateimg.com/image/article/16932874630829.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest2020201inch2020Il20team20ha20acquistato206087720ETH20ad20un20prezzo20medio20di201655202020Ethereum2020le20commissioni20di20negoziazione20hanno20raggiunto20il20minimo20degli20ultimi20820mesi20BlackRock20era20il20secondo20azionista20pi20grande20delle20prime20cinque20aziende20minerarie20in20termini20di20capitalizzazione20di20mercato919895"><a name="Crypto Daily Digest:   1inch  Il team ha acquistato 6.087,7 ETH ad un prezzo medio di $1.655;   Ethereum  le commissioni di negoziazione hanno raggiunto il minimo degli ultimi 8 mesi, BlackRock era il secondo azionista più grande delle prime cinque aziende minerarie in termini di capitalizzazione di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a> Il team ha acquistato 6.087,7 ETH ad un prezzo medio di $1.655; <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> le commissioni di negoziazione hanno raggiunto il minimo degli ultimi 8 mesi, BlackRock era il secondo azionista più grande delle prime cinque aziende minerarie in termini di capitalizzazione di mercato</h2><p>Ieri mattina, Terry Gou, fondatore di Hon Hai Technology Group (Foxconn), che in precedenza aveva chiesto lo sviluppo della blockchain a Taiwan, ha tenuto una “Mainstream Public Opinion Alliance Press Conference” presso la Zhang Rongfa Foundation di Taipei, annunciando ufficialmente la sua candidatura alla leadership di Taiwan nel 2024.</p>
<p>Terry Gou una volta ha affermato di voler trasformare Taiwan in un’isola sperimentale per la tecnologia dell’IA e ha usato il piano di pagamento di Facebook Libra come esempio per introdurre le finanze blockchain a Taiwan. Ha anche menzionato che il concetto di metaverso richiederà 5-10 anni per essere implementato e ha sottolineato che il mercato delle valute virtuali è variegato e ancora altamente speculativo.</p>
<p>Ieri, Crypto KOL - The ₿itcoin Therapist ha pubblicato su Twitter che BlackRock è il secondo azionista di quattro delle prime cinque società minerarie per valore di mercato, Riot Blockchain, Marathon Digital Holdings, Cipher Mining e TeraWulf.</p>
<p>Secondo @EmberCN monitoraggio, il <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a> L’indirizzo del team (etichettato come 1inch: Raccolta del Fondo di Investimento del Team) ha acquistato 6.087,7 ETH il 28 agosto utilizzando 10 milioni di USDT e 70.000 USDC (circa 10,07 milioni di dollari), con un prezzo medio di acquisto di $1.655.</p>
<p>In precedenza, è stato segnalato che il 5 luglio il team di <a href="/price/1inch-1inch" target="_blank" class="blog_inner_link">1inch</a> ha venduto circa 11.000 ETH, convertendoli in WETH e scambiandoli con DAI in diverse transazioni. Successivamente, Sergej Kunz, co-fondatore di 1inch, ha dichiarato che la ragione per la vendita anticipata di 11.000 ETH era che il team stava testando nuove funzionalità in modalità Fusion.</p>
<p>Recentemente, l’incidente del PEPE che è stato schiacciato ha anche suscitato scalpore.</p>
<p>Ieri, il fondatore del segnalatore PAULY ha pubblicato su Twitter che il team PEPE aveva precedentemente rubato oltre 10 milioni di dollari di fondi dal portafoglio di CEX e li aveva venduti sul mercato pubblico. Ora hanno trasferito i restanti 9,6 milioni di dollari in un portafoglio controllato da una persona anonima di 25 anni. Avevano già organizzato molte ordini brevi per il trading interno prima di rubare i fondi di CEX. Le loro violazioni di manipolazione di mercato e insider trading continuano.</p>
<p>In termini di dati, secondo i dati pubblicati dalla piattaforma di dati di rischio DeTrust di Bitrace, oltre 115 miliardi di USDT sono affluiti in alcuni indirizzi delle piattaforme del Sud-est asiatico nel 2022, principalmente includendo 37,16 miliardi di dollari di fondi per il gioco d’azzardo online e 69,78 miliardi di dollari di fondi per il riciclaggio di denaro, con circa 460 milioni di USDT fraudolenti coinvolti.</p>
<p>La piattaforma SocialFi di recente popolarità, friend.tech, ha generato solo $160.000 in commissioni di protocollo nelle ultime 24 ore. È sceso significativamente dal suo picco ed è molto indietro rispetto ai noti protocolli DeFi come Lido, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, e MakerDAO.</p>
<p>Al contrario, il protocollo può generare fino a $1,12 milioni di commissioni di protocollo entro 24 ore del suo picco, e la cifra attuale è inferiore al 20% del suo picco.</p>
<p>Il mercato degli NFT continua ad essere lento e, secondo i dati di Dune, il volume di scambi del mercato degli NFT nella scorsa settimana è stato solo di $8,91 milioni, raggiungendo un nuovo minimo in due anni.</p>
<p>Secondo i dati di CryptoQuant, la commissione giornaliera pagata dagli utenti per eseguire scambi su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il 27 agosto è stato di 1.719 ETH, il punto più basso dal 26 dicembre dell’anno scorso e una diminuzione dell’89% rispetto al massimo annuale di 16.720 ETH il 5 maggio. La diminuzione delle commissioni di pagamento totali indica un basso utilizzo della rete, possibilmente a causa della crescente popolarità delle soluzioni di scalabilità L2, un sviluppo positivo a lungo termine per Ethereum.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi296759"><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-BTC657924"><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/1693280667BTC 0829.png" alt=""><br>Il grafico a 4 ore mostra una stretta consolidazione e oscillazione. Oggi il focus dovrebbe essere se viene superato il livello di resistenza di $26.510, il che potrebbe formare un pattern di doppio fondo. Il supporto inferiore si trova a $25.606, mentre la linea di difesa principale rimane a $24.226.</p>
<h3 id="h3-SEI769960"><a name="SEI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEI</h3><p><img src="https://gimg2.gateimg.com/image/article/1693280678SEI 0829.png" alt=""><br>Ci sono segni di un fondo a breve termine, e la linea del collo cruciale è formata precisamente a $0.1290 USD. Sul grafico orario è emerso un potenziale pattern a testa e spalle rovesciato, consentendo una strategia di rimbalzo a breve termine di circa $0.13 USD. Gli obiettivi a breve termine sono $0.1395 USD e $0.1433 USD - rapidi ingressi ed uscite.</p>
<h3 id="h3-DOGE120466"><a name="DOGE" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DOGE</h3><p><img src="https://gimg2.gateimg.com/image/article/1693280695DOGE 0829.png" alt=""><br>Il grafico giornaliero complessivo è stato in trend ribassista per 835 giorni, probabilmente in fase di preparazione per un’azione significativa dei prezzi prima della fine dell’anno. Il prezzo di base si attesta a $0.05099 USD. Nel caso di un rally indipendente, gli obiettivi sequenziali sono $0.10799 USD, $0.15879 USD, $0.43360 USD e un nuovo massimo storico.</p>
<h2 id="h2-Macro20azioni20USA20guidano20il20mercato202020ottimismo2020con20la20Camera20che20condanna20la20Federal20Reserve20per20ostacolare20il20pagamento20della20legislazione20sulle20stablecoin913684"><a name="Macro: azioni USA guidano il mercato   ottimismo , con la Camera che condanna la Federal Reserve per ostacolare il pagamento della legislazione sulle stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: azioni USA guidano il mercato <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">ottimismo</a>, con la Camera che condanna la Federal Reserve per ostacolare il pagamento della legislazione sulle stablecoin</h2><p>Il mercato azionario statunitense è salito su tutta la linea e <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> nella regione Asia-Pacifico permeata da Europa e Stati Uniti. L’indice Dow Jones ha chiuso in rialzo dello 0,62%, l’indice S&amp;P 500 è salito dello 0,63% e l’indice Nasdaq è salito dell’0,84%; I prezzi dell’oro sono saliti dello 0,3% a $1920; I titoli di stato statunitensi sono saliti e il rendimento dei titoli di stato a due anni è diminuito di 4,1 punti base a 5,0371%; Il rendimento dei titoli di stato a 10 anni è diminuito di 3,7 punti base a 4,198%;</p>
<p>Il lunedì, il mercato ha continuato a elaborare il discorso di Powell della settimana scorsa, scommettendo che la probabilità di un rialzo dei tassi di 25 punti base a novembre aumentasse dal 33% della settimana scorsa al 51%, e stavano scommettendo che i tassi di interesse rimanessero alti per un certo periodo di tempo.</p>
<p>I trader prevedono che la probabilità che la Federal Reserve riduca i tassi di interesse dai livelli attuali entro giugno 2024 sia del 58%, inferiore al 62% di venerdì scorso e all’83% di una settimana fa. L’aumento dei tassi di interesse potrebbe essere un segnale preoccupante per il mercato azionario.</p>
<p>In attesa di una serie di pesanti dati questa settimana, il punto di rischio principale per questa settimana inizierà dal giovedì, quando verranno pubblicati gli indicatori di inflazione preferiti dalla Federal Reserve, l’indice dei prezzi PCE core di luglio e il rapporto sull’occupazione non agricola. Rafforzeranno o indeboliranno i due pilastri del rimbalzo, ossia l’atterraggio morbido e il ritiro dell’inflazione. Si prevede che sia i dati ADP degli Stati Uniti che i dati non agricoli diminuiranno rispetto ai valori precedenti.</p>
<p>D’altra parte, in una lettera al presidente della Federal Reserve Powell del 28 agosto, il presidente del Comitato per i servizi finanziari della Camera dei rappresentanti degli Stati Uniti, McHenry, ha dichiarato che le recenti lettere di supervisione e regolamentazione della Federal Reserve (SR 23-7 e SR 23-8) hanno minato i progressi compiuti dal Congresso nella legislazione per istituire un quadro normativo per le stablecoin di pagamento e senza dubbio impediranno alle istituzioni finanziarie di partecipare all’ecosistema degli asset digitali.</p>
<p>Il congressista Patrick French Hill e Bill Huizeng hanno scritto nelle loro lettere: “La Federal Reserve impedisce alle banche di emettere stablecoin di pagamento o di partecipare all’ecosistema dei stablecoin di pagamento mediante l’emissione di queste lettere regolamentari. Il quadro regolamentare stabilito dal Congresso proteggerà meglio i consumatori e garantirà certezza per i partecipanti al mercato, il che ha portato all’introduzione del Clarity for Payment Stablecoins Act. Tuttavia, meno di due settimane dopo, la Federal Reserve ha rilasciato SR 23-7 e SR 23-8 senza collaborare con il Congresso per stabilire un meccanismo fattibile.”</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à consentita la ripubblicazione dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>