Tm90aXppZSBxdW90aWRpYW5lIHwgSEsgaW50ZW5kZSByaWxhc2NpYXJlIHJlZ29sYW1lbnRpIHN1bGxlIHN0YWJsZWNvaW4gbCdhbm5vIHByb3NzaW1vLCBNYWtlckRBTyBoYSBudW92YW1lbnRlIGF1bWVudGF0byBsZSBwcm9wcmllIHBhcnRlY2lwYXppb25pIG5lZ2xpIGFzc2V0IFJXQSwgaWwgdm9sdW1lIGRpIHRyYWRpbmcgT1RDIGR

2023-09-21, 05:22

<p><img src="https://gimg2.gateimg.com/image/article/16952744230921.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Lapplicazione20di20pagamento20Venmo20lancer20la20stablecoin20PYUSD20Hong20Kong20ha20pianificato20di20rilasciare20normative20sulle20stablecoin20nel20202467028"><a name="Crypto Daily Digest: L’applicazione di pagamento Venmo lancerà la stablecoin PYUSD; Hong Kong ha pianificato di rilasciare normative sulle stablecoin nel 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: L’applicazione di pagamento Venmo lancerà la stablecoin PYUSD; Hong Kong ha pianificato di rilasciare normative sulle stablecoin nel 2024</h2><p>Secondo The Block, la piattaforma di pagamento di PayPal Venmo fornirà presto la stablecoin PYUSD di PayPal in dollari americani. PayPal ha dichiarato in un comunicato stampa che PYUSD verrà lanciato nelle ‘prossime settimane’. Gli utenti potranno acquistare e inviare PYUSD tramite PayPal, Venmo o portafogli esterni compatibili.</p>
<p>Venmo è una controllata di PayPal e ha iniziato a fornire servizi di acquisto di criptovalute nel 2021. Il 7 agosto, PayPal e la società di infrastrutture crittografiche Paxos hanno lanciato PYUSD, che è completamente supportato da depositi in dollari statunitensi, obbligazioni del tesoro a breve termine e equivalenti in contanti simili. In seguito, PayPal ha aggiunto un servizio di scambio di criptovalute per dollari statunitensi, consentendo agli utenti di scambiare valute digitali con dollari statunitensi a partire dall’11 settembre.</p>
<p>Il fondatore di DefiLlama 0xngmi ha lanciato un avvertimento sulla piattaforma X, affermando: “Attualmente, friend.tech e tutte le sue versioni fork memorizzano le chiavi degli utenti nel front-end, quindi l’aggiornamento tramite il front-end potrebbe rubare le chiavi degli utenti o tutti i fondi. Alcune persone potrebbero non memorizzare le chiavi complete nel front-end, ma hanno le chiavi nella memoria del front-end, quindi sono vulnerabili ad attacchi di approvvigionamento in ogni caso.”</p>
<p>Il legislatore di Hong Kong Duncan Chiu ha dichiarato oggi che Hong Kong sta attualmente conducendo la seconda fase di consultazione sulle linee guida per l’emissione di stablecoin. Ha espresso in un forum a Shanghai che spera che Hong Kong possa pubblicare le regole normative per gli emittenti di stablecoin entro la metà dell’anno prossimo.</p>
<p>Secondo i dati di Makerburn, MakerDAO ha aggiunto 191 milioni di dollari in asset RWA negli ultimi due giorni attraverso Monetalis Clydesdale e BlockTower Andromeda. Tra questi, Monetalis Clydesdale ha aumentato le attività RWA di 97 milioni di dollari e BlockTower Andromeda ha aumentato le attività RWA di 94 milioni di dollari. Inoltre, il patrimonio totale dell’attuale RWA dell’accordo supera i 2,9 miliardi di dollari.</p>
<p>In una dichiarazione, l’Agenzia Fiscale Nazionale della Corea del Sud ha affermato che in seguito all’esigenza della Corea del Sud di segnalare gli asset crittografici all’estero quest’anno, il valore totale degli asset crittografici all’estero dichiarati dai contribuenti quest’anno è di 130,8 trilioni di won (98,5 miliardi di dollari). Un totale di 1432 individui e aziende ha segnalato i propri asset crittografici all’estero. Le autorità fiscali hanno dichiarato che le detenzioni di criptovalute all’estero segnalate dai contribuenti coreani rappresentano il 70,2% del totale degli asset esteri segnalati.</p>
<p>Il paese richiede ai cittadini sudcoreani con attività (incluse criptovalute) superiori a 500 milioni di won (circa 378.000 dollari) sui conti esteri di dichiarare le proprie detenzioni.</p>
<p>In termini di dati, secondo BTC.com, la difficoltà di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il mining è stato regolato intorno alle 17:00 di ieri (a quota blocco di 808416), con un aumento del 5.48% a 57.12T, stabilendo un nuovo massimo storico. Attualmente, la potenza di calcolo media dell’intera rete è di 419.19 EH/s.</p>
<p>Secondo i dati di Glassnode, il portafoglio dell’OTC desk ha registrato una media di soli 11 trasferimenti giornalieri negli ultimi 30 giorni. Equivalente a un volume di scambi annuo di 4015 transazioni. La società madre dell’emittente ETF 21Shares e il direttore delle ricerche della società di prodotti di investimento in criptovalute 21co, @elindinga, hanno affermato che l’ultima volta che si è verificato un livello così basso è stato nel novembre 2018 e l’attuale mercato non sembra aver avviato una fase di raccolta fondi su larga scala.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi646888"><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-BTC305242"><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/1695274458BTC.png" alt=""><br>Il grafico a quattro ore mostra un volume in diminuzione nella parte inferiore, indicando la possibilità di una formazione al top nel breve termine. Nel breve termine, potrebbe esserci un retest del livello di supporto di $26.510. La strategia di medio termine dovrebbe mantenere la stabilità all’interno dell’attuale intervallo di prezzo, mentre nel lungo termine si prevede ancora un significativo ribasso prima del secondo trimestre del 2024.</p>
<h3 id="h3-MKR685879"><a name="MKR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MKR</h3><p><img src="https://gimg2.gateimg.com/image/article/1695274477MKR.png" alt=""><br>Nell’ultimo anno, la tendenza di MKR è stata impressionante. Inoltre, si è formato un grande pattern rialzista a testa e spalle invertito nel lungo termine. Dopo aver superato il trend generale al ribasso all’inizio di questo mese, MKR ha di nuovo iniziato un movimento verso l’alto. Nel breve termine, ha incontrato resistenza a $1.371 USD, il livello più alto dell’ultimo anno. Nel breve termine, si suggerisce una strategia di breakout, con obiettivi successivi a $1.577 USD, $1.703 USD, $1.805 USD e $1.905 USD.</p>
<h3 id="h3-ARK290044"><a name="ARK" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ARK</h3><p><img src="https://gimg2.gateimg.com/image/article/1695274503ARKB.png" alt=""><br>Nella settimana scorsa, ARK ha registrato un aumento graduale del volume inferiore e i suoi trend giornalieri seguono da vicino quelli di HIFI. Purtroppo, l’apertura dei mercati dei contratti su varie borse rappresenta un ostacolo significativo per ulteriori trend individuali al rialzo. Nel breve termine, è consigliabile mantenere la stabilità a $0.5899 USD.</p>
<h2 id="h2-Macro20Le20aspettative20per20i20tagli20dei20tassi20di20interesse20lanno20prossimo20saranno20ridotte20e20Powell20ha20dichiarato20che20non20rinuncer20alla20possibilit20di20aumentare20i20tassi20di20interesse834553"><a name="Macro: Le aspettative per i tagli dei tassi di interesse l’anno prossimo saranno ridotte, e Powell ha dichiarato che non rinuncerà alla possibilità di aumentare i tassi di interesse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Le aspettative per i tagli dei tassi di interesse l’anno prossimo saranno ridotte, e Powell ha dichiarato che non rinuncerà alla possibilità di aumentare i tassi di interesse</h2><p>Alle 2:00 del mattino, ora di Pechino, giovedì, la Federal Reserve ha annunciato che manterrà invariato il suo tasso di interesse di riferimento nell’intervallo del 5,25-5,5%. Sebbene ciò sia in linea con le aspettative, è stata anche una sorpresa per il mercato. Come ho detto in precedenza, dovremmo essere più preoccupati dei tagli attesi dei tassi piuttosto che se ci saranno ulteriori aumenti dei tassi. Ieri sera ero particolarmente interessato alla matrice dei punti della Federal Reserve:</p>
<p>In primo luogo, il rapporto di voto: 12 su 19 funzionari sono inclini ad aumentare nuovamente i tassi di interesse entro l’anno, e il numero di persone che sostengono ulteriori aumenti dei tassi ha superato molte aspettative (che è un buon divario per Powell). Goldman Sachs ritiene che siano 10 persone;</p>
<p>In secondo luogo, le aspettative per il taglio dei tassi di interesse dell’anno prossimo: la stima mediana mostra che attualmente i funzionari della Federal Reserve si aspettano che il tasso dei fondi federali scenda al 5,1% entro la fine del 2024, superiore al 4,6% previsto a giugno. Che concetto è questo?</p>
<p>A giugno di quest’anno, il tasso di interesse previsto entro la fine del 2024 è del 4,6%, e l’aspettativa del mercato per i tassi di interesse massimi è di circa il 5,5%. Ciò significa che ci saranno quasi 100 punti base di tagli ai tassi di interesse. Seguendo l’abitudine di ridurre i tassi di interesse di 25 punti base ogni volta, equivale a quattro tagli ai tassi di interesse l’anno prossimo; questa volta, i funzionari della Federal Reserve hanno aumentato il tasso di interesse alla fine del 2024 al 5,1%, il che significa che si aspettano solo un taglio dei tassi di interesse di circa 40 punti base l’anno prossimo, equivalente ad aspettarsi solo due tagli dei tassi di interesse l’anno prossimo.</p>
<p>Questo è veramente scioccante per il mercato. Wall Street era originariamente preparata per la Federal Reserve per tagliare i tassi di interesse una volta, ma chi avrebbe pensato a una tale magnitudine? Dopo la pubblicazione del grafico a matrice di punti, i trader hanno rapidamente dato un feedback che i contratti di swap sui tassi di interesse riflettevano una diminuzione della probabilità di tagli dei tassi di interesse nel 2024, con il primo taglio dei tassi previsto per settembre 2024, anziché il precedente luglio. Tuttavia, il mercato si aspetta ancora una piccola possibilità di ulteriori rialzi dei tassi di interesse, con una probabilità del 29% a novembre.</p>
<p>Il presidente della Federal Reserve, Powell, ha dichiarato: “La Federal Reserve si aspetta che il nucleo PCE aumenti del 3,9% anno su anno ad agosto; dato il progresso che abbiamo fatto, il FOMC ha deciso di mantenere invariati i tassi di interesse. Prenderemo decisioni su base riunione per riunione e, se appropriato, ci prepareremo ad aumentare ulteriormente i tassi di interesse. Mantenere i tassi di interesse invariati non significa che abbiamo raggiunto la posizione restrittiva che cerchiamo. La Federal Reserve non ha deciso se i tassi di interesse sono sufficientemente restrittivi.”</p>
<p>Complessivamente, la Federal Reserve ha suggerito di mantenere invariati i tassi di interesse, ma ha avvertito che potrebbero esserci ulteriori rialzi dei tassi di interesse in futuro. In modo inaspettato ha significativamente ridotto le aspettative per il taglio dei tassi di interesse del prossimo anno. Il mercato è perlopiù insoddisfatto di queste informazioni. PIMCO ha dato una visione diversa e la loro logica principale è che se il prossimo disegno di legge di spesa non verrà risolto, non ci sarà alcuna possibilità di aumentare i tassi di interesse a novembre.</p>
<p>A meno di due settimane dal 30 settembre, il Congresso degli Stati Uniti sta ancora faticando a raggiungere un consenso su un disegno di legge di spesa a breve termine. Dopo le trattative sul tetto del debito all’inizio di giugno, Capitol Hill si è nuovamente trovato di fronte a un confronto diretto tra i partiti repubblicano e democratico. Attualmente sono in discussione diversi piani di bilancio al Congresso degli Stati Uniti, ma nessuno può essere votato in entrambe le camere del Congresso.</p>
<p>Nel suo ultimo rapporto, PIMCO ha dichiarato che è “probabile” che il governo degli Stati Uniti avvii uno shutdown completo e a lungo termine alla fine del mese, portando in ultima analisi la Federal Reserve ad abbandonare l’aumento dei tassi di interesse a novembre. “Data la forte posizione dei repubblicani della Camera, se il governo chiude, potrebbe essere difficile creare rapidamente un catalizzatore per la riapertura”.</p>
<p>I dati mostrano che il più lungo shutdown governativo complessivo nella storia degli Stati Uniti si è verificato nel 2013, durando 16 giorni e portando a una diminuzione dello 0,6% nel suo prodotto interno lordo (PIL). Molte istituzioni hanno fornito previsioni specifiche sull’impatto della sospensione. Dakota, economista capo di Ernst &amp; Young, ha affermato che la crisi lascerà un segno chiaro sull’economia. Stima che causerà perdite per 6 miliardi di dollari all’economia statunitense ogni settimana e ridurrà la crescita del PIL dello 0,1% nel quarto trimestre. Goldman Sachs stima che ogni settimana di chiusura del governo provocherà una diminuzione dello 0,2% nell’economia statunitense.</p>
<p>Libby Cantrill, Direttore della Politica Pubblica presso PIMCO, ha affermato: ‘La saggezza tradizionale al Congresso suggerisce che il blocco del governo è solo questione di tempo, non se sia un problema. La nostra preoccupazione è quanto durerà il blocco del governo. Data la complessa divisione all’interno del Partito Repubblicano nell’attuale Camera dei Rappresentanti, una volta che il governo si chiude, potrebbe non esserci un catalizzatore per la sua riapertura’. Vale la pena notare che un blocco del governo ritarderà la raccolta e la pubblicazione di una grande quantità di dati di mercato chiave, inclusi il PIL, il tasso di disoccupazione e i dati sull’inflazione, che metteranno alla prova la capacità della Federal Reserve di valutare la forza economica.</p>
<p>In breve, le imminenti trattative tra le due parti sul disegno di legge di spesa a breve termine diventeranno il focus dell’attenzione di mercato. Se questo disegno di legge non passa, influenzerà inevitabilmente il ciclo di rialzo dei tassi di interesse di novembre. Pertanto, dobbiamo mantenere la nostra attenzione. Non possiamo ascoltare ciò che la Federal Reserve dice attualmente, e dobbiamo anche vedere i risultati e le aspettative delle trattative congressuali e cosa hanno fatto.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore di Gate.io<br><div>Traduttore:Gioia Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo i punti di vista del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga fatto 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>