TGEgcGnDuSBncmFuZGUgdmVuZGl0YSBkaSBORlQgbmVsbGEgc3RvcmlhIGRlZ2xpIE5GVA==

2023-03-20, 00:04

<p><img src="https://gimg2.gateimg.com/image/article/1679269908深度分析 封面.jpeg" alt=""></p>
<h2 id="h2-TL20DR296735"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Jeffrey Huang è diventato popolare quando ha venduto 1.010 NFT in 48 ore e in seguito ha acquistato 191 NFT.</p>
<p>La ragione principale per Huang di scambiare un grande volume di NFT era quella di ottenere una grande quota individuale dei token BLUR.</p>
<p>Il Merge, i primi 5.000 giorni, l’orologio NFT, HUMANE ONE e diversi cryptopunks sono gli NFT più costosi.</p>
<p>Oltre al marketplace NFT di Blur, puoi anche acquistare NFT nella Magic Box di Gate.io.</p>
<h2 id="h2-Introduzione447105"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Nonostante il attuale mercato criptato depresso, ci sono molte attività nel mercato NFT, che mostrano quanto siano popolari i token non fungibili. Le celebrità sono tra i principali investitori nel settore del mondo virtuale. Questo articolo tratterà di come Jeffrey Huang, un musicista di classe mondiale, ha venduto 1.010 NFT in 48 ore. Discuteremo anche <a href="https://www.gate.io/learn/articles/top-10-most-expensive-nfts-ever-sold/285" target="_blank">alcune delle più grandi vendite NFT di tutti i tempi</a>.</p>
<h2 id="h2-Importante20vendita20seguita20da20un20rapido20riacquisto306534"><a name="Importante vendita seguita da un rapido riacquisto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Importante vendita seguita da un rapido riacquisto</h2><p>Nansen, una società di ricerca blockchain, riporta che Jeffrey Huang, anche conosciuto come Machi Big Brother, ha venduto 1.010 NFT per un totale di 11.680 ETH del valore di 18,6 milioni di dollari alla data della vendita. L’elenco degli NFT venduti include 90 <a href="https://www.gate.io/learn/articles/what-is-bored-ape-yacht-club/143" target="_blank">Bored Ape Yacht Club (BAYC)</a>.</p>
<p>La cosa interessante è che Machi Big Brother in seguito ha acquistato 191 NFT, una mossa che alcuni analisti come Andrew Thurman sostengono potrebbe essere un atto di manipolazione di mercato o un modo per ottenere un enorme airdrop <a href="https://www.gate.io/uk/blog_detail/2168/tides-shift-in-nft-market-blur-token-activity-rises-on-gate.io" target="_blank">dal mercato Blur</a>, il marketplace NFT numero 1.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679270422Jeffrey hwang1.png" alt=""><br>Machi Big Brother (Jeffrey Huang) - <a href="https://assets.pandaily.com/uploads/2022/08/Untitled-design-3-11-1536x799.jpg" rel="nofollow noopener noreferrer" target="_blank">Pandaily</a></p>
<p>Non sorprende che il dump di NFT di Machi Big Brother e l’acquisto successivo di altri NFT fossero per aumentare il suo coinvolgimento sul mercato NFT di Blur. Questo perché la quota del drop aereo che un trader di NFT ottiene è determinata dal suo livello di partecipazione sul mercato Blur. A febbraio, il Marketplace Blur ha annunciato un nuovo round di airdrop previsto a breve.</p>
<p>Nello specifico, nell’ultimo airdrop Blur Machi Big Brother ha ottenuto la quota individuale più grande del token BLUR distribuito. Infatti, Arkham Intel, una società di analisi blockchain, riporta che Machi Big Brother ha ottenuto 1,8 milioni di token BLUR che ha convertito in 1,3 milioni di dollari.</p>
<p>Leggi anche su <a href="https://www.gate.io/learn/articles/the-trend-of-nft-marketplaces/379" target="_blank">la tendenza dei marketplace NFT</a></p>
<h2 id="h2-Chi2020Machi20Big20Brother70430"><a name="Chi è Machi Big Brother?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi è Machi Big Brother?</h2><p>Machi Big Brother, il cui vero nome è Jeff Huang, è un noto musicista e imprenditore tecnologico taiwanese. È stato membro del trio musicale L.A. Boyz tra il 1991 e il 1997. Successivamente ha formato il proprio gruppo musicale hip hop chiamato Machi nel 2003. Con la sua esperienza e passione per la musica, Huang e i suoi partner hanno creato un’azienda di registrazione musicale chiamata MACHI Entertainment.</p>
<p>Nel 2017 Huang è diventato popolare nel settore della blockchain quando ha fondato Mithril, una piattaforma di social media decentralizzata che premia i creatori di contenuti per il loro contributo. Machi Big Brother ha iniziato a investire pesantemente in NFT nel 2021 quando è diventato uno dei balene NFT più quotati. Infatti, è interessato agli NFT di Bored Ape Yacht Club (BAYC).</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2250" target="_blank">Chi sono le balene cripto e perché contano</a></p>
<h2 id="h2-Quale20relazione20ha20Machi20Big20Brother20con20BAYC917040"><a name="Quale relazione ha Machi Big Brother con BAYC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quale relazione ha Machi Big Brother con BAYC?</h2><p>Secondo i record di cryptoslam.io, Machi Big Brother è il miglior trader di NFT BAYC di tutti i tempi. Sembra aver generato molto profitto dal trading di questi NFT dal 2021. Ad esempio, nel 2021 Machi Big Brother ha guadagnato 5,85 milioni di dollari tramite la negoziazione di 34 Bored Apes NFT.<br>Allo stesso modo, ha effettuato oltre 1.300 scambi di NFT Otherside generando oltre 1,4 milioni di dollari di vendite in pochi mesi. In generale, però, il suo <a href="https://opensea.io/MachiBigBrother/activity" rel="nofollow noopener noreferrer" target="_blank">commercio</a> Le attività consistono in operazioni in entrata e in uscita, qualcosa che va avanti da molto tempo.</p>
<h2 id="h2-Altre20grandi20vendite20di20NFT20nella20storia400069"><a name="Altre grandi vendite di NFT nella storia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altre grandi vendite di NFT nella storia</h2><p>Dal 2021 sono comparsi sul mercato diversi costosi NFT. Alcune delle famose vendite di NFT includono Everydays: The Merge, The First 5000 Days, Clock, HUMAN ONE, TPunk #3442 e diversi cryptopunk.</p>
<h2 id="h2-Il20Merge778952"><a name="Il Merge" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il Merge</h2><p>The Merge è stata la vendita di NFT più costosa nell’intera storia dei token non fungibili. Creato da Pak, l’artista digitale, il Merge è stato venduto per 91,8 milioni di dollari nel dicembre 2021. Un totale di 28.983 persone hanno acquistato 312.000 azioni del Merge, rendendo Pak l’artista vivente più costoso.</p>
<h2 id="h2-Everyday20I20primi20500020giorni712536"><a name="Everyday: I primi 5.000 giorni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Everyday: I primi 5.000 giorni</h2><p>“Everyday”, creato da Mike “Beeple” Winkelmann, è il secondo NFT più costoso in quanto è stato venduto a $69.3 milioni nel marzo 2021. Vignesh Sundaresan, anche conosciuto come MetaKovan, il fondatore del progetto Metapurse NFT, ha acquistato ‘The First 5000 Days’ (Everyday) all’asta di Christie’s.</p>
<h2 id="h2-Lorologio20NFT901701"><a name="L’orologio NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’orologio NFT</h2><p>L’artista anonimo Pak e Julian Assange, il creatore di WikiLeaks, hanno collaborato per creare la “Censored NFT collection” che include il Clock NFT. Il Clock NFT, venduto per $52.7 milioni, è un NFT dinamico che mostra il numero di giorni in cui Assange è stato in prigione.</p>
<p>Nel febbraio 2022, l’AssangeDAO ha acquistato l’orologio NFT come attività di raccolta fondi per la difesa di Assange dalla sua estradizione negli Stati Uniti.</p>
<p>Dai un’occhiata a <a href="https://www.gate.io/price/view/nft" target="_blank">Le migliori monete e token NFT per capitalizzazione di mercato</a></p>
<h3 id="h3-UMANO20UNO244321"><a name="UMANO UNO" class="reference-link"></a><span class="header-link octicon octicon-link"></span>UMANO UNO</h3><p>HUMANE ONE, l’opera d’arte di Beeple che raffigura un astronauta che cammina permanentemente attraverso paesaggi mutevoli, è stata venduta per 28,9 milioni di dollari nel novembre 2021. Questo NFT è speciale perché ha un contratto intelligente codificato al suo interno che consente a Beeple di controllarlo a distanza per monitorare ciò che viene visualizzato al suo interno.</p>
<h3 id="h3-Cryptopunks20di20Larva20Labs579378"><a name="Cryptopunks di Larva Labs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cryptopunks di Larva Labs</h3><p>Alcune vendite famose di NFT che puoi pensare includono diversi CryptoPunks di Larva Labs. Questi includono CryptoPunk #5822 venduto per un valore di $23,7 milioni di ETH, CryptoPunk #5822 venduto per $23,7 milioni, CryptoPunk #7523 ($11,8 milioni), CryptoPunk #4156 ($10,26 milioni), CryptoPunk #5577 ($7,7 milioni), CryptoPunk #7804 ($7,56 milioni) e CryptoPunk #3100 ($7,51 milioni).</p>
<h2 id="h2-Come20acquistare20buoni20NFT20su20Gateio419197"><a name="Come acquistare buoni NFT su Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come acquistare buoni NFT su Gate.io</h2><p>Nel marketplace NFT di Gate.io chiamato <a href="https://www.gate.io/nft" target="_blank">Magic Box</a> puoi acquistare vari token non fungibili tramite il sistema di prezzo fisso o asta. In pratica, Magic Box è integrato con i principali mercati di token non fungibili come OpenSea, Sorare e Rarible.</p>
<p>Il primo passo quando si desidera acquistare NFT è creare un account su Gate.io e verificarlo. Una volta verificato il tuo account, devi ricaricare il tuo portafoglio. Da lì, visiti <a href="https://www.gate.io/nft" target="_blank">il mercato</a> e esplora le varie NFT visualizzate lì.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679270540Jeffrey hwang2.png" alt=""><br>NFT su Gate.io NFT Marketplace- Gate.io</p>
<p>Una volta individuato l’NFT che desideri acquistare, clicca su di esso per aprire una nuova finestra e poi clicca su “Raccogli ordine”, come indicato di seguito.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679270595Jeffrey hwang3.png" alt=""></p>
<p>Una volta che fai clic su “Raccogli ordine”, si aprirà una nuova finestra che ti permette di inserire la tua offerta.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679270612Jeffrey hwang4.png" alt=""></p>
<p>Quindi, inserisci l’offerta indicando l’importo che sei disposto a pagare per l’NFT. Una volta fatto ciò, attendi la fine del periodo d’asta.</p>
<h2 id="h2-Conclusion449358"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>In breve, Jeffrey Huang ha sorpreso la comunità cripto quando ha venduto 1.010 NFT in 48 ore. Sorprendentemente, subito dopo la vendita ne ha acquistati altri 191. Gli analisti ritengono che il motivo di Huang per fare ciò fosse aumentare la sua partecipazione nel mercato Blur NFT per ottenere una buona quota dell’airdrop. Nonostante Huang… <a href="https://www.gate.io/learn/articles/how-to-trade-nft/48" target="_blank">scambiato l’NFT</a> Nel marketplace NFT di Blur è anche possibile acquistarli presso lo scambio di criptovalute Gate.io.</p>
<div class="blog-details-info"><br><div>Autore: <strong> Mashell C. </strong>, Ricercatore 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à consentita la ripubblicazione dell'articolo a condizione che Gate.io venga citato. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>