Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgbWVyY2F0byBjcml0dG9ncmFmaWNvIHNwZXJpbWVudGEgZGVib2xpIGZsdXR0dWF6aW9uaTsgSGFtc3RlciBLb21iYXQgYW5udW5jaWEgdW4gZHJvcCBkZWwgNjAlIGRlaSB0b2tlbjsgQmxhY2tiaXJkIExhYnMgbGFuY2lhIHVuYSBwaWF0dGFmb3JtYSBXZWIzIHBlciBpIHBhZ2FtZW50aSBuZWk

2024-07-31, 03:46

<p><img src="https://gimg2.gateimg.com/image/article/17223972451_24.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Hamster20Kombat20annuncia20il206020di20token20airdrop20Blackbird20Labs20presenta20la20piattaforma20Web320per20i20pagamenti20dei20ristoranti20Movement20Labs20Testnet20rilasciata20attrarre2016020milioni20di20TVL20promessi16003"><a name="Crypto Daily Digest: Hamster Kombat annuncia il 60% di token airdrop; Blackbird Labs presenta la piattaforma Web3 per i pagamenti dei ristoranti; Movement Labs Testnet rilasciata, attrarre $160 milioni di TVL promessi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Hamster Kombat annuncia il 60% di token airdrop; Blackbird Labs presenta la piattaforma <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> per i pagamenti dei ristoranti; Movement Labs Testnet rilasciata, attrarre $160 milioni di TVL promessi</h2><p>Prima, esaminiamo l’attività commerciale di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF. Secondo i dati di Farside Investor, il 30 luglio il Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (GBTC) ha avuto un deflusso di fondi di $73,6 milioni. Nel frattempo, il Fidelity Bitcoin Spot ETF (FBTC) ha avuto un deflusso di $2,9 milioni, il Bitwise Bitcoin Spot ETF (BITB) ha avuto un deflusso di $3,2 milioni e l’ARK 21Shares Bitcoin Spot ETF (ARKB) ha avuto un deflusso di $7,9 milioni.</p>
<p>Il Bitwise <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Spot ETF (ETHW) ha registrato un ingresso di 3,5 milioni di dollari; il Fidelity Ethereum Spot ETF (FETH) ha registrato un ingresso netto di 16,4 milioni di dollari il primo giorno; il Grayscale Ethereum Spot ETF (ETHE) ha registrato un deflusso netto di 120,3 milioni di dollari il primo giorno.</p>
<p>La quota di mercato di Bitcoin, che misura il valore di mercato relativo di Bitcoin rispetto al valore di mercato totale delle criptovalute, ha raggiunto un massimo del 52,7% la settimana scorsa, il livello più alto degli ultimi tre anni da aprile 2021.</p>
<p><strong>Hamster Kombat pubblica un nuovo white paper, allocando il 60% dei token per l’airdrop ai giocatori</strong></p>
<p>Il team di Hamster Kombat ha rilasciato martedì un nuovo white paper, dettagliando l’economia del token del progetto e rivelando l’imminente evento di airdrop dei token. Il white paper afferma che stanno pianificando il “più grande airdrop nella storia della criptovaluta” e che il gioco ha attualmente 300 milioni di utenti. Secondo il white paper, il 60% dei token verrà ‘specificamente’ utilizzato per premiare i giocatori.</p>
<p>Il white paper afferma anche che “i fondi rimanenti saranno utilizzati per fornire liquidità di mercato, partnership di ecosistemi e sovvenzioni, ricompensare le squadre e altri progetti”. Gli sviluppatori hanno dichiarato che Hamster Kombat non ha ricevuto supporto da parte di società di investimento o venture capitalist e quindi non affronterà “pressione di vendita”.</p>
<p>Inizialmente, il gioco era previsto per subire il suo primo airdrop questo mese, ma è stato annunciato martedì che l’esecuzione dell’airdrop sarebbe stata un’operazione complessa. Lo sviluppatore ha affermato nel gruppo ufficiale di Telegram che l’airdrop del token Hamster è un compito tecnicamente complesso e non abbiamo stabilito una data specifica perché è difficile prevedere l’ora esatta di attuazione di questo piano.</p>
<p>Anche se il suo fondatore rimane anonimo, hanno stabilito una grande comunità di giocatori in breve tempo, e Hamster Kombat è diventato un argomento caldo nel campo della criptovaluta. L’ex Hamster Kombat ha 50 milioni di utenti attivi quotidiani in 190 paesi.</p>
<p>Il gioco è stato ispirato dal successo di Notchcoin. A titolo di riferimento, Notcoin ha distribuito oltre 80 miliardi di token NOT del valore approssimativo di 1 miliardo di dollari a maggio.</p>
<p><strong>Blackbird Labs lancia <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> piattaforma per pagamenti nei ristoranti</strong></p>
<p>Il 30 luglio, Blackbird Labs, una startup tecnologica alberghiera fondata da Ben Leventhal, co-fondatore di Resy ed Eater, ha annunciato il lancio di una piattaforma di pagamento Web3 chiamata Blackbird Pay, appositamente progettata per i ristoranti. La piattaforma si basa sulla nuova rete blockchain di Blackbird, chiamata Blackbird Flynet, fornendo ai ristoranti la propria rete di pagamento e regolamento end-to-end per la prima volta, mirando a risolvere problemi come la riduzione dei profitti e le riserve di contanti.</p>
<p>L’obiettivo di Blackbird Pay è ridurre i tempi di liquidazione e ridurre i costi delle transazioni nei ristoranti a circa il 2% per transazione. Inoltre, consente ai clienti di effettuare pagamenti utilizzando il token nativo di Blackbird, FLY, che viene emesso come ricompensa della piattaforma. Blackbird Pay consente ai clienti dei ristoranti aderenti di effettuare pagamenti direttamente dall’app Blackbird utilizzando carte di credito, carte di debito, token FLY o <a href="/price/usd-coin-usdc" rel="nofollow noopener noreferrer" target="_blank">USD Coin</a>(USDC). L’applicazione assegna inoltre un punteggio unico di valore del cliente a ciascun utente, che i ristoranti membri possono utilizzare come base per programmi personalizzati di punti, benefici e premi.</p>
<p>L’applicazione potenziale delle startup Web3 nell’industria della ristorazione è enorme, coprendo la riduzione dei costi, i programmi di ricompensa per la gestione e la gamification. Altri partecipanti includono DevourGO, un servizio di consegna di cibo Web3. Secondo i dati dell’American Restaurant Association, le vendite dei ristoranti americani dovrebbero superare per la prima volta i 1000 miliardi di dollari nel 2024.</p>
<p>Roni Mazumdar, co-proprietario di Unpalogetic Foods, ha dichiarato che Blackbird e servizi simili possono aiutare i ristoranti a risparmiare migliaia di dollari in commissioni di transazione mensili.</p>
<p>Blackbird sta ancora sviluppando applicazioni di messaggistica e scoperta per ristoranti, tra cui progetti come Blackbird Breakfast Club e Bar Blackbird, mirati a portare più affluenza ai ristoranti durante la bassa stagione. La società ha raccolto $24 milioni in finanziamenti della Serie A guidati da Andreessen Horowitz.</p>
<p><strong>Movement Labs si unisce <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> AgLayer di ’s, il testnet rilascia i 160 milioni di TVL promessi</strong></p>
<p>La società di sviluppo blockchain Movement Labs ha annunciato di unirsi a AgLayer di <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> su Ethereum Layer 2, coincidendo con il lancio del testnet pubblico di Movement. Movement è il primo ecosistema basato su Move che utilizza AgLayer, contribuendo a colmare il divario tra gli ecosistemi Move ed EVM e consentendo agli sviluppatori di Ethereum di distribuire contratti Solidity su catene basate su Move senza modificare il codice.</p>
<p>AgLayer è uno strato di interoperabilità sviluppato da Polygon Labs e altri contributori principali, con l’obiettivo di promuovere liquidità e sicurezza unificate tra le reti di catene. AgLayer semplifica il processo di conversione o trasferimento sicuro degli asset nativi di Ethereum da una catena all’altra mediante il ricollocamento delle prove di sicurezza basate su ZK su Ethereum.</p>
<p>AgLayer fungerà da livello di liquidità unificato tra le catene basate su MoveVM, altre ‘AggChains’ e Ethereum, contribuendo a risolvere i problemi di frammentazione della blockchain. L’infrastruttura utilizzerà anche il livello di disponibilità dei dati di Celestia per lo storage dei dati off chain a basso costo e ad alta velocità, mantenendo nel contempo la sicurezza di Ethereum.</p>
<p>Movement Labs ha annunciato ad aprile di quest’anno il completamento di un round di finanziamento di Serie A da 38 milioni di dollari guidato da Polychain Capital, con l’obiettivo di introdurre la macchina virtuale Move di Facebook in Ethereum. Move è stato inizialmente sviluppato dai membri del progetto di stablecoin Diem di Facebook. Movement Labs afferma che prima del lancio della mainnet, il public testnet Parthenon aveva già attirato $160 milioni di TVL promessi.</p>
<h2 id="h2-Tendenze20di20mercato20il20mercato20nel20complesso2020debole20e20volatile20e20il20mercato2020in20attesa20della20decisione20sui20tassi20dinteresse20della20Federal20Reserve122134"><a name="Tendenze di mercato: il mercato nel complesso è debole e volatile, e il mercato è in attesa della decisione sui tassi d’interesse della Federal Reserve" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il mercato nel complesso è debole e volatile, e il mercato è in attesa della decisione sui tassi d’interesse della Federal Reserve</h2><p>BTC mostra un trend debole e volatile intorno ai $66.000. L’incidente Mt.Gox continua a fermentare, con una grande quantità di BTC trasferiti per compensazione, il che ha creato una certa pressione al ribasso sul mercato. Nel frattempo, l’ETF spot di Bitcoin ha visto un deflusso di quasi $100 milioni, e sebbene BlackRock non abbia ancora aggiornato i suoi dati pertinenti, il sentiment di mercato è stato influenzato in qualche misura.</p>
<p>ETH: Rispetto a Bitcoin, ETH ha avuto una performance relativamente positiva, con un prezzo mantenuto sopra i $3.250. Negli ultimi giorni, l’uscita degli ETF su Ethereum di Grayscale si è rallentata.</p>
<p>Altcoin: Il mercato delle altcoin manca di nuovi punti caldi e sta vivendo in generale un trend al ribasso. L’attenzione degli investitori è principalmente sulle valute mainstream, e il sentimento di mercato per le altcoin è relativamente basso.</p>
<h3 id="h3-Indicatori20di20dati814416"><a name="Indicatori di dati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Indicatori di dati</h3><p>Oggi, l’indice AHR999 è 0,87, anche se l’indice è leggermente diminuito, è comunque adatto per gli investitori a lungo termine per effettuare investimenti regolari. L’indice AHR999 è un indicatore importante per misurare il valore degli investimenti a lungo termine del mercato, e i valori attuali indicano che ci sono ancora buone opportunità di investimento a lungo termine nel mercato.</p>
<p>L’indice della paura e dell’avidità rimane a 61, indicando un raffreddamento del sentimento di avidità di mercato. Questo indice è un indicatore importante per misurare il sentimento di mercato, con valori più alti che indicano un mercato più avido e viceversa indicando un mercato più timoroso. I valori attuali indicano che il sentimento di mercato sta diventando più calmo e gli investitori dovrebbero rimanere cauti nelle loro operazioni.</p>
<h3 id="h3-Notizie20macroeconomiche104216"><a name="Notizie macroeconomiche" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notizie macroeconomiche</h3><p>Mercato azionario statunitense: i tre principali indici hanno oscillato, con le azioni tecnologiche rappresentate da NVIDIA che sono scese del 7%, facendo scendere l’indice Nasdaq di più del 1%. Questa notizia ha avuto un certo impatto negativo sul mercato globale degli asset.</p>
<p>Politica monetaria: La Federal Reserve rilascerà la sua decisione sui tassi di interesse alle 2:00 del mattino ora di Pechino di giovedì, e il presidente della Fed Powell terrà un discorso alle 2:30. Ci si aspetta che ci possano essere significative fluttuazioni di mercato prima e dopo questo periodo, e gli investitori dovrebbero controllare in modo ragionevole le loro posizioni.</p>
<h3 id="h3-Punti20Caldi20del20Mercato380667"><a name="Punti Caldi del Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato:</h3><p><strong>Mini gioco Telegram</strong><br>Hamster Kombat, che conta oltre 50 milioni di abbonati Telegram, ha aggiornato ieri il suo whitepaper sui token e ha annunciato che il 60% dei suoi token sarà utilizzato per gli airdrop degli utenti. Sebbene l’ufficiale sostenga che ci siano oltre 300 milioni di utenti nel gioco, il valore degli airdrop di token che un singolo utente può ricevere sembra limitato di fronte a questa scala di utenti. È importante notare che Gate.io ha lanciato il trading pre-mercato per questo token e gli investitori possono prestare attenzione alle sue performance di mercato.</p>
<p><strong><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Ecosistema</strong><br>Il prezzo di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> (SOL) è sceso sotto i $180, e tutti i token Meme on-chain, tranne BOME, sono in trend al ribasso. L’opinione di mercato suggerisce che la significativa caduta di SOL possa essere correlata alla spedizione di SOL acquistati a prezzo scontato da una certa istituzione di investimento criptato. Secondo le notizie, il SOL acquistato dall’istituzione a prezzo scontato subirà un periodo di blocco di 4 anni, ma in realtà questi token stanno già circolando sul mercato e non c’è alcun meccanismo di blocco obbligatorio. Ciò ha avuto un significativo impatto negativo sul prezzo di mercato di SOL.</p>
<h3 id="h3-Conclusion652089"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h3><p>In generale, il sentimento di mercato attuale è relativamente calmo, con una differenziazione significativa nelle performance delle valute principali. La tendenza a breve termine del mercato è incerta e la decisione sui tassi di interesse della Fed e il discorso di Powell saranno al centro dell’attenzione del mercato questa settimana, ci si aspetta che causino significative fluttuazioni nel mercato del rischio. Gli investitori dovrebbero controllare ragionevolmente le proprie posizioni e mantenere operazioni caute.</p>
<h2 id="h2-Macro20Il20mercato2020cauto20prima20della20pubblicazione20dei20rapporti20finanziari20delle20azioni20tecnologiche20con20lSampP2050020e20gli20indici20Nasdaq20in20calo380517"><a name="Macro: Il mercato è cauto prima della pubblicazione dei rapporti finanziari delle azioni tecnologiche, con l’S&amp;P 500 e gli indici Nasdaq in calo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Il mercato è cauto prima della pubblicazione dei rapporti finanziari delle azioni tecnologiche, con l’S&amp;P 500 e gli indici Nasdaq in calo</h2><p>Martedì 30 luglio, l’indice S&amp;P 500 e l’indice Nasdaq hanno chiuso in ribasso, trascinati principalmente al ribasso dalla debole performance dei chip e dei grandi titoli tecnologici, mentre una serie di importanti rapporti finanziari delle società tecnologiche che verranno pubblicati questa settimana hanno aumentato l’incertezza del mercato. Al contrario, il Dow Jones Industrial Average è salito leggermente.</p>
<p>Come uno dei leader nel campo dell’intelligenza artificiale, il prezzo delle azioni di Microsoft è sceso dello 0,89% per chiudere a $422,92 prima dell’annuncio delle prestazioni trimestrali. Nonostante le alte aspettative di mercato, le prestazioni del gigante del software sono state inferiori alle previsioni di crescita per i servizi di cloud computing Azure, causando una caduta del prezzo delle azioni di circa il 5% nelle contrattazioni dopo l’orario di chiusura.</p>
<p>I dati specifici mostrano che il Dow Jones Industrial Average è salito dello 0,5%, mentre l’indice S&amp;P 500 è sceso dello 0,5% e l’indice Nasdaq è sceso dell’1,28%.</p>
<p>Il produttore di chip Nvidia è sceso del 7,04% a chiudere a $103,73. Questo ha trascinato al ribasso anche altre azioni di chip, facendo diminuire l’indice Philadelphia Semiconductor del 3,88%. Inoltre, tra le altre grandi aziende tecnologiche, Apple è salita dello 0,26%, Amazon è scesa dello 0,81% e Meta è scesa dello 0,54%, principalmente a causa delle preoccupazioni di mercato sulla sua valutazione.</p>
<p>Anche questa settimana saranno pubblicati i dati sulle forze lavoro, compreso il rapporto governativo sull’occupazione di venerdì. Il sondaggio sulle offerte di lavoro e la mobilità della forza lavoro pubblicato martedì ha mostrato che il numero di offerte di lavoro nel mese di giugno è stato di 8,18 milioni, superiore alle aspettative degli economisti di 8 milioni.</p>
<p>Mercoledì 31 luglio, i mercati azionari asiatici sono rimasti all’interno di un intervallo familiare, riflettendo la divergenza nel campo dell’intelligenza artificiale dovuta al forte contrasto di prestazioni tra il gigante tecnologico Microsoft e il produttore di chip AMD. Prima che la Banca del Giappone annunciasse la sua decisione politica, lo yen si è rafforzato. Mercoledì, le politiche delle banche centrali di tutto il mondo sono diventate il centro dell’attenzione degli investitori e anche la Federal Reserve annuncerà la sua decisione sui tassi di interesse nel corso della giornata. In generale, il mercato si aspetta che la banca centrale statunitense mantenga invariati i tassi d’interesse, ma potrebbe suggerire futuri tagli dei tassi d’interesse.</p>
<p>Dal lato cinese, un’indagine ufficiale sulle fabbriche pubblicata mercoledì ha mostrato che l’attività manifatturiera si è contratta per il terzo mese consecutivo, aumentando le aspettative di mercato per ulteriori misure di stimolo economico. L’indice ufficiale degli acquisti (PMI) per luglio è sceso da 49,5 a giugno a 49,4, anche se al di sotto della linea di demarcazione tra crescita e contrazione di 50, è superiore alla previsione mediana di 49,3 in un sondaggio Reuters.</p>
<p>Nelle prime contrattazioni, lo yen è sceso dell’1%, ma a causa dell’apprezzamento complessivo dello yen, ci si aspetta che scenda del 3,7% a luglio.</p>
<p>Nel mercato delle materie prime, il petrolio greggio statunitense è salito dello 0,67% a $75,23 al barile, mentre il petrolio Brent è salito dello 0,5% a $79,02 al barile. Anche i prezzi dell’oro sono aumentati di circa l’1% martedì poiché gli investitori si aspettavano che la Federal Reserve potesse fornire indizi su un taglio dei tassi a settembre questo fine settimana. L’oro al contado è salito dell’0,8% a $2403,47 all’oncia, mentre il prezzo di liquidazione dei future sull’oro statunitense è aumentato dell’1% a $2451,9 all’oncia.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Icing</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 si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni di copyright.<br></div><p></p><br></div></div></div></div>