R2F0ZS5pbyBBTUEgY29uIE1pbnRlZC1MaXN0IGUgc2NhbWJpYSBpIHR1b2kgTkZUIGUgcmljZXZpIHJpY29tcGVuc2UgY29uIHRva2VuIE1URA==
<p><img src="https://gimg2.gateimg.com/image/article/1673506145FgZGjhKXkAIgYas.jpeg" alt=""><br><strong>Ora: 2 novembre 2022, 13:00 (UTC)</strong><br><strong>Gate.io ha ospitato una sessione AMA (Ask-Me-Anything) con il Direttore, Brand &amp; Business Partnerships di Minted, Matt Wan nella Community di Gate.io Exchange.</strong><br><strong>Sito web ufficiale: <a href="https://minted.network/" rel="nofollow noopener noreferrer" target="_blank">https://minted.network/</a></strong><br><strong>Twitter: <a href="https://twitter.com/mintednetwork" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/mintednetwork</a></strong><br><strong>Segui Minted su Twitter e Telegram</strong></p>
<p><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/1673506250截屏2023-01-12 11.09.57.png" alt=""><br><strong>Direttore, Brand &amp; Business Partnerships di Minted — Matt Wan
</strong><br>Sono il Direttore per le Partnership di Brand &amp; Business presso Minted. Giorno dopo giorno, lavoro a stretto contatto con tutti i nostri vari portatori di interessi esterni, dai partner ai creatori ai membri della comunità, per contribuire a far avanzare la nostra missione presso Minted. Lavoro anche a stretto contatto con il nostro team di prodotto per condividere feedback e soddisfare le esigenze dei portatori di interessi per plasmare la roadmap dello sviluppo del prodotto. E solo per divertimento come dato personale su di me, amo la natura e recentemente ho preso lezioni per provare a imparare il wing foiling—che è uno sport acquatico che è un po’ un incrocio tra il kitesurf e il windsurf.</p>
<h2 id="h2-Domande20e20risposte20da20Gateio662745"><a name="Domande e risposte da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte da Gate.io</h2><h3 id="h3-Q120Puoi20dirci20cosa2020Minted990044"><a name="Q1: Puoi dirci cosa è Minted?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi dirci cosa è Minted?</h3><p><strong>Matt</strong>: È abbastanza semplice - Minted (minted.network) è una piattaforma NFT decentralizzata, nativa sia delle catene <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> che Cronos. E aspiriamo ad essere il bazar digitale delle meraviglie per tutti coloro che vogliono scoprire, scambiare e trovare gemme NFT. Offriamo un’esperienza utente altamente curata e sicura, e ci stiamo costantemente migliorando in base al feedback della nostra comunità e dei nostri partner.</p>
<h3 id="h3-Q220Potresti20anche20dirci20qualcosa20di20pi20sul20team20di20Minted78003"><a name="Q2: Potresti anche dirci qualcosa di più sul team di Minted?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Potresti anche dirci qualcosa di più sul team di Minted?</h3><p><img src="https://gimg2.gateimg.com/image/article/1673506325截屏2023-01-12 11.24.29.png" alt=""><br><strong>Matt</strong>: Abbiamo un team di persone eccezionalmente talentuose e laboriose, tutte con un’ossessione per gli NFT e per realizzare il nostro obiettivo di costruire un bazar digitale delle meraviglie web3. Dai nostri product manager ai nostri designer ai nostri community manager, tutti si stanno impegnando per offrire ai nostri utenti il miglior prodotto possibile. Minted è stato incubato da <a href="/price/cronos-cro" target="_blank" class="blog_inner_link">Cronos</a> Labs, quindi dobbiamo assolutamente ringraziare anche il team di Cronos Labs per il loro supporto. Degno di nota è anche il fatto che abbiamo una partnership commerciale con Crypto.com NFT per estendere ulteriormente la nostra portata e il nostro pubblico.</p>
<h3 id="h3-Q320Abbiamo20conosciuto20diverse20piattaforme20NFT20in20questo20settore20cosa20rende20Minted20diverso616014"><a name="Q3: Abbiamo conosciuto diverse piattaforme NFT in questo settore, cosa rende Minted diverso?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Abbiamo conosciuto diverse piattaforme NFT in questo settore, cosa rende Minted diverso?</h3><p><strong>Matt</strong>: Prima di tutto, come già accennato in precedenza, ci concentriamo molto sull’esperienza utente finale altamente curata e sicura. Per quanto riguarda la sicurezza, tutti i contratti Minted sono completamente sottoposti a revisione e adottiamo anche un approccio di lista bianca per quanto riguarda l’elenco delle collezioni.</p>
<p>Inoltre, siamo in grado di accedere all’ecosistema più ampio di #CROfam, che comprende gli utenti di Cronos e Crypto.com, che rappresenta più di 50 milioni di persone. La nostra partnership commerciale con Crypto.com NFT è anche molto importante, poiché ci consente di accedere a determinate opportunità che altrimenti non avremmo.</p>
<p>Inoltre, abbiamo anche partnership solide con altre dapps su Cronos, ad esempio, con VVS.<br><img src="https://gimg2.gateimg.com/image/article/1673506473截屏2023-01-12 11.27.39.png" alt=""><br>Infine, il nostro obiettivo è offrire un’esperienza molto gratificante per gli utenti su Minted. Ciò significa che gli utenti possono guadagnare ricompense in token $MTD tramite le ricompense per le inserzioni, le casseforti $MTD e le ricompense per il trading (in arrivo a breve).</p>
<h3 id="h3-D420Quali20sono20i20tuoi20piani20per20il20token20MTD375210"><a name="D4: Quali sono i tuoi piani per il token $MTD?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>D4: Quali sono i tuoi piani per il token $MTD?</h3><p><strong>Matt</strong>: Felice di condividere di più su questo! Innanzitutto, voglio indirizzare tutti al nostro lightpaper per le ultime informazioni ufficiali sul token. Ma voglio anche condividere con voi le nostre idee a livello generale per il futuro.</p>
<p>In primo luogo, abbiamo intenzione di utilizzare $MTD come modo per ‘’restituire’’ agli utenti fedeli di Minted, attraverso lo staking per la condivisione dei ricavi, ricompense per le quotazioni e ricompense per il trading.</p>
<p>In futuro, utilizzeremo sempre di più $MTD per le funzioni di governance. Al momento, la maggior parte delle decisioni sono prese dal nostro team principale, ma man mano che il progetto matura, sempre più decisioni saranno disponibili alla nostra comunità.<img src="https://gimg2.gateimg.com/image/article/1673506547截屏2023-01-12 11.29.08.png" alt=""><br>Infine, useremo $MTD per altre utility. Tuttavia, su questo fronte, ancora nulla è confermato al 100%, ma il nostro team sta esplorando attivamente diversi utilizzi potenziali (ad esempio, utilizzare $MTD per acquistare NFT).</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità 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, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>