Tm90aXppZSBnaW9ybmFsaWVyZSB8IFBheVBhbCBoYSBsYW5jaWF0byB1biBzdGFibGVjb2luIGluIGRvbGxhcmkgVVNBIFBZVVNELCBsJ0F1dG9yaXTDoCBtb25ldGFyaWEgZGkgU2luZ2Fwb3JlIHN1cHBvcnRhIGwnaW5ub3ZhemlvbmUgbmVsbCdpbmR1c3RyaWEgV2ViMzsgbGEgdm9sYXRpbGl0w6AgZGVsIEJUQyDDqCBzY2VzYSBhaSB

2023-08-08, 03:41

<p><img src="https://gimg2.gateimg.com/image/article/16914730690808.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20LAutorit20Monetaria20di20Singapore20ha20investito2011020milioni20in20innovazione20in20settori20come20Web203020e20PayPal20ha20lanciato20un20stablecoin20in20dollari20statunitensi20PYUSD752635"><a name="Crypto Daily Digest: L’Autorità Monetaria di Singapore ha investito $110 milioni in innovazione in settori come Web 3.0, e PayPal ha lanciato un stablecoin in dollari statunitensi PYUSD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: L’Autorità Monetaria di Singapore ha investito $110 milioni in innovazione in settori come Web 3.0, e PayPal ha lanciato un stablecoin in dollari statunitensi PYUSD</h2><p>Ieri, l’Autorità monetaria di Singapore ha promesso di fornire fino a S $ 150 milioni per la tecnologia e l’innovazione nel settore finanziario, inclusa la Web 3.0. Secondo il Nuovo Piano per la Tecnologia e l’Innovazione del Settore Finanziario (FSTI 3.0) dell’Autorità monetaria di Singapore (MAS), saranno investiti fino a S $ 150 milioni (circa $ 110 milioni) entro tre anni.</p>
<p>FSTI 3.0 mira ad accelerare e rafforzare l’innovazione supportando progetti che utilizzano tecnologie all’avanguardia o connessioni regionali, raddoppiando nel contempo l’impegno della MAS nel promuovere un ecosistema tecnologico vibrante per il settore finanziario.</p>
<p>Secondo Bloomberg, PayPal (PYPL.O) ha lanciato un stablecoin in dollari statunitensi per trasferimenti e pagamenti. Paxos Trust Co. emette PayPal USD (PYUSD) che è completamente supportato da depositi in dollari statunitensi, obbligazioni del tesoro a breve termine e equivalenti di cassa simili. È ancorato al dollaro statunitense e verrà gradualmente aperto ai clienti di PayPal negli Stati Uniti. Questo token può anche essere trasferito a portafogli di terze parti compatibili al di fuori della rete PayPal.</p>
<p>PYUSD è progettato per essere facilmente convertibile in dollari statunitensi e altre criptovalute disponibili sulla rete PayPal. Può essere utilizzato per finanziare acquisti e presto sarà disponibile sull’applicazione di pagamento popolare di PayPal, Venmo. Gli utenti saranno in grado di inviare eventualmente i loro token tra i portafogli PayPal e Venmo. PayPal ha dichiarato che a partire da settembre, Paxos rilascerà rapporti mensili dettagliando gli asset che supportano PYUSD. Paxos rilascerà anche la certificazione di terze parti da parte di società di revisione per gli asset di riserva di PYUSD.</p>
<p>Ieri, il BitVol ( <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L’indice di volatilità, lanciato dalla società di indici finanziari T3 Index in collaborazione con la piattaforma di trading di opzioni <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> LedgerX, è sceso a 37,08, un minimo storico dell’0,96% rispetto al 5 agosto.</p>
<p>L’indice BitVol misura la volatilità implicita attesa di 30 giorni derivata dai prezzi delle opzioni Bitcoin negoziabili. La volatilità implicita si riferisce alla volatilità implicita dal prezzo effettivo dell’opzione. Utilizza la formula di pricing delle opzioni B-S per calcolare il prezzo effettivo dell’opzione e dividerlo per la volatilità σ - la volatilità derivata sostituendo altri parametri nella formula.</p>
<p>Il prezzo effettivo delle opzioni è formato dalla competizione tra numerosi operatori di opzioni, quindi, la volatilità implicita rappresenta le opinioni e le aspettative dei partecipanti al mercato sul futuro del mercato ed è considerata la più vicina alla vera volatilità in quel momento.</p>
<p>Bitcoin ha raggiunto una volatilità che si è ridotta ai minimi storici, dimostrando che la fase attuale è il periodo più tranquillo nel mercato dal marzo 2020. Inoltre, storicamente, una tale bassa volatilità è coerente con la fase di riaccumulazione dopo un mercato ribassista.</p>
<p>Secondo l’ultimo rapporto settimanale di CoinShares, l’uscita totale di fondi dai prodotti di investimento in asset digitali della scorsa settimana è stata di 107,4 milioni di dollari. L’uscita netta di Bitcoin ha raggiunto i 111,4 milioni di dollari, la più grande uscita settimanale dal marzo. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> i prodotti di investimento hanno un deflusso netto di $5.9 milioni. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Gli investimenti di Gate.io hanno registrato un afflusso netto di 9,5 milioni di dollari, raggiungendo un nuovo record di afflussi netti in una singola settimana dal marzo 2022. Il volume settimanale di trading dei prodotti di investimento è inferiore del 36% rispetto alla media anno-to-date, ma è più influenzato dal volume di trading su un mercato di scambio più ampio, che è inferiore del 62% rispetto alla media anno-to-date.</p>
<p>Dal punto di vista regionale, l’uscita di fondi è principalmente concentrata in due fornitori di ETP in Germania e Canada, con uscite rispettivamente di $71 milioni e $29 milioni.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi815536"><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-BTC938426"><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/1691473101BTC.png" alt=""><br>Continuando a convergere al terminale, in attesa di un punto di svolta per la decisione direzionale. Strategia di ingresso aggressiva lunga: $28.550 USD; Strategia di ingresso aggressiva corta: $27.950 USD, con una visione continua verso il livello di $26,5K USD.</p>
<h3 id="h3-UNIBOT961852"><a name="UNIBOT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>UNIBOT</h3><p><img src="https://gimg2.gateimg.com/image/article/1691473119UNIBOT.png" alt=""><br>Il grafico a 4 ore mostra un modello di convergenza verso l’alto, superando brevemente la chiave di collo a $157.56 USD. Si consiglia attenzione a breve termine, la strategia long conservativa consiglia di attendere una rottura dell’alta precedente, puntando successivamente a $213.81 USD, $290.16 USD e $335.56 USD.</p>
<h3 id="h3-YGG876837"><a name="YGG" class="reference-link"></a><span class="header-link octicon octicon-link"></span>YGG</h3><p><img src="https://gimg2.gateimg.com/image/article/1691473142YGG.png" alt=""><br>Il target giornaliero di $0.97786 USD è stato raggiunto ieri, seguito da un significativo ritracciamento al livello di $0.33290 USD, coinvolgendo 7 market maker. La dinamica di mercato suggerisce una partecipazione attiva nel mercato dei contratti, raccomandando di prendere profitto per coloro che hanno guadagnato nel breve termine.</p>
<h2 id="h2-Macro20Misto20di20falco20e20colombo20la20probabilit20che20la20Fed20aumenti20i20tassi20di20interesse20a20settembre2020ancora20molto20bassa57902"><a name="Macro: Misto di falco e colombo, la probabilità che la Fed aumenti i tassi di interesse a settembre è ancora molto bassa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Misto di falco e colombo, la probabilità che la Fed aumenti i tassi di interesse a settembre è ancora molto bassa</h2><p>Washington sta preparando un nuovo scontro fiscale che potrebbe complicare la formulazione delle politiche della Fed e rafforzare l’avvertimento di Fitch che il danno causato dagli Stati Uniti stessi sta danneggiando la sua posizione nell’economia globale.</p>
<p>Il Congresso degli Stati Uniti ha chiuso i battenti ad agosto senza risolvere l’escalation del conflitto sulle spese e sulle questioni sociali scottanti, aumentando il rischio di una chiusura del governo a causa dell’esaurimento dei fondi federali dopo il 30 settembre. Questo è l’ultimo caso di “brinkmanship” nel bilancio degli Stati Uniti. Eventi simili continuano a svolgersi, portando Fitch ad annullare la valutazione AAA dei titoli di Stato statunitensi la scorsa settimana. Questa decisione storica ha fatto disperare Wall Street e Washington.</p>
<p>D’altra parte, i presidenti della Fed sono in parte falchi e in parte colombi, infiltrando attivamente informazioni nel mercato. Attualmente, abbiamo ripetutamente sottolineato la probabilità di un rialzo dei tassi a settembre, ma in termini di sentiment di mercato, la probabilità di un rialzo dei tassi è quasi zero.</p>
<p>Quindi non dobbiamo più preoccuparci dell’impatto dei continui aumenti dei tassi di interesse a settembre sul mercato. Diamo un’occhiata a cosa hanno detto i presidenti della Fed.</p>
<p>Il presidente della Fed di New York, John Williams, ha dichiarato che si prevede una diminuzione dei tassi di interesse con l’inflazione e non si esclude la possibilità di abbassare i tassi di interesse all’inizio del 2024, ma i dettagli dipendono dai dati economici. Si prevede che il tasso di disoccupazione salirà oltre il 4% l’anno prossimo.</p>
<p>La governatrice della Fed Michelle W. Bowman ha continuato ad essere “falco”, affermando che saranno necessari ulteriori rialzi dei tassi di interesse per ridurre l’inflazione ai livelli desiderati. Nella presa di decisioni, si cercheranno prove di una diminuzione sostenuta e significativa dell’inflazione.</p>
<p>Il presidente della Federal Reserve di Atlanta, Raphael Bostic, ha dichiarato che non c’è bisogno di aumentare nuovamente i tassi di interesse a settembre e non c’è bisogno di abbassare i tassi prima del secondo semestre dell’anno prossimo.</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 sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>