QW5hbGlzaSBkZWxsJ2luZmx1ZW56YSBkaSBEYXZpcyBIaWx0b24gc3VsbGEgY3Jlc2NpdGEgZGVsIHByZXp6byBkZWwgdG9rZW4gU2FuZGJveCAoU0FORCk=

2023-06-12, 07:07
<p><img src="https://gimg2.gateimg.com/image/article/1686552409SDFX.jpeg" alt=""></p>
<h2 id="h2-Troppo20lungo20non20letto88137"><a name="Troppo lungo; non letto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Troppo lungo; non letto</h2><p>L’annuncio della collaborazione tra Sandbox e Paris Hilton per il lancio di una collezione di avatar iconici ha portato a un aumento del 6% del valore di SAND.</p>
<p>Se il momento attuale del prezzo di SAND continua, il valore della criptovaluta Sand potrebbe raggiungere $0.60.</p>
<p>Parisland di Hilton mira a fornire esperienze romantiche ai giocatori attraverso la sua realtà virtuale di appuntamenti.</p>
<h2 id="h2-Introduzione895094"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Sandbox, una piattaforma metaversale, <a href="https://www.gate.io/learn/articles/what-is-the-sandbox/88" target="_blank">è uno dei principali mondi virtuali</a> che sta alimentando interazioni coinvolgenti su web3. Oltre a collaborare con molte aziende fintech come Adidas, Gucci Vault Warner Music Group e Ubisoft, sta lavorando anche con vari personaggi famosi tra cui Snoop Dogg e Paris Hilton che hanno un impatto sull’adozione di <a href="https://www.gate.io/blog_detail/409/the-sandbox-everything-you-need-to-know" target="_blank">SAND, il token nativo di Sandbox</a>, e il suo valore.</p>
<p>Questo articolo esplora come la celebrità Paris Hilton abbia influenzato la sua impennata dei prezzi. Copre anche la collaborazione tra Sandbox e Hilton, nonché la piattaforma di incontri nel mondo virtuale recentemente lanciata.</p>
<h2 id="h2-Il20valore20del20token20Sandbox20SAND20supera20i20050352322"><a name="Il valore del token Sandbox (SAND) supera i $0,50" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il valore del token Sandbox (SAND) supera i $0,50</h2><p>La scorsa settimana il valore di SAND è balzato oltre i $0,50 a causa della notizia della collaborazione tra Sandbox e Paris Hilton, una celebrità americana popolare. Il 22 maggio 2022, Hilton ha annunciato che 11.11 Media aveva stretto una partnership con Sandbox per lanciare una collezione dei suoi avatar prima del suo concerto musicale a Los Angeles.</p>
<p>L’annuncio di Paris Hilton ha portato a un aumento del prezzo del 6% di SAND, spingendolo oltre il livello di $0.50. Ci sono state anche movimenti positivi in alcune metriche di SAND come gli Indirizzi Attivi Giornalieri (DAA). <a href="https://embed.santiment.net/chart?ps=the-sandbox&amp;pt=SAND&amp;df=2023-05-21T23%3A00%3A00.000Z&amp;dt=2023-05-24T23%3A00%3A00.000Z&amp;emcg=1&amp;wm=price_usd%3Bdaily_active_addresses&amp;wax=0%3B1&amp;wc=%2326C953%3B%23FFAD4D&amp;ws=%7B%22interval%22%3A%221d%22%7D%3B" rel="nofollow noopener noreferrer" target="_blank">Secondo Santiment</a>, il 24 maggio il numero di indirizzi attivi giornalieri è aumentato del 34%, passando da 488 a 656.</p>
<p>D’altra parte, l’accumulo delle balene è aumentato dopo che Hilton ha annunciato la collaborazione. Tale sviluppo ha creato ulteriore slancio al sentiment rialzista di SAND. In particolare, dal 22 maggio le balene hanno aggiunto quasi 7 milioni di SAND alle loro cripto-portafogli. Il grafico qui sotto mostra l’aumento dei saldi delle balene a seguito della partnership tra Sandbox e Hilton.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1686553102Paris Hilton 1.png" alt=""><br>Aumento dei saldi delle balene SAND - Santiment</p>
<p>Di solito, l’accumulo delle balene mostra un impulso rialzista che esiste in qualsiasi mercato. Come si vede nel diagramma sopra, i saldi delle balene sono aumentati significativamente dal 24 maggio al giorno della scrittura.</p>
<p>Con la dinamica dei prezzi che esisteva il 23 maggio, il mercato si aspettava che il prezzo di SAND salisse sopra i $0,60. Il grafico successivo indica i movimenti del prezzo di SAND dal 20 maggio.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1686553132Paris Hilton 2.png" alt=""><br>Prezzo del Sandbox - Coingecko</p>
<p>Come osservato nel diagramma sopra, <a href="https://www.gate.io/price/the-sandbox-sand" target="_blank">prezzo SAND</a> è aumentato a partire dal 24 maggio. Ha raggiunto un valore di $0,56 il 31 maggio prima di scendere a $0,52 il 1 giugno. Al momento della scrittura, il 2 giugno, il prezzo di Sandbox è di $0,56. In base alla dinamica di mercato prente, il Sand <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">previsione del prezzo</a> di $0,60 è probabile che diventi realtà nelle prossime settimane.</p>
<h2 id="h2-Sandbox20e20Paris20Hilton20in20collaborazione154560"><a name="Sandbox e Paris Hilton in collaborazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sandbox e Paris Hilton in collaborazione</h2><p>Abbiamo discusso come l’annuncio della collaborazione tra Sandbox metaverse e Paris Hilton abbia portato all’attuale slancio del prezzo di Sand crypto. Pertanto, approfondiamo dettagliatamente la natura della loro partnership.</p>
<p>Sandbox, una controllata di Animoca Brands, si è associata a 11:11 Media, la società di media di prossima generazione di Paris Hilton, per lanciare una collezione di avatar di Paris Hilton. Questa collezione composta da 5.555 avatar unici include undici NFT unici fatti a mano. Degno di nota, i detentori di questi avatar ottengono biglietti VIP gratuiti per il concerto live di Paris che si terrà il 7 giugno 2023 presso l’iconico Fonda Theatre di Los Angeles.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/638/decentraland-versus-sandbox-what-s-the-best-metaverse-project" target="_blank">Decentraland versus Sandbox, quale è il miglior Metaverse</a></p>
<p>Gli avatar sono anche unici in diversi modi che dovrebbero appassionare una vasta fetta dei suoi fan e della società più ampia. Questa collezione è una vera celebrazione dello stile di vita di Hilton e mostra anche il suo senso della moda, i suoi costumi di Halloween e gli abiti eleganti.</p>
<p>Oltre ai suoi costumi, ci sono altri accessori che includono guanti e cuffie da DJ. Ogni avatar costa 100 SANDS ed è disponibile su base first-come-first-served a causa del loro numero limitato. Quando giocano al gioco, i detentori dell’avatar avranno anche la possibilità di vincere criptovalute SAND.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/the-sandbox-sand" target="_blank">Previsioni di prezzo di SAND (Sandbox) per il 2023-2030</a></p>
<p>In sostanza, il lancio degli avatar ha tre <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Onde</a>. Il 31 maggio, la comunità OG di Parigi ha coniato i token. Successivamente, coloro che hanno firmato la lista di controllo hanno avuto la possibilità di coniare i loro token il 1° giugno. Infine, il pubblico generale ha avuto la possibilità di coniare gli avatar il 2 giugno. Tuttavia, gli avatar saranno svelati il 5 giugno 2023.</p>
<p>Questi avatar hanno grande significato per i fan e i collaboratori di Hilton. Secondo <a href="https://www.animocabrands.com/the-sandbox-and-11-11-media-to-launch-paris-hilton-avatar-collection#:~:text=The%20Sandbox%20and%2011%3A11%20Media%20to%20launch%20Paris%20Hilton" rel="nofollow noopener noreferrer" target="_blank">Post del blog di Amicobrands</a>, “11:11 Media vuole che gli avatar servano come un promemoria incoraggiante per i fan di abbracciare l’espressione di sé, celebrare la propria individualità e lasciare che la propria inner Paris brilli.”</p>
<p>Con riferimento a questa collezione, Sebastien Borget, <a href="https://www.animocabrands.com/the-sandbox-and-11-11-media-to-launch-paris-hilton-avatar-collection#:~:text=The%20Sandbox%20and%2011%3A11%20Media%20to%20launch%20Paris%20Hilton" rel="nofollow noopener noreferrer" target="_blank">Il COO e co-fondatore di The Sandbox ha detto</a>, “<br><strong>La collezione di avatar di Paris Hilton di 11:11 Media permetterà ai giocatori di esprimere con orgoglio la propria Paris Hilton interiore in <a href="/price/the-sandbox-sand" rel="nofollow noopener noreferrer" target="_blank">The Sandbox</a>.</strong>”</p>
<p>Ha aggiunto, “<br><strong>Dopo aver assistito a più attivazioni di successo del metaverso da parte del team di Parigi, i fan hanno atteso con impazienza questa collezione. Siamo entusiasti che presto potranno equipaggiare i loro nuovi avatar per mostrarsi nel metaverso.</strong>”</p>
<p>In generale, la collaborazione tra 11.11 Media e Sandbox promette molto ai fan del metaverso. Cynthia Miller, Direttore di <a href="/web3" target="_blank" class="blog_inner_link">web3</a> e metaverso presso 11:11 Media, ha commentato positivamente su tale sviluppo. <a href="https://www.animocabrands.com/the-sandbox-and-11-11-media-to-launch-paris-hilton-avatar-collection#:~:text=The%20Sandbox%20and%2011%3A11%20Media%20to%20launch%20Paris%20Hilton" rel="nofollow noopener noreferrer" target="_blank">Lei ha detto</a>“<br><strong>Unendo la presenza inconfondibile di Paris Hilton con la tecnologia all’avanguardia di The Sandbox, stiamo aprendo una nuova era di intrattenimento immersivo e creatività illimitata.</strong>”</p>
<p>Il lancio di questa collezione non è l’unica avventura di Hilton con i progetti blockchain e il metaverso. 11:11 Media ha anche collaborato con Sandbox per creare Parisland, un progetto di appuntamenti nel metaverso.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/415/sandbox-an-irresistible-immersive-virtual-game" target="_blank">Sandbox, un gioco virtuale immersivo irresistibile</a></p>
<h2 id="h2-Hiltons20Metaverse20Dating20Reality449073"><a name="Hilton’s Metaverse Dating Reality" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hilton’s Metaverse Dating Reality</h2><p>Come detto in precedenza, Sandbox e 11:11 Media si sono associati per sviluppare una realtà virtuale di appuntamenti. Parisland è il progetto metaverso di Hilton sviluppato sulla blockchain Sandbox. Si tratta di un “ibrido tra uno show televisivo interattivo e un gioco”. Diversi giocatori partecipano allo show virtuale di appuntamenti che Hilton conduce.</p>
<p>L’avventura degli appuntamenti, che dà ad ogni partecipante la possibilità di cercare il suo amore della vita, si svolge su un’isola romantica chiamata Parisland. Ogni giocatore svolge varie attività come trovare il prezioso Love Burger e gli anelli nuziali. Inoltre, tutti hanno l’opportunità di flirtare con vari concorrenti prima di scegliere il proprio vero partner.</p>
<p>La prima sessione dello spettacolo di appuntamenti reality si è svolta dal 13 febbraio al 13 marzo 2023 ed è stata un evento unico nel suo genere che si è svolto nel metaverso di Sandbox. Le avventure sono giunte al termine con un matrimonio spettacolare in cui Hilton ha fatto da DJ per la coppia.</p>
<p>Secondo Sebastien Borget, l’obiettivo di questa esperienza è creare e coltivare relazioni autentiche tra i giocatori. In effetti, Hilton vuole che le persone trovino l’amore tramite Parisland</p>
<h2 id="h2-Conclusione847420"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il valore di SAND è aumentato del 6% dopo l’annuncio della collaborazione di Paris Hilton con Sandbox blockchain per lanciare i suoi avatar iconici. Recentemente, Hilton ha anche sviluppato una piattaforma di appuntamenti metaversali su Sandbox. Il mercato delle criptovalute prevede che il valore di SAND raggiungerà $0.60 nel corrente momento di crescita dei prezzi.</p>
<div class="blog-details-info"><br><div>Autore: <strong> Mashell C. </strong>, Ricercatore di Gate.io<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 il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, sarà intrapresa un'azione legale per violazione del copyright.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards