Tm90aXppZSBxdW90aWRpYW5lIHwgTGUgYXV0b3JpdMOgIGRpIHJlZ29sYW1lbnRhemlvbmUgZGVsbGEgY29udGFiaWxpdMOgIGRlZ2xpIFN0YXRpIFVuaXRpIGluY29yYWdnaWFubyBsZSBwaWF0dGFmb3JtZSBhIGRldGVuZXJlIGNyaXB0b3ZhbHV0ZSwgaWwgQ3liZXJwb3J0IGRpIEhLIMOoIHNvc3BldHRhdG8gZGkgZXNzZXJlIHN0YXR

2023-09-08, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/16941520350908.jpg" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20le20agenzie20regolatorie20contabili20degli20Stati20Uniti20potrebbero20incoraggiare20le20piattaforme20a20detenere20criptovalute20e20si20sospetta20che20il20Cyberport20di20Hong20Kong20sia20stato20hackerato747699"><a name="Riepilogo giornaliero delle criptovalute: le agenzie regolatorie contabili degli Stati Uniti potrebbero incoraggiare le piattaforme a detenere criptovalute e si sospetta che il Cyberport di Hong Kong sia stato hackerato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: le agenzie regolatorie contabili degli Stati Uniti potrebbero incoraggiare le piattaforme a detenere criptovalute e si sospetta che il Cyberport di Hong Kong sia stato hackerato</h2><p>Secondo The Block, il Financial Accounting Standards Board (FASB) ha approvato nuove regole che consentono alle aziende di segnalare i loro asset di criptovalute al valore equo.</p>
<p>Le nuove regole saranno annunciate entro la fine del 2023 e entreranno in vigore nel 2025, ma l’azienda può applicare queste regole in anticipo. I token encapsulati non sono soggetti alle nuove regole. Alcuni professionisti ritengono che i metodi di misurazione contabile precedenti fossero uno degli ostacoli più grandi per le istituzioni che detengono criptovalute, che devono essere sottoposte a un trattamento di deterioramento. Il fair value incoraggerà le istituzioni a detenere criptovalute.</p>
<p>Molte grandi aziende Web3, come MicroStrategy e Bitfinex, mantengono <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> nei loro bilanci. Berenberg Capital ha dichiarato in un rapporto che le nuove regole possono “eliminare gli effetti negativi delle perdite di valore secondo le attuali regole FASB”.</p>
<p>Dal lato del gigante, Google ha aggiornato la sua politica pubblicitaria ieri. A partire dal 15 settembre, gli inserzionisti possono utilizzare i Servizi Pubblicitari di Google per promuovere giochi NFT, purché il contenuto pubblicitario non implichi contenuti legati al gioco d’azzardo. Raccomandare ai giocatori di acquistare beni in-game che migliorano l’esperienza utente, come abbigliamento, armi e armature dei personaggi, sarà conforme alle ultime politiche pubblicitarie di Google. Ma i giochi che promuovono lo “staking NFT” o i “casinò sociali” saranno vietati dall’utilizzare i servizi pubblicitari di Google.</p>
<p>Già a luglio di quest’anno, Google ha permesso agli utenti Android di scaricare giochi dal negozio Google Play e acquistare, vendere e guadagnare asset digitali come NFT.</p>
<p>Secondo i report dei media, la piattaforma di servizi online multifunzionale del sud-est asiatico Grab (applicazione per taxi, consegna di cibo e pagamento) ha aggiunto una scheda <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> per un portafoglio crittografico basato sulla <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygona</a> Tra di loro, Grab ha collaborato con l’Autorità Monetaria di Singapore per lanciare voucher NFT a Singapore, che possono essere utilizzati per il pranzo quotidiano e il consumo esperienziale.</p>
<p>Gli utenti possono riscattare buoni presso i commercianti selezionati, guadagnare NFT unici con caratteristiche singaporeane e ricevere ulteriori ricompense. Grab è una delle più grandi piattaforme online multifunzionali dell’Asia sud-orientale, con sede a Singapore e circa 180 milioni di utenti.</p>
<p>Hong Kong Cyberport è stato hackerato, con informazioni sulle startup, documenti aziendali, documenti di identità e altre informazioni ottenute dagli hacker, per un totale di circa 400 GB di dati aziendali. Nel post di X (precedentemente noto come Twitter), un account che si concentra sulla sicurezza informatica, si può vedere che i dati rubati sul sito web degli hacker vengono addebitati circa $300.000 (circa HKD 2,35 milioni).</p>
<p>Secondo i dati della piattaforma di intelligence di mercato IntoTheBlock, i grandi detentori di SHIB (balene blu) hanno effettuato acquisti folli nella scorsa settimana. È stato accumulato un totale di $100 milioni di SHIB, il che significa che questi investitori almeno non hanno partecipato alla vendita.</p>
<p>Il termine ‘detentore principale’ qui si riferisce al numero totale di indirizzi che detengono tra lo 0,1% e l’1% del volume di circolazione, nonché gli indirizzi che detengono oltre l’1% del volume di circolazione.</p>
<p>I dati mostrano che <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> è sceso del 7% la scorsa settimana e il suo prezzo attuale è di circa $ 0,00000767.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi15115"><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-BTC422995"><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/1694152077BTC.png" alt=""><br>Il grafico a quattro ore mostra un evidente pattern di fondo arrotondato, ed è interessante osservare se <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> può rompere oggi il livello di $26.510 e mantenerlo in modo sostenibile. C’è la possibilità di un movimento continuo verso l’alto verso $26.975 e $27.283 se riesce a rompere. Se non riesce a rompere, è probabile che continui a oscillare all’interno di un range, quindi è consigliabile adottare una strategia conservativa di acquisto basso e vendita alta.</p>
<h3 id="h3-SSV117788"><a name="SSV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SSV</h3><p><img src="https://gimg2.gateimg.com/image/article/1694152096SSV.png" alt=""><br>SSV ha subito un significativo calo dal suo picco di $99 al prezzo attuale di $16.09, con il grafico giornaliero in trend al ribasso. A breve termine, potrebbe esserci un rimbalzo con obiettivi a $16.72 e $17.36. Si consiglia di cogliere i rimbalzi a breve termine con una strategia di ingresso e uscita rapida.</p>
<h3 id="h3-TORN889800"><a name="TORN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TORN</h3><p><img src="https://gimg2.gateimg.com/image/article/1694152113TORN.png" alt=""><br>TORN, un progetto leader nello spazio degli accordi di monete miste, ha subito un calo sostanziale dal suo massimo storico di $948,8 a $2,91, una diminuzione del 99,69%. Il grafico giornaliero mostra segni di toccare il fondo a $2,5060, ed è stato recentemente ritestato il pattern del triangolo convergente. Si prevede una rottura intorno al 13/09, e una strategia conservativa prevede una posizione a livelli più bassi.</p>
<h2 id="h2-Macro20La20domanda20di20oro20ha20raggiunto20un20nuovo20record20e20potrebbero20essere20sospese20le20aumenti20dei20tassi20di20interesse20a20settembre724757"><a name="Macro: La domanda di oro ha raggiunto un nuovo record, e potrebbero essere sospese le aumenti dei tassi di interesse a settembre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: La domanda di oro ha raggiunto un nuovo record, e potrebbero essere sospese le aumenti dei tassi di interesse a settembre</h2><p>Dopo che l’indice ISM dei servizi di mercoledì ha mostrato che il settore dei servizi è rimasto forte, il numero di richieste iniziali di sussidi di disoccupazione annunciate giovedì ha raggiunto il minimo degli ultimi sei mesi, indicando che il mercato del lavoro ha ancora resilienza, rafforzando ancora una volta le aspettative di mercato per il rialzo della Federal Reserve. L’indice del dollaro americano si è mantenuto sopra il livello di 105, chiudendo in rialzo dello 0,19% a 105,07.</p>
<p>Dopo aver rilasciato dati solidi, il rendimento del Tesoro statunitense è salito brevemente per poi scendere leggermente. Il rendimento del Tesoro a due anni è sceso dal 5,02% al 4,95% il giorno stesso, mentre il rendimento del Tesoro a 10 anni è sceso dal 4,29% a circa il 4,25%.</p>
<p>L’oro spot è sceso brevemente durante la sessione di trading per poi tornare al livello di $1.920, ma non è riuscito a mantenere quel livello alla fine della giornata, chiudendo in rialzo dello 0,17% a $1.919,66 l’oncia. L’argento spot è sceso per sette giorni consecutivi di trading, chiudendo in ribasso dell’0,86% a $22,97 l’oncia, segnando un nuovo minimo in quasi tre settimane.</p>
<p>Secondo un’analisi di uno stratega di JPMorgan Chase, l’allocazione di capitale degli investitori verso l’oro ha raggiunto un massimo di 11 anni. Gli strategi guidati da Nikolaos Panigrtzoglou hanno affermato che l’allocazione implicita dell’oro da parte degli investitori non bancari è guidata dal comportamento degli acquisti delle banche centrali. Ha ottenuto questi dati dividendo le scorte di oro in monete d’oro, lingotti o fondi negoziati in borsa (ETF) in oro fisico rispetto alle scorte di attività finanziarie.</p>
<p>Ha detto: “Per gli standard storici, l’allocazione degli investitori in oro sembra attualmente piuttosto elevata, e le persone devono presumere che la crescita strutturale della domanda della banca centrale superi i livelli normali storici (a causa delle preoccupazioni per le sanzioni o la diffusa diversificazione verso l’esterno degli investimenti dai titoli di Stato del Gruppo dei Sette (G7)) per essere rialzisti sull’oro”.</p>
<p>Tuttavia, secondo gli ultimi dati del secondo trimestre rilasciati dal World Gold Council, gli acquisti di oro delle banche centrali sono diventati più normali. Se le azioni di acquisto della banca centrale vengono normalizzate, l’oro potrebbe ripristinare il suo rapporto storico con i rendimenti obbligazionari aggiustati per l’inflazione. Normalmente, per ogni aumento di 100 punti base del rendimento reale di un’obbligazione del tesoro decennale, il prezzo dell’oro diminuirà di €209 (circa $224), e viceversa. Ma questo non è stato il caso l’anno scorso.</p>
<p>Una settimana prima della riunione, i funzionari della Federal Reserve entreranno in un periodo di silenzio, con Logan e Williams tra gli ultimi funzionari che pianificano di parlare pubblicamente.</p>
<p>Giovedì ora locale, hanno rilasciato la loro ultima dichiarazione pubblica, esprimendo una posizione a favore della pace e suggerendo che i rialzi dei tassi di interesse potrebbero essere sospesi a settembre.</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. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>