VG9rZW4gZnJhemlvbmFyaW8gZGkgR2F0ZS5pbyAtIE1hZ2dpb3JlIGxpcXVpZGl0w6AgZSBtYWdnaW9yZSBmbGVzc2liaWxpdMOgIHBlciBnbGkgTkZUICJibHVlIGNoaXA=

2023-01-19, 04:30

<p><img src="https://gimg2.gateimg.com/image/article/16741021071280X1280.jpeg" alt=""><br>Per riassumere, il 15 dicembre 2022 è stata rilasciata la collezione di carte collezionabili digitali di Trump al prezzo di 99 dollari ciascuna. Nonostante la collezione abbia ricevuto critiche diffuse dai media, tutti i 45.000 NFT (con l’ex presidente Donald Trump in varie pose e abiti) sono andati esauriti entro 12 ore dal lancio. Questa collezione segue il controverso rilascio della serie NFT di Melania Trump, che è stata messa all’asta su <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> nel gennaio 2022.</p>
<p>È importante notare che la collezione di carte commerciali digitali di Trump su OpenSea è un’iniziativa indipendente dalla sua campagna per la rielezione. L’acquisto di queste NFT non influenzerà le sue possibilità di riconquistare l’ufficio. Tuttavia, gli acquirenti di 45 NFT avranno l’opportunità di cenare con l’ex Presidente. Per coloro che non sono interessati all’acquisto di 45 NFT, c’è comunque l’opportunità di vincere vari premi attraverso la Trump Sweepstakes, come merchandise firmato e videochiamate con l’ex Presidente.</p>
<p>Dato l’acclamazione sociale e culturale di Trump come icona globale dei media e degli affari, Gate.io ha rilasciato ITRUMP il 15 gennaio per rafforzare la liquidità della collezione.</p>
<p>Come già accennato, in vista di ITRUMP, Gate.io ha anche lanciato diversi token frazionari correlati - IPUNKS, IAZUKI e IBAYC.</p>
<h2 id="h2-IPUNKS203321"><a name="IPUNKS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IPUNKS</h2><p>Per riassumere, l’iniziativa NFT Fraction Token è una soluzione creativa proposta da Gate.io per risolvere i problemi perpetui legati alla bassa liquidità e ai costi elevati per i NFT di alto livello.</p>
<p>CryptoPunks, creati nel 2017 da Larva Labs, è il punto di ancoraggio per questo sforzo. Acquistando un CryptoPunk originale e impegnandolo al Tesoro, Gate ha poi emesso un numero corrispondente di token ERC20 che le persone potevano acquistare per detenere la proprietà frazionata del CryptoPunk NFT originale. Il rapporto di emissione è di 1:10.000 o 10.000 token ERC20 per 1 x NFT originale, con ciascun token ERC20 che rappresenta 1⁄100,000 proprietà dell’opera NFT originale.</p>
<p>Lo strumento unico NFT AMM di Gate consente uno scambio semplice di token ERC20 per NFT frazionati, con la possibilità di riscattare l’NFT originale una volta raggiunta una determinata quantità di NFT frazionati.</p>
<p>Il token ERC20 emesso per la collezione CryptoPunks si scambia con l’etichetta <a href="https://www.gate.io/trade/IPUNKS_USDT/?ch=GM_blog_fraction1_20230119&amp;utm_campaign=TR_scQ4dUxw&amp;utm_content=&amp;utm_medium=CPM&amp;utm_source=CH_sApqy83F&amp;utm_term=" target="_blank">IPUNKS con un accoppiamento USDT</a>. L’offerta circolante di PUNKS è uguale all’offerta totale e al numero di CryptoPunks nel pool di liquidità CryptoPunks. I CryptoPunks nel pool possono essere riscattati da IPUNKS dal pool di liquidità in qualsiasi momento.</p>
<h2 id="h2-IBAYC383704"><a name="IBAYC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IBAYC</h2><p>Dopo IPUNKs c’era IBAYC - un token ERC-20 ancorato agli NFT del Bored Ape Yacht Club posseduti da Gate.io. Un token IBAYC rappresenta1⁄10.000 BAYC nel pool di liquidità BAYC.<br>L’offerta circolante di BAYC è uguale all’offerta totale di BAYC nel pool di liquidità e può essere riscattata in qualsiasi momento. <a href="https://www.gate.io/trade/IBAYC_USDT/?ch=GM_blog_fraction2_20230119&amp;utm_campaign=TR_CZbopzVF&amp;utm_content=&amp;utm_medium=CPM&amp;utm_source=CH_sApqy83F&amp;utm_term=" target="_blank">IBAYC ha anche una coppia di trading con USDT</a>.</p>
<h2 id="h2-IAZUKI630477"><a name="IAZUKI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IAZUKI</h2><p>La fase tre era IAZUKI.</p>
<p>La vendita di avvio per i token IAZUKI si è svolta dalle 06:00 del 8 gennaio 2023 alle 06:00 del 9 gennaio 2023 (UTC), con il trading per le coppie IAZUKI/USDT che iniziano alle 09:00 del 9 gennaio. Come per IPUNK e IBAYC, ogni Azuki NFT è frazionato in 10.000 token IAZUKI ERC-20 e disponibili per il trading con abbinamento USDT.</p>
<h2 id="h2-Come20aiuta20il20Token20frazionario20con20la20liquidit20degli20NFT996893"><a name="Come aiuta il Token frazionario con la liquidità degli NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come aiuta il Token frazionario con la liquidità degli NFT?</h2><p>Con la crescente popolarità degli NFT, i prezzi delle collezioni popolari possono schizzare alle stelle, rendendoli accessibili solo a pochi investitori ricchi. Dividendo la proprietà dei token ERC-721 o ERC-1155 in più token ERC-20 attraverso la frazionamento, gli NFT diventano più accessibili. Altri benefici correlati che favoriscono la liquidità includono:<br>Democratizzazione</p>
<p>Uno dei principali vantaggi dei NFT frazionari è la democratizzazione. L’alto costo di alcuni NFT popolari può rendere difficile la partecipazione al mercato per investitori o collezionisti più piccoli. Frazionando un NFT costoso, il costo viene abbassato e diventa più accessibile a un pubblico più ampio.</p>
<h2 id="h2-Price20Discovery604624"><a name="Price Discovery" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Price Discovery</h2><p>La frazionazione dei NFT aiuta anche nella scoperta del prezzo. Determinare il prezzo giusto per un NFT costoso con una storia limitata di transazioni può essere difficile. Scomponendo il NFT in pezzi più accessibili, più persone possono partecipare al commercio dell’asset, rendendo più facile determinarne il valore effettivo.<br>Maggiore visibilità per i creatori</p>
<p>I creatori beneficiano anche dalla frazionazione poiché permette una maggiore visibilità online e un mercato più liquido, consentendo loro di raggiungere un pubblico più ampio.<br>Come beneficiano i detentori di NFT frazionati?</p>
<p>I possessori di NFT frazionati possono possedere una percentuale di un NFT più grande e costoso. A seconda del NFT e della piattaforma su cui è stato acquistato, il possessore può avere accesso a comunità NFT esclusive e altri vantaggi come i diritti di voto. Alcuni progetti di NFT frazionati offrono anche opzioni di staking, permettendo ai possessori di bloccare il proprio NFT su una piattaforma o protocollo per ricevere ricompense di staking e altri benefici.</p>
<h2 id="h2-Quotazione20in20borsa20e20liquidit20aggiunta317622"><a name="Quotazione in borsa e liquidità aggiunta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quotazione in borsa e liquidità aggiunta</h2><p>Gli utenti beneficiano anche dall’avere i token frazionari quotati su Gate.io, in quanto aiuta a rafforzare e ottimizzare la liquidità. A differenza dei caveau NFT più specializzati e restrittivi su piattaforme come NFTX, i token frazionari di Gate.io sono conformi a ERC-20. Pertanto, quando lo scambio acquista un NFT, emette e elenca 10.000 token corrispondenti, qualsiasi utente della piattaforma può acquistare o vendere i token per USDT.</p>
<h2 id="h2-Riscatto20NFT773114"><a name="Riscatto NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riscatto NFT</h2><p>Nonostante questa funzionalità sia ancora in fase di sviluppo, alla fine, se un utente detiene più di 10.000 token relativi a un NFT specifico come IPUNK, essi possono visitare il mercato NFT di Gate.io per riscattare i suddetti token per l’originale e l’intero NFT al suo prezzo originale.</p>
<p>Inoltre, ciò consente anche di aggiungere incentivi in quanto gli utenti possono acquistare token ERC20 frazionati elencati dal mercato, scambiare i 10.000 token per l’NFT originale e quindi rivendere l’NFT originale su mercati secondari come OpenSea.</p>
<h2 id="h2-Pi20ampie20opportunit20di20investimento20in20NFT880303"><a name="Più ampie opportunità di investimento in NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Più ampie opportunità di investimento in NFT</h2><p>Dopo il lancio dei token frazionari, gli utenti possono anche aggiungere i propri NFT al pool di liquidità e Gate.io aiuterà a emettere i token ancorati ERC-20 di conseguenza.</p>
<h4 id="h4-Autore20squadra20Gate20NFT695184"><a name="Autore: squadra Gate NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Autore: squadra Gate NFT</h4><p>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentita la ripubblicazione dell’articolo a condizione che venga citata Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.</p>