U2FsdG8gSW5hc3BldHRhdG8gLSBCaXRjb2luIHN1cGVyYSBpIDQwLjAwMCBkb2xsYXJpOyBPUkRJIHJhZ2dpdW5nZSB1biBudW92byByZWNvcmQ=

2023-12-04, 09:29

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-Salto20Inaspettato20Ragioni20per20cui20BTC20supera20i20livelli20di20resistenza20e20lecosistema20BRC20830658"><a name="Salto Inaspettato: Ragioni per cui BTC supera i livelli di resistenza e l’ecosistema BRC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Salto Inaspettato: Ragioni per cui BTC supera i livelli di resistenza e l’ecosistema BRC-20</h2><p>Il 4 dicembre, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha superato i $40.000, il record più alto dalla prima metà del 2022; E il momento è completamente inarrestabile. Secondo i dati di Gate, il prezzo più alto di BTC nelle ultime 24 ore ha superato i $41743, un aumento di oltre il 4%, nonostante il sentiment generale del mercato sia stato acceso.</p>
<p>In precedenza, la maggior parte degli analisti di criptovalute aveva opinioni simili sull’andamento di Bitcoin, con 39000 che rappresenta un importante livello di resistenza. Se questo livello di resistenza viene rotto, si prevede che raggiunga i 40.000$ in un breve periodo di tempo. Abbastanza sicuro, ora il Big Bull è arrivato, superando i $ 41.000 più velocemente del previsto. Nel frattempo, secondo i dati di IntotheBlock, detenere oltre 1000 indirizzi BTC ha raggiunto un nuovo massimo nel 2023, e il valore di mercato di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ha superato i 780 miliardi di dollari.</p>
<p>Nel mese precedente, Bitcoin ha continuato a fluctuare ad un livello elevato dopo essere salito a $36,000. Nel complesso, a parte alcuni focolai di BRC20 e GameFi, il mercato è stato quasi sempre in fluctuazione insieme alle fluctuazioni di Bitcoin, causando sospetti e ansie tra le persone dell’industria delle criptovalute. Ora la situazione generale è chiara e il mercato si sta preparando ad entrare nel prossimo nodo.<br><img src="https://gimg2.gateimg.com/image/article/17016816781.png" alt=""><br>Sorgente: Gate.io</p>
<p>Ci si aspetta un aumento del BTC, ma le forze trainanti dietro questa ondata di superamento del livello di resistenza sono le seguenti:</p>
<p>In primo luogo, il mercato si aspetta che la Federal Reserve tagli i tassi di interesse, il che rappresenta anche la prima volta di recente in cui un rappresentante del consiglio di amministrazione della Federal Reserve ha annunciato un taglio dei tassi. In questo momento, i fondi di rifugio sicuro si stanno affollando su oro e Bitcoin; in secondo luogo, i detentori di Bitcoin hanno una volontà relativamente ferma a lungo termine, con meno pressione alla vendita. Nel frattempo, i fondi over-the-counter stanno fluendo costantemente, con un aumento significativo dell’afflusso di stablecoin nel mese di novembre; inoltre, ci sono nuove informazioni che indicano la finestra di approvazione per gli ETF Bitcoin (intorno al 10 gennaio prossimo anno), e molteplici fattori di notizie positive hanno portato all’attuale tendenza al rialzo di Bitcoin.<br><img src="https://gimg2.gateimg.com/image/article/17016818832.jpeg" alt=""><br>Origine: unsplash</p>
<p>Di conseguenza, la situazione delle Altcoin è relativamente stabile e L1 e L2 non sono ancora riusciti a tenere il passo con l’intero mercato. Ad esempio, ETH è rimasto addirittura molto stabile per diversi mesi senza una forte tendenza al rialzo; Ma credo che i fondi arriveranno presto. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> attraverso le principali catene pubbliche e i loro progetti derivati.</p>
<p>Nel frattempo, il token BRC20, che ha subito alti e bassi, presenta ancora una volta la natura drammatica dell’asset di iscrizione. Secondo i dati di Gate, ORDI ha registrato l’aumento più alto delle ultime 24 ore di TOP2. Essendo il token BRC20 che ha già creato un miracolo centuplicato ed è anche il primo token BRC20, ORDI ha mostrato un leggero calo la settimana scorsa, sembra che i partecipanti stiano gradualmente trarre profitto ed uscire. Il fatto è che sopporta il vento di BTC e tornerà nel breve termine; Va detto che, sebbene manchi ancora di valore pratico per il momento, la traccia di iscrizione mostra il potere del sentimento di mercato.</p>
<p>Tuttavia, nel complesso, la tendenza degli altri token BRC20 è ancora piuttosto imprevedibile e fluttua notevolmente, poiché il BRC20 attuale manca ancora di costruzioni infrastrutturali. Non è fino a quando non partecipano più sviluppatori o istituzioni che questo ecosistema può essere costruito organicamente, ma ci vorrà sicuramente del tempo. I giocatori devono considerare attentamente se partecipare o meno alla sottoscrizione e persino al trading sul mercato secondario. È meglio fare un’approfondita indagine sul proprietario del progetto e sulla comunità prima di prendere una decisione.<br><img src="https://gimg2.gateimg.com/image/article/17016819343.png" alt=""><br>Fonte: BRC-20.io</p>
<p>Oltre a BRC20, anche altre iscrizioni di catene pubbliche hanno mostrato un’eccezionale performance, come ad esempio ETH che ha avuto una ondata di crescita esplosiva. I contratti intelligenti e le basse commissioni GAS hanno portato un potenziale considerevole a <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Iscrizioni. Abbiamo già pubblicato articoli di analisi sul blog di Gate e i lettori interessati possono cercare le parole chiave di iscrizione per valutare le potenziali prospettive degli ETH.</p>
<h2 id="h2-Lesplosione20del20Project20Energy20Storage20potrebbe20essere20un20fenomeno20improvviso20GameFi20Track20guidato20da20Xpet87346"><a name="L’esplosione del Project Energy Storage potrebbe essere un fenomeno improvviso: GameFi Track guidato da Xpet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’esplosione del Project Energy Storage potrebbe essere un fenomeno improvviso: GameFi Track guidato da Xpet</h2><p>Negli ultimi due giorni, la popolarità di GameFi non è nuova. La scala di finanziamento del settore GAMEFI nel mese di ottobre è stata molto ampia, e tali risultati erano previsti; ma anche con così tanti progetti, la popolarità di Xpet si distingue ancora tra i GameFi emergenti.</p>
<p>Xpet è un’estensione basata su X, con un gameplay semplice. Basta raccogliere il tuo animale domestico e verrà visualizzato sulla tua homepage di X. I giocatori possono partecipare ad attività interattive come nutrire, potenziare animali domestici e fattorie, produrre frutta, convertirla in token di gioco, acquistare oggetti, ecc. Allo stesso tempo, può essere scambiato con ETH.</p>
<p>La semplicità e la facilità di comprensione sono esattamente i vantaggi di Xpet, che non richiede operazioni complesse. È legato a X, una piattaforma sociale di successo, e abbinato a un’immagine di animale domestico molto carina, è molto adatto ai giocatori moderati e ai giocatori che vogliono davvero giocare per guadagnare. Nonostante non ci sia una promozione significativa, ci si aspetta anche una diffusione fenomenale di Xpet.</p>
<p>Tuttavia, se vuoi partecipare, ricorda di non “coinvolgerti”, poiché i token $BPET e $XPET non sono ancora stati lanciati e lo sviluppo del progetto è ancora molto basilare.<br><img src="https://gimg2.gateimg.com/image/article/17016819544.png" alt=""><br>Sorgente: Xpet (estensione di Google)</p>
<p>Oltre a questo piccolo gioco che combina essenzialmente GameFi e SocialFi, ci sono anche molti progetti di gioco entusiasmanti in attesa di essere lanciati. Ad esempio, il capolavoro 3AFPS SHARPNEL creato da un team di sviluppo professionale; Gioco di ruolo ben realizzato e altamente giocabile BIG TIME; L’eroe del gas promosso dal team di <a href="/price/stepn-gmt" target="_blank" class="blog_inner_link">StepN</a> Se il gioco è il tuo preferito, puoi anche cercare GameFi su Gate per fornire una panoramica delle tendenze, dei progetti popolari e dell’analisi professionale.</p>
<p>Credo che XPET possa fungere da punto di partenza per rivitalizzare il settore del GameFi che è stato fermo per molto tempo, spingendo così piattaforme GameFi come <a href="/price/gala-gala" rel="nofollow noopener noreferrer" target="_blank">GALA</a> Giochi, mercati NFT e piattaforme basate su forum. Allo stesso tempo, spero che il miglioramento del livello di produzione dei giochi <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> possa davvero portare il GameFi in un ecosistema sano e prospero.</p>
<h2 id="h2-Finding20Un20nuovo20percorso20porta20alla20mania20della20FOMO20del20mercato20Blast20e20LUNC459634"><a name="Finding Un nuovo percorso porta alla mania della FOMO del mercato: Blast e LUNC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Finding Un nuovo percorso porta alla mania della FOMO del mercato: Blast e LUNC</h2><p>Essendo un nuovo progetto del team “conoscente” di BLUR, la partecipazione di Blast può dirsi un miracolo. L’ultima volta che ho raccolto informazioni su Blast è stato due settimane fa. I suoi follower ufficiali su Twitter erano 25000, ma oggi ha superato i 170.000.</p>
<p>La logica di Blast non è affatto innovativa. La sua narrativa è “L2 fruttifera”, che in realtà dice agli utenti che può mantenere stabili i loro ETH a lungo termine e non deprezzarsi a causa dell’inflazione - inoltre, risolve il problema del TVL della piattaforma e, d’altra parte, il “reddito passivo” più diretto come punto di vendita è sufficiente per suscitare l’interesse degli utenti per la partecipazione.</p>
<p>Va detto che il team di BLUR è bravo a creare argomenti e punti di vendita. Ora che il TVL di Blast ha superato i 600 milioni e con l’ingresso di BLUR nella terza stagione degli airdrop, questo nuovo punto di forza su NFT e DeFi potrebbe decollare.<br><img src="https://gimg2.gateimg.com/image/article/17016819815.png" alt=""><br>Origine: Blast.io</p>
<p>Infine, parliamo della “resurrezione” della comunità LUNA - il lancio di un nuovo progetto chiamato mint cash. Speriamo di ripuntare USTC (che in realtà è UST2.0) al dollaro USA e suggeriamo di impostare limiti sulla fornitura massima di LUNC e USTC. <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Il team ha proposto di utilizzare BTC come riserva di valore per supportare completamente questo sistema di stablecoin.</p>
<p>Quando questa notizia è stata rilasciata per la prima volta, l’USTC è salito di oltre il 300%, ma dovrebbe esserci stato un ritiro, e poi è tornato indietro; Il momentum è rimbalzato nei due giorni scorsi, mantenendosi intorno a 0,065 USDT.<br><img src="https://gimg2.gateimg.com/image/article/17016819966.png" alt=""><br>Sorgente: Gate.io</p>
<p>Il concetto e la visione presentati da Mint Cash offrono uno strato di garanzia rispetto alla precedente ‘stablecoin algoritmica’. Tuttavia, come fare in modo che gli utenti che hanno sperimentato il crollo di LUNA si fidino di nuovo è un viaggio lungo e impegnativo; Forse USTC può davvero approfittare dell’aumento complessivo del mercato e riconquistare la sua posizione come stablecoin, ma almeno dal punto di vista del progetto stesso, Mint Cash attualmente ha solo un white paper e manca di informazioni sufficienti a supportare tutto ciò.</p>
<h2 id="h2-Conclusion907339"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>La forte crescita di BTC ha indubbiamente ispirato lo spazio delle criptovalute; Ci sono segnali di tagli dei tassi di interesse della Federal Reserve e il quarto halving si avvicina sempre di più, con sempre più persone che entrano di conseguenza; Che si tratti di seguire l’indice di mercato o di cercare potenziali Altcoin, ora è un’ottima opportunità.</p>
<p>Quando le informazioni esplodono, è anche un momento per i giocatori di testare la propria capacità di pensiero indipendente e compostezza, specialmente per gli investitori al dettaglio che trovano difficile afferrare informazioni di prima mano. Spero che tutti possano gestire bene la propria allocazione di risorse sotto il sentimento del toro che ritorna rapidamente, e non cadere in guai a causa di FOMO o panico.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S.</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. La ripubblicazione dell'articolo sarà consentita a condizione che sia menzionato Gate.io. In tutti i casi, saranno adottate azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>