Z2F0ZUxpdmUgQU1BIFJlY2FwIC0gTWljcm92aXNpb25DaGFpbg==

2024-03-01, 02:53

<p><img src="https://gimg2.gateimg.com/image/article/1709261597blog.jpg" alt=""></p>
<h2 id="h2-Auto20Presentazione273907"><a name="Auto Presentazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Auto Presentazione</h2><p>Team MVC:<br>Jason: Ciao, sono Jason. Sono il COO di MVC. Grazie a tutti per esservi uniti all’AMA di MVC di oggi su Gate.io.</p>
<p>Rachel: Ciao a tutti. Sono Rachel.<br>Sono uno dei membri del comitato MVC DAO e uno dei primi contributori. Mi sono avvicinata al mondo delle blockchain nel 2018, occupandomi di operazioni e marketing. Nel 2021, ho iniziato a esplorare l’ecosistema UTXO e sono stata coinvolta nella nascita di MVC. E con tutta l’euforia attorno a BTC Layer2 in questo momento, sono entusiasta di essere qui in questa AMA, condividendo informazioni su MVC e perché è la scelta migliore per il sidechain e la soluzione di scaling di BTC. Un grande ringraziamento all’host e a Gate per avermi invitato. Grazie.</p>
<p>Ken: Ciao, è bello avere l’audience di Gate.io con me oggi, mi chiamo Ken. Mi sono unito a MVC solo 2 mesi fa. Prima lavoravo per un fornitore di bancomat BTC in Europa dal 2019. Il mio lavoro principale era cercare di facilitare il maggior numero possibile di bancomat BTC in tutta Europa. Le persone potevano semplicemente scannerizzare il codice QR con la nostra app e prelevare la valuta locale dal bancomat. Da allora, ho visto sempre più persone utilizzare i bancomat in quel periodo e sono diventato un sostenitore al 100% del BTC.</p>
<p>Tuttavia, nel tempo, ho scoperto che gli alti costi delle transazioni <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> saranno il più grande ostacolo all’adozione mainstream di Bitcoin. Ad esempio, il minimo per prelevare denaro da un bancomat Bitcoin è di 100 euro, con una commissione di 5 euro. La questione delle commissioni di transazione può sembrare insignificante in periodi di rapida <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo Bitcoin</a> la crescita, ma diventa particolarmente evidente durante i prezzi stabili o in diminuzione di Bitcoin. MVC può risolvere in modo efficace e permanente questo problema, offrendo commissioni di transazione basse e velocità di transazione istantanee. Se vai su Twitter, è facile vedere che siamo in grado di effettuare transazioni istantanee con pagamento in $Space ad agosto dello scorso anno, che è una pietra miliare di MVC. Per me, al fine di diventare parte dell’ecosistema che cambia l’industria, ho deciso di unirmi a MVC. MVC ha implementato in modo costante ogni piano elencato sul suo Gitbook, progredendo nella giusta direzione. In un futuro prevedibile, i progetti, i token e le app correlati a MVC diventeranno significativamente preziosi.</p>
<h2 id="h2-Q120Il20concetto20di20BTC20Layer2022020molto20popolare20ora20Ci20puoi20dare20una20breve20introduzione20su20MicrovisionChain20MVC20e20cosa20lo20distingue20dagli20altri20ecosistemi20di20BTC20Layer202871090"><a name="Q1: Il concetto di BTC Layer 2 è molto popolare ora. Ci puoi dare una breve introduzione su MicrovisionChain (MVC) e cosa lo distingue dagli altri ecosistemi di BTC Layer 2?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Il concetto di BTC Layer 2 è molto popolare ora. Ci puoi dare una breve introduzione su MicrovisionChain (MVC) e cosa lo distingue dagli altri ecosistemi di BTC Layer 2?</h2><p>Jason:<br>Breve introduzione:<br>MVC non è solo un concetto o una presentazione; è oggi una soluzione di scaling di sidechain Bitcoin completamente funzionale e in tempo reale!</p>
<p>Precedentemente, prima dell’esistenza di MVC, il modello UTXO ha ricevuto critiche per le sue limitazioni, tra cui l’assenza di contratti intelligenti Turing-Complete di livello 1 e identificatori basati su conto. Tuttavia, attraverso innovativi progressi come BVM e la soluzione DID decentralizzata cross-chain [MetaID], MVC ha trasformato il panorama delle soluzioni di scalabilità senza fare affidamento sul tradizionale modello basato su conti EVM.</p>
<p>Il successo di MVC non è solo una teoria ma una realtà dimostrata attraverso il suo Mainnet, che funziona con successo da oltre un anno, ulteriormente dimostrato da molti dApps completamente funzionali on-chain, un’ottima esperienza degli utenti e il tasso di hash di MVC POW costantemente nei primi 3 (e anche raggiungendo il secondo posto) a livello globale. Dalle statistiche, la rete MVC ha oltre 20.000 indirizzi che la detengono, con una forte e solidale comunità globale.</p>
<p>Cosa distingue MVC da altre soluzioni per funzionalità:<br>Un aspetto chiave che differenzia BVM su MVC è il suo focus sulle transazioni a 0 conferme e le commissioni ultra-basse, dimostrate da progetti come mvcswap e show3.io. Queste applicazioni mostrano capacità di transazione istantanee e funzionalità innovative come il social finance (socialfi) e la governance di organizzazioni autonome decentralizzate (DAO), tutto alimentato dai contratti intelligenti di MVC basati su UTXO di livello 1.</p>
<p>Cosa differenzia MVC da altre soluzioni della fondazione:<br>L’esperienza di MVC nella tecnologia UTXO, con oltre 3 anni di sviluppo collaborativo, lo posiziona in modo unico per portare creatività ed efficienza senza precedenti all’ecosistema BTC. Come unica soluzione di sidechain Bitcoin UTXO sottoposta ad audit, la credibilità di MVC sarà ulteriormente consolidata da un prossimo audit Certik, rafforzando il suo impegno per la sicurezza e l’affidabilità.</p>
<p>In sintesi, BVM &amp; MVC rappresenta un significativo passo avanti per Bitcoin, aprendo nuove possibilità di innovazione e crescita all’interno del <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosistema.</p>
<h2 id="h2-Q220Inoltre20hai20appena20menzionato20la20potenza20di20hash20di20MVC20Puoi20brevemente20presentarci20cos20BVM20e20quale20impatto20avr20sullecosistema20successivo20di20BTC386182"><a name="Q2: Inoltre, hai appena menzionato la potenza di hash di MVC. Puoi brevemente presentarci cos’è BVM e quale impatto avrà sull’ecosistema successivo di BTC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Inoltre, hai appena menzionato la potenza di hash di MVC. Puoi brevemente presentarci cos’è BVM e quale impatto avrà sull’ecosistema successivo di BTC?</h2><p>Jason:<br>Permettimi di dipingere un quadro della rivoluzionaria Bitcoin Virtual Machine (BVM) e del suo profondo impatto sull’ecosistema BTC.</p>
<p>BVM: Concetto rivoluzionario MVC introdotto per la prima volta nel maggio 2023 al mondo:<br>Il Bitcoin Virtual Machine (BVM) è destinato a cambiare il panorama del Bitcoin consentendo la programmabilità del codice bitcoin con contratti intelligenti Turing-complete e mappatura 1:1 dei satoshi, considerando che MVC ha la stessa struttura tecnica del bitcoin, le applicazioni e l’infrastruttura dell’ecosistema bitcoin come portafogli e mercati NFT, possono facilmente aggiungere il supporto per MVC senza richiedere uno sviluppo aggiuntivo estensivo. Nel frattempo, in teoria, può stabilire qualsiasi tipo di applicazioni simili a <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’EVM di Gate.io. Questa innovazione permette agli sviluppatori di creare diverse applicazioni, inclusi piattaforme DeFi e DApp come <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> e Lido.</p>
<p>Impatto sull’ecosistema successivo di Bitcoin:<br>Immagina un mondo in cui le transazioni Bitcoin sono rapide, le commissioni sono minime e le possibilità di dapps sono infinite. Entra in gioco BVM, il game-changer che, combinato con MVC, offre costi di transazione bassi, un’elevata capacità di elaborazione e un ambiente ricco di funzionalità che vanta smart contract Turing-complete.</p>
<p>In un panorama in cui le applicazioni decentralizzate (dApps) su Bitcoin si trovano di fronte a ostacoli come tariffe esorbitanti di Gas, MVC emerge come la soluzione per spingere avanti l’adozione di massa. Immaginate un futuro in cui inviare transazioni non comporta un costo eccessivo di 30 USD, 50 USD o persino 500 USDT. Quanti utenti sopporterebbero questo? Il punto di svolta è vicino, esigendo una soluzione scalabile di sidechain.</p>
<p>MVC entra in gioco come faro di speranza, offrendo un’esperienza senza soluzione di continuità per utilizzare il protocollo ordinale, i token BRC-20 e vari futuri token del protocollo Bitcoin, liberi da congestione e commissioni eccessive. La Macchina Virtuale Bitcoin (BVM) rivoluziona il gioco consentendo a Bitcoin di ospitare applicazioni simili all’EVM in modo efficiente su sidechain MVC, aprendo la strada al progresso delle applicazioni e all’innovazione user-friendly.</p>
<p>In poche parole, BVM non è solo un aggiornamento; è un salto in un futuro in cui il potenziale di Bitcoin non conosce limiti. Preparati a vedere l’evoluzione di BTC con MVC e BVM che guidano l’assalto verso un ecosistema blockchain più efficiente, accessibile e dinamico.</p>
<p>Rachel: Negli ultimi tempi ho notato molti progetti che stanno emergendo con concetti simili a BVM, ma non sono esattamente come MicrovisionChain. Ecco perché: Innanzitutto, molti di loro sono ancora nella fase di PowerPoint. La mainnet di MicrovisionChain è attiva da oltre un anno, con decine di dApp in esecuzione. In secondo luogo, non hanno un contratto intelligente di livello 1 puro, basato sulla stessa struttura UTXO di Bitcoin, che è l’opposto di MVC. E potrebbero non essere sufficientemente decentralizzati e sicuri senza il consenso POW e una potenza di hash sufficiente, in cui MVC ha superato molte blockchain POW. In terzo luogo, non offrono strumenti sufficienti agli sviluppatori per iniziare. Quindi l’intero sistema potrebbe essere difficile da scalare.</p>
<p>In un altro ordine di idee, MVC ha recentemente introdotto un piano MVC 100, che lo distingue davvero dagli altri concorrenti. Il piano 100 MVC mira a rendere open source tutto il codice di MVC e ad attirare costruttori per scalare bitcoin insieme. Siamo davvero entusiasti delle potenzialità di creare una nuova rete di scalabilità intorno a bitcoin e diamo il benvenuto ad altre squadre a prendere un esempio dal libro di MVC e unirsi a noi nella costruzione della prossima generazione di internet. BVM è solo l’inizio.</p>
<h2 id="h2-Q320Puoi20dirci20qual2020la20differenza20tra20MVC20e20altre20istituzioni20centralizzate20che20lavorano20sul20BTC20Layer20220e20come20gli20utenti20possono20contribuire846683"><a name="Q3: Puoi dirci qual è la differenza tra MVC e altre istituzioni centralizzate che lavorano sul BTC Layer 2 e come gli utenti possono contribuire?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Puoi dirci qual è la differenza tra MVC e altre istituzioni centralizzate che lavorano sul BTC Layer 2 e come gli utenti possono contribuire?</h2><p>Ken:<br>Innanzitutto, è comprensibile che le persone abbiano dubbi sull’architettura di MVC. Perché in passato, non molti progetti hanno adottato la nostra architettura che è così equa e trasparente. Anche un progetto di successo come <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> è ancora gestito da un team. Naturalmente, non è escluso che ci siano meriti nel gestire in questo modo, ma le opinioni dei partecipanti ordinari diventeranno insignificanti. Le conseguenze dirette di ciò saranno la partecipazione insufficiente alla comunità, lo sviluppo lento dei progetti correlati alla catena pubblica e, alla fine, frenare la crescita del progetto. Pertanto, l’architettura MVC è in grado di motivare le persone ad essere coinvolte e responsabili per lo sviluppo della comunità.</p>
<p>La logica è semplice. Innanzitutto, la persona che vota deve essere il proprietario di $Space e uno $Space corrisponde a un diritto di voto. Il beneficio diretto della loro partecipazione alle decisioni di voto è che i risultati di ogni decisione saranno riflessi nello sviluppo del progetto e nell’andamento del prezzo di $Space. In questo modo, tutti i membri ordinari avranno lo spirito di proprietà e partecipazione che è la base dell’Organizzazione Autonoma Decentralizzata. Lo chiamiamo DAO.</p>
<p>Ad un altro livello, l’architettura di MVC deve persistere e operare continuamente, quindi MVC non può adottare l’architettura di altre istituzioni attualmente presenti sul mercato. A titolo di esempio, tutti conoscono Elon Musk, il fondatore di Tesla, ma ora ha un altro ruolo come proprietario di Twitter. L’anno scorso ha acquisito Twitter e lo ha riposizionato come X. Qui porrò tre domande:</p>
<ol>
<li>Quale proporzione di persone è effettivamente disposta a cambiare il nome dell’azienda da Twitter a X?</li><li>Se Elon Musk non è più proprietario dell’azienda o muore in futuro, è possibile che l’azienda torni a chiamarsi Twitter?</li><li>Come comuni utenti di Twitter, le nostre voci verranno ascoltate e influenzeranno le decisioni finali?</li></ol>
<p>Per garantire equità e sostenibilità, MVC adotta un meccanismo di elezione tramite voto. Questo sistema, che si estende per migliaia di anni dall’antica Grecia ai giorni nostri, è stato dimostrato nel tempo essere in grado di resistere. Il meccanismo superiore di MVC, simile a Bitcoin, persiste anche per le nostre future generazioni. Il nostro modello attuale è già stato implementato con successo nella pratica, con comitati e vari contributori amministrativi già stabiliti. Le elezioni sono condotte da un consenso dei comuni proprietari dello spazio e si svolgono con successo da oltre un anno.</p>
<h2 id="h2-Q420Le20commissioni20elevate20e20le20velocit20ridotte20sono20problemi20ben20noti20di20BTC20Come20affronta20MVC20questi20due20grandi20punti20critici20di20BTC20Quando20possiamo20aspettarci20di20sperimentare20le20prestazioni20di20MVC549035"><a name="Q4: Le commissioni elevate e le velocità ridotte sono problemi ben noti di BTC. Come affronta MVC questi due grandi punti critici di BTC? Quando possiamo aspettarci di sperimentare le prestazioni di MVC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Le commissioni elevate e le velocità ridotte sono problemi ben noti di BTC. Come affronta MVC questi due grandi punti critici di BTC? Quando possiamo aspettarci di sperimentare le prestazioni di MVC?</h2><p>Jason:<br>Introduzione del problema di congestione su Bitcoin:<br>La congestione su Bitcoin [Alte commissioni di gas e lentezza delle transazioni] è principalmente causata dall’aumento dell’uso e dell’attività di rete, che di solito riguarda le transazioni, le DApp BRC-20 e le piattaforme DeFi dell’ecosistema Bitcoin.<br>Le soluzioni di scalabilità tradizionali, come l’aumento delle dimensioni dei blocchi, erano limitate dall’enfasi di Bitcoin sulla decentralizzazione. Di conseguenza, il mondo si è concentrato sulle soluzioni di layer 2 e sidechain per affrontare il problema di congestione di Bitcoin.<br>Il framework operativo di come MVC affronta il problema di congestione di Bitcoin:<br>Le sidechain funzionano come MVC come blockchain indipendenti collegate alla rete Bitcoin attraverso un ponte a doppia direzione che consente lo stesso indirizzo del portafoglio. Questa connessione facilita il trasferimento senza soluzione di continuità degli asset tra Bitcoin e la sidechain MVC.<br>Gli asset di Bitcoin e dell’ecosistema Bitcoin vengono trasferiti sulla rete Bitcoin tramite meccanismi di peg-in, creando quantità equivalenti di token sulla sidechain MVC. I processi di peg-out consentono il recupero della quantità equivalente di token bruciando i token della sidechain.<br>Quando possiamo aspettarci le prestazioni superiori della sidechain MVC?<br>Beh, la buona notizia è che il futuro è luminoso e vicino! Il testnet del ponte è vicino al completamento, con il completamento previsto entro la fine di marzo o l’inizio di aprile.<br>Una volta che gli asset di Bitcoin e dell’ecosistema vengono collegati dalla rete Bitcoin alla rete della sidechain come MVC, mantengono le loro proprietà senza soluzione di continuità, e MVC si distingue consentendo alle applicazioni dell’ecosistema BTC di utilizzare gli asset sulla rete MVC con commissioni più basse e un ambiente privo di congestione. Sfruttando questo approccio unico, MVC apre la porta a una massiccia adozione dell’uso di Bitcoin con un’esperienza più efficiente e senza soluzione di continuità nel campo delle applicazioni DEFI e delle massicce applicazioni <a href="/web3" target="_blank" class="blog_inner_link">WEB3</a> diverse.</p>
<p>Rachel: Permettetemi di presentarvi un altro progetto chiamato orders.exchange, ticker $RDEX, che è già quotato su Gate.io. Sarà un progetto perfetto per mostrare la potenza e le prestazioni di MicrovisionChain. È il primo DEX su BTC a aggregare ordini, scambi e ponti, ed è destinato a supportare MVC in futuro, colmando il divario tra BTC e MVC su Layer1 e Layer2.</p>
<p>Se gli utenti vogliono sperimentare MVC come la sidechain principale, orders.exchange è la strada da seguire. Ho sentito dire che stanno lanciando tre funzionalità a marzo, rendendolo lo scambio decentralizzato più competitivo su BTC. Gli utenti potranno sperimentare commissioni estremamente basse e trading BTC e BRC20 ad alta velocità direttamente tramite questo DEX.</p>
<h2 id="h2-Q520Infine20riguardo20allimplementazione20ecologica20MVC20sta20preparando20il20lancio20del20ponte20di20asset20molto20atteso20e20sta20pianificando20di20allocare20milioni20di20dollari20per20sostenere20il20programma20di20sovvenzione20del20MVC20Builder20Potresti20condividere20gli20ultimi20sviluppi20con20il20pubblico72513"><a name="Q5: Infine, riguardo all’implementazione ecologica. MVC sta preparando il lancio del ponte di asset molto atteso e sta pianificando di allocare milioni di dollari per sostenere il programma di sovvenzione del MVC Builder. Potresti condividere gli ultimi sviluppi con il pubblico?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Infine, riguardo all’implementazione ecologica. MVC sta preparando il lancio del ponte di asset molto atteso e sta pianificando di allocare milioni di dollari per sostenere il programma di sovvenzione del MVC Builder. Potresti condividere gli ultimi sviluppi con il pubblico?</h2><p>Jason:<br>MVCDAO sponsorizzerà fino a 200.000 qyt di Space coins per premiare gli sviluppatori di app MVC, favorire la crescita dell’ecosistema. Le proposte per i Builder Grant saranno sottoposte a una revisione del comitato, i dettagli saranno rivelati a marzo. Gli sviluppatori approvati riceveranno Space coins come ricompensa dopo il completamento dell’app.</p>
<p>Emozionanti prospettive attendono l’adozione della rete MVC in futuro, immaginando pratici micropagamenti in Bitcoin e quotazioni di asset del mondo reale in Bitcoin sulla rete MVC. Ci si aspettano esperienze utente migliorate negli sportelli automatici Bitcoin, nell’e-commerce e altro ancora, sfruttando i bassi costi di MVC e l’integrazione con Bitcoin. Con MVC, le possibilità della blockchain sono illimitate, sopra sono solo alcune emozionanti prospettive per i futuri riferimenti degli sviluppatori.</p>
<p>Preparati per un viaggio verso un mondo Web3 decentralizzato e sicuro, con MVC all’avanguardia dell’innovazione. Resta sintonizzato per un futuro in cui ogni utilizzo di Internet web2 diventa realtà in web3 con il potere di MVC e Bitcoin. MVC è qui per guidare la carica in una nuova era di possibilità!</p>
<p>MVC, una DAO guidata dalla comunità globale, è pronta per una crescita e un’adozione notevoli. Le prospettive e gli scenari di adozione menzionati evidenziano la necessità che sviluppatori diversi in tutto il mondo sfruttino i finanziamenti per sviluppatori. Unisciti a noi nel plasmare il futuro dell’industria del Bitcoin e della blockchain! Siamo in continuo sviluppo e accogliamo con favore più sviluppatori per sbloccare insieme il potenziale illimitato di MVC.</p>
<h2 id="h2-Conclusion472133"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Squadra MVC:<br>Preparatevi per un viaggio verso un mondo decentralizzato e sicuro di Web3, con MVC all’avanguardia dell’innovazione. Restate sintonizzati per un futuro in cui ogni utilizzo di internet web2 diventa realtà in web3 con il potere di MVC e Bitcoin. MVC è qui per guidare l’assalto verso una nuova era di possibilità!</p>
<p>Unisciti a noi nel plasmare il futuro dell’industria del bitcoin e della blockchain! Siamo in continuo sviluppo e invitiamo più sviluppatori a sbloccare insieme il potenziale illimitato di MVC.</p>
<div class="blog-details-info"><br><div>Autore:<strong> GateLive</strong>, Team di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti 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 di violazione del copyright.<br></div><p></p><br></div></div></div>