Tm90aXppZSBxdW90aWRpYW5lIHwgTXVzayBhZmZlcm1hIGNoZSBYIG5vbiBsYW5jZXLDoCBtYWkgY3JpcHRvdmFsdXRlLCB2dWxuZXJhYmlsaXTDoCBkZWwgY29tcGlsYXRvcmUgRXRoZXJldW0gVnlwZXIgcmlzb2x0YSwgdG9rZW4gQVBUIGUgSU1YIHNhcmFubm8gc2Jsb2NjYXRpIGluIGdyYW5kaSBxdWFudGl0w6AgcXVlc3RhIHNldHR

2023-08-07, 04:20

<p><img src="https://gimg2.gateimg.com/image/article/16913880130807.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Musk20afferma20che20X20non20lancer20mai20criptovalute20i20token20APT20e20IMX20verranno20sbloccati20in20grandi20quantit20questa20settimana900251"><a name="Crypto Daily Digest: Musk afferma che X non lancerà mai criptovalute, i token APT e IMX verranno sbloccati in grandi quantità questa settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Musk afferma che X non lancerà mai criptovalute, i token APT e IMX verranno sbloccati in grandi quantità questa settimana</h2><p>Sabato, Musk ha risposto a <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> graphic designer DogeDesigner che X non lancerà mai token crittografici.</p>
<p>Ma già quando Musk ha preso il controllo di Twitter per la prima volta, alcuni hanno speculato che avrebbe introdotto la criptovaluta in Twitter. Infatti, secondo un rapporto del 2023, Twitter permetterà agli utenti di scambiare azioni e criptovalute sulla piattaforma come parte di una partnership con la società di investimento sociale eToro.</p>
<p>La visione di Musk è quella di costruire Twitter in una piattaforma globale guidata dall’intelligenza artificiale che copre tutti i campi. Musk ha dichiarato che questo piano inizierà con il supporto alle valute fiat e, se necessario, integrerà le criptovalute per un certo periodo di tempo in futuro. Ciò significa chiaramente che la visione di Musk per un futuro guidato dall’intelligenza artificiale include potenziali casi d’uso delle criptovalute.</p>
<p>In realtà, Musk ha precedentemente affermato che il sistema bancario attuale non è “in tempo reale ed inefficiente” e non corrisponde al mondo digitalmente connesso di oggi. Musk ha menzionato che la soluzione a questo problema è la criptovaluta.</p>
<p>Oggi, Musk afferma che X non lancerà mai token criptati, ed è incerto se sarà un falso tiro o altri mezzi per realizzare la sua visione della criptovaluta.</p>
<p>Il 6 agosto, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il compilatore Vyper ha rilasciato un rapporto di analisi sull’incidente di vulnerabilità della scorsa settimana: Prima del 30 luglio, sono state sfruttate molte piscine di liquidità di Curve a causa di potenziali vulnerabilità nel compilatore Vyper. Sebbene gli errori siano stati identificati e corretti, non erano a conoscenza dell’impatto sul protocollo che utilizzava compilatori vulnerabili al momento e non sono stati esplicitamente avvisati. La vulnerabilità stessa è una protezione di reingresso implementata in modo non corretto e le versioni di Vype interessate sono v0.2.15, v0.2.16 e v0.3.0.</p>
<p>La vulnerabilità è stata risolta e testata nella versione 0.3.1 e le versioni 0.3.1 e successive sono sicure. In futuro, verranno adottate misure per migliorare la correttezza dei contratti intelligenti compilati con Vyper. Una di queste è migliorare i test del compilatore, inclusa l’aumento della copertura, il confronto dell’output del compilatore con le specifiche del linguaggio e l’utilizzo di strumenti di verifica formale (FV) per la verifica del bytecode del compilatore. La seconda è fornire strumenti per consentire agli sviluppatori di testare più facilmente il proprio codice, inclusi test a livello di codice sorgente e bytecode. La terza è rafforzare l’uso del protocollo Vyper per un feedback bidirezionale più rigoroso.</p>
<p>Secondo i dati di Token Unlocks, i token dei primi 5 progetti saranno sbloccati questa settimana, con APT e IMX che esperimenteranno significativi sbloccaggi. Tra di essi:</p>
<p>Alle 0:00 del 7 agosto (UTC), Nym ha sbloccato 45,63 milioni di NYM (circa 8,68 milioni di dollari), corrispondenti al 9,52% dell’offerta circolante;</p>
<p>Alle 0:00 (UTC) del 7 agosto, Hashflow ha sbloccato 3,23 milioni di HFT (circa 1,15 milioni di dollari), corrispondenti al 1,84% dell’offerta circolante;</p>
<p>Alle 0:00 (UTC) del 9 agosto, <a href="/price/moonbeam-glmr" rel="nofollow noopener noreferrer" target="_blank">Moonbeam</a> sbloccherà 3,04 milioni di GLMR (circa $700.000), corrispondenti al 0,44% dell’offerta circolante;</p>
<p>Alle 0:00 del 12 agosto (UTC), <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> sbloccherà 4,54 milioni di APT (approssimativamente 30,58 milioni di dollari), corrispondenti al 2,07% dell’offerta circolante;</p>
<p>Alle 10:00 (UTC) del 12 agosto, <a href="/price/immutablex-imx" rel="nofollow noopener noreferrer" target="_blank">ImmutableX</a> sbloccherà 18,08 milioni di IMX (circa 13,51 milioni di dollari), pari al 1,67% dell’offerta circolante.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi627940"><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-BTC600934"><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/1691388052BTC.png" alt=""><br>Questa settimana si avvicina alla fine, continuando ad aspettare che venga scelta una direzione. Strategia di ingresso long rischiosa: $28,550 USD; Strategia di ingresso short rischiosa: $27,950 USD con un’occhiata continua al livello di $26.5K USD.</p>
<h3 id="h3-KAS521124"><a name="KAS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>KAS</h3><p><img src="https://gimg2.gateimg.com/image/article/1691388068KAS.png" alt=""><br>Il prezzo di ingresso menzionato della settimana scorsa era di $0,4250 USD, e questa settimana continua a creare nuovi massimi storici, raggiungendo brevemente $0,05217 USD, ottenendo un profitto del 22,68%. Una volta completata la consolidazione, è possibile un impulso sostenuto verso $0,065379 USD, $0,10483 USD e l’obiettivo principale di $0,14428 USD.</p>
<h3 id="h3-WLD908182"><a name="WLD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WLD</h3><p><img src="https://gimg2.gateimg.com/image/article/1691388085WLD.png" alt=""><br>È stata formata una pattern rialzista a forma di “W” dall’introduzione della moneta. Se si è ottimisti riguardo ai fondamentali di WLD, osservare una rottura sostenuta al di sopra del precedente massimo di $2.55 USD, con obiettivi successivi a $2.584 USD, $2.785 USD e $2.925 USD. Impostare lo stop-loss al precedente minimo di $1.845 USD.</p>
<h2 id="h2-Macro20Inizia20a20speculare20sui20rialzi20dei20tassi20di20interesse20concentrandoti20sui20dati20sullinflazione20degli20Stati20Uniti20di20gioved277715"><a name="Macro: Inizia a speculare sui rialzi dei tassi di interesse, concentrandoti sui dati sull’inflazione degli Stati Uniti di giovedì" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Inizia a speculare sui rialzi dei tassi di interesse, concentrandoti sui dati sull’inflazione degli Stati Uniti di giovedì</h2><p>Finora, il mercato azionario statunitense ha superato le aspettative degli investitori per il 2023.</p>
<p>Originariamente, si pensava che il ciclo di aumento dei tassi di interesse non avrebbe migliorato il mercato azionario fino alla fine dell’anno. Tuttavia, l’indice S&amp;P 500 è salito del 18% quest’anno, a soli 6 punti percentuali dal massimo storico di 4796 punti stabilito nel gennaio 2022.</p>
<p>Il mercato è ora quasi non protetto, e a causa dei tori troppo compiacenti per acquistare protezione, l’assicurazione al ribasso è diventata il periodo più economico della storia, con molte persone che scommettono su tutto.</p>
<p>Dopo essersi calmati per diversi mesi, questa settimana gli indici S&amp;P 500 e Nasdaq hanno registrato i loro maggiori cali settimanali dal momento della crisi bancaria di marzo, suonando così l’allarme per il mercato. Alcuni esperti avvertono che l’inflazione potrebbe portare più sorprese quando il recente rally del mercato azionario mostrerà segni di eccessiva speculazione.</p>
<p>Marko Kolanovic, uno stratega di JPMorgan Chase, ha dichiarato che la speculazione sull’intelligenza artificiale sta creando una bolla azionaria, che si trova di fronte al rischio di scoppiare. La più grande società di gestione patrimoniale del mondo, Blackstone, ha avvertito che l’inflazione ‘montagne russe’ sta entrando in un periodo di volatilità, cattive notizie per le azioni. Buone notizie economiche come una diminuzione dell’inflazione potrebbero non essere necessariamente buone notizie per il mercato. La ricerca di Rosenberg ha evidenziato che il Dow Jones Industrial Average è recentemente salito per 13 giorni consecutivi, il più lungo dal 1987.</p>
<p>L’ultima volta che il Dow Jones Industrial Average è salito del 28% in 13 giorni, è poi crollato del 19% nell’ottobre dello stesso anno. Tuttavia, uno dei motivi per considerare di sostenere le azioni statunitensi è che la recessione economica è stata rinviata a tempo indeterminato. Lo “stimolo nascosto” del bilancio da 1 trilione di dollari ha fornito finanziamenti a Biden Economics, e anche Fitch lo ha ora scoperto, portando a un declassamento del suo rating negli Stati Uniti.</p>
<p>La popolazione occupata non agricola negli Stati Uniti è aumentata di 187.000 persone dopo l’aggiustamento del trimestre di luglio, l’aumento più piccolo dal dicembre 2020 e inferiore alle aspettative per il secondo mese consecutivo. Il tasso di disoccupazione negli Stati Uniti è ulteriormente diminuito al 3,5% a luglio, solo leggermente superiore al minimo del 3,4% all’inizio di quest’anno, più di mezzo secolo fa. Dopo la pubblicazione dei dati, gli operatori hanno ridotto le scommesse su ulteriori aumenti dei tassi di interesse da parte della Federal Reserve.</p>
<p>La governatrice della Federal Reserve, Bowman, ha dichiarato che la Federal Reserve potrebbe dover aumentare ulteriormente i tassi di interesse per ripristinare completamente la stabilità dei prezzi. Bowman ha dichiarato di sostenere la decisione di aumentare i tassi di interesse nell’ultimo incontro della Federal Reserve. Nonostante i dati successivamente pubblicati abbiano mostrato un rallentamento della crescita dei prezzi, Bowman ha affermato di voler vedere ulteriori prove di una deflazione sostenuta. Inoltre, ha anche criticato la proposta di capitale della banca.</p>
<p>Questa settimana c’è un punto temporale importante. Alle 12:30 (UTC) di giovedì sera è stato annunciato il tasso annuale CPI trimestrale degli Stati Uniti per la fine di luglio, con un valore precedente del 3% e una previsione del 3,3%. Questi dati sono utilizzati solo come riferimento per la decisione della Federal Reserve se aumentare i tassi di interesse. Attualmente, la probabilità di un aumento dei tassi a settembre è molto bassa nelle previsioni del mercato macro, quindi dobbiamo prestare attenzione a ogni dato macro che influisce sulla decisione di aumentare i tassi di interesse.</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 suggerimenti 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></div>