Z2F0ZUxpdmUgQU1BIFJlY2FwIC0gTWljcm92aXNpb25DaGFpbg==

2024-03-01, 02:53

<p><img src="https://gimg2.gateimg.com/image/article/1709261597blog.jpg" alt=""></p>
<h2 id="h2-Zelfintroductie893544"><a name="Zelfintroductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zelfintroductie</h2><p>MVC team:<br>Jason: Hallo, ik ben Jason. Ik ben de COO van MVC. Bedankt dat jullie vandaag deelnemen aan de MVC AMA op Gate.io.</p>
<p>Rachel: Hallo allemaal. Ik ben Rachel.<br>Ik ben een van de MVC DAO-commissieleden en vroege bijdragers. Ik raakte in 2018 betrokken bij de hele blockchain scene, waar ik bezig was met operationele en marketing zaken. In 2021 ben ik me echt gaan verdiepen in het UTXO-ecosysteem en ben ik betrokken geraakt bij de geboorte van MVC. En met alle opwinding rond BTC Layer2 op dit moment, ben ik super enthousiast om hier in deze AMA te zijn en te delen over MVC en waarom het de beste keuze is voor BTC’s sidechain en schaaloplossing. Grote dank aan de gastheer en Gate dat ze mij hebben uitgenodigd. Dank je wel.</p>
<p>Ken: Hallo, leuk om vandaag het Gate.io-publiek bij me te hebben, mijn naam is Ken. Ik ben 2 maanden geleden lid geworden van MVC. Ik werkte tot voor kort bij een BTC-geldautomaatleverancier in Europa sinds 2019. Mijn voornaamste taak was om zoveel mogelijk BTC-geldautomaten in heel Europa te faciliteren. Mensen kunnen gewoon de QR-code scannen met onze app en lokale valuta opnemen bij de geldautomaat. Sindsdien zag ik dat steeds meer mensen de geldautomaten op dat moment gebruikten en ik werd 100% voorstander van BTC.</p>
<p>Echter, in de loop van de tijd heb ik gemerkt dat de hoge kosten van Bitcoin-transacties de grootste hindernis zullen zijn voor de algemene acceptatie van Bitcoin. Bijvoorbeeld, het minimumbedrag om geld op te nemen bij een Bitcoin-automaat is 100 euro, met een vergoeding van 5 euro. Het probleem van transactiekosten kan tijdens perioden van snelle <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> groei, maar het wordt vooral merkbaar tijdens stabiele of dalende <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> prijzen. MVC kan dit probleem effectief en permanent oplossen, met lage transactiekosten en snelle transactiesnelheden. Als je op Twitter kijkt, zie je gemakkelijk dat we in augustus vorig jaar instant transacties kunnen doen met het betalen van $Space, wat een mijlpaal is voor MVC. Voor mij is het besluit om deel uit te maken van het ecosysteem dat de industrie verandert, genomen. MVC heeft consequent elk plan uitgevoerd dat op zijn Gitbook staat vermeld, en is op de goede weg. In de nabije toekomst zullen MVC-gerelateerde projecten, tokens en apps aanzienlijk waardevol worden.</p>
<h2 id="h2-Q120Het20concept20van20BTC20Layer20220is20nu20erg20populair20Kunt20u20ons20een20korte20introductie20geven20over20MicrovisionChain20MVC20en20wat20het20onderscheidt20van20andere20BTC20Layer20220ecoen336745"><a name="Q1: Het concept van BTC Layer 2 is nu erg populair. Kunt u ons een korte introductie geven over MicrovisionChain (MVC) en wat het onderscheidt van andere BTC Layer 2 ecoen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Het concept van BTC Layer 2 is nu erg populair. Kunt u ons een korte introductie geven over MicrovisionChain (MVC) en wat het onderscheidt van andere BTC Layer 2 ecoen?</h2><p>Jason:<br>Korte introductie:<br>MVC is niet alleen een concept of een ppt; het is vandaag een volledig functionele Bitcoin sidechain scaling oplossing!</p>
<p>Voorheen, voordat het MVC bestond, werd het UTXO-model bekritiseerd vanwege de beperkingen, waaronder het ontbreken van Turing-volledige Layer-1 slimme contracten en op accounts gebaseerde identificatiemiddelen. Echter, door innovatieve ontwikkelingen zoals de BVM en cross-chain gedecentraliseerde DID-oplossing [MetaID], heeft MVC het landschap van schaaloplossingen getransformeerd zonder te vertrouwen op het traditionele op accounts gebaseerde EVM-model.</p>
<p>Het succes van MVC is niet alleen een theorie, maar een realiteit die wordt aangetoond door zijn Mainnet, dat al meer dan een jaar succesvol draait, verder bewezen door vele volledig functionele on-chain dApps, de geweldige ervaring van gebruikers en de MVC’s POW-hashsnelheid die consequent in de wereldwijde TOP 3 staat (en zelfs de TOP 2 bereikt). Uit statistieken blijkt dat het MVC-netwerk meer dan 20.000 houdende adressen heeft, met een sterke, ondersteunende wereldwijde community.</p>
<p>Wat MVC onderscheidt van andere oplossingen op basis van functie:<br>Eén belangrijk aspect dat BVM op MVC onderscheidt, is de focus op 0-bevestigingstransacties en ultra-lage kosten, gedemonstreerd door projecten als mvcswap en show3.io. Deze toepassingen tonen de mogelijkheid tot directe transacties en innovatieve functies zoals sociale financiën (socialfi) en gedecentraliseerde autonome organisatie (DAO) governance, allemaal aangedreven door MVC’s UTXO-gebaseerde layer 1 smart contracts.</p>
<p>Wat MVC onderscheidt van andere oplossingen van de stichting:<br>MVC’s expertise in UTXO-technologie, met meer dan 3 jaar aan gezamenlijke ontwikkeling, plaatst het uniek om ongeëvenaarde creativiteit en efficiëntie naar het BTC-ecosysteem te brengen. Als de enige geauditeerde UTXO Bitcoin-sidechain-oplossing zal de geloofwaardigheid van MVC verder worden versterkt door een aankomende Certik-audit, waarmee het zijn toewijding aan veiligheid en betrouwbaarheid onderstreept.</p>
<p>In het kort vertegenwoordigt BVM &amp; MVC een grote sprong voorwaarts voor Bitcoin, waarbij nieuwe mogelijkheden voor innovatie en groei worden geopend binnen de gate. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosysteem.</p>
<h2 id="h2-Q220Daarnaast20heb20je20zojuist20de20hashkracht20van20MVC20genoemd20Kun20je20ons20kort20introduceren20wat20BVM20is20en20welke20impact20het20zal20hebben20op20het20volgende20ecosysteem20van20BTC853058"><a name="Q2: Daarnaast heb je zojuist de hashkracht van MVC genoemd. Kun je ons kort introduceren wat BVM is en welke impact het zal hebben op het volgende ecosysteem van BTC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Daarnaast heb je zojuist de hashkracht van MVC genoemd. Kun je ons kort introduceren wat BVM is en welke impact het zal hebben op het volgende ecosysteem van BTC?</h2><p>Jason:<br>Laat me een beeld schetsen van de baanbrekende Bitcoin Virtual Machine (BVM) en de diepgaande impact ervan op het BTC-ecosysteem.</p>
<p>BVM: Game-Changer Concept MVC introduceert voor het eerst in mei 2023 aan de wereld:<br>De Bitcoin Virtual Machine (BVM) is een game-changer die de Bitcoin-landschap zal transformeren door bitcoin-code programmeerbaar te maken met Turing-complete slimme contracten en 1:1 satoshi-mapping, mits MVC dezelfde technische structuur als bitcoin heeft. Bitcoin-ecosysteemtoepassingen en -infrastructuur zoals wallets en NFT-markten kunnen gemakkelijk ondersteuning toevoegen voor MVC zonder uitgebreide extra ontwikkeling te vereisen. Ondertussen kan het in theorie elk soort toepassing vergelijkbaar met <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>‘s EVM. Deze innovatie stelt ontwikkelaars in staat om diverse toepassingen te creëren, waaronder DeFi-platforms en DApps zoals <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> en Lido.</p>
<p>Impact op het volgende ecosysteem van Bitcoin:<br>Stel je een wereld voor waar Bitcoin transacties snel zijn, de kosten minimaal zijn en de mogelijkheden voor dapps eindeloos zijn. Maak kennis met BVM, de game-changer die, in combinatie met MVC, lage transactiekosten, hoge doorvoer en een functierijke omgeving biedt met Turing-complete slimme contracten.</p>
<p>In een landschap waar gedecentraliseerde applicaties (dApps) op Bitcoin worden geconfronteerd met obstakels zoals buitensporige Gas-kosten, komt MVC naar voren als de oplossing om de massale adoptie vooruit te stuwen. Stel je een toekomst voor waarin transacties verzenden niet gepaard gaat met een stevig prijskaartje van 30 USD, 50 USD of zelfs 500 USDT aan kosten. Hoeveel gebruikers zouden dat accepteren? Het kantelpunt is nabij en vraagt om een schaalbare oplossing voor sidechains.</p>
<p>MVC stapt in als de baken van hoop, en biedt een naadloze ervaring voor het gebruik van het ordinaal protocol, BRC-20 tokens en diverse toekomstige bitcoin protocol tokens, vrij van congestie en buitensporige kosten. De Bitcoin Virtual Machine (BVM) revolutioneert het spel door Bitcoin in staat te stellen EVM-achtige applicaties efficiënt te hosten op sidechain MVC, en legt daarmee de basis voor applicatie-ontwikkeling en gebruiksvriendelijke innovatie.</p>
<p>Kortom, BVM is niet zomaar een upgrade; het is een sprong naar een toekomst waarin het potentieel van Bitcoin geen grenzen kent. Maak je klaar om de evolutie van BTC te aanschouwen, met MVC en BVM aan het roer van een meer efficiënt, toegankelijk en dynamisch blockchain-ecosysteem.</p>
<p>Rachel: Ik merk de laatste tijd veel projecten op met concepten die lijken op BVM, maar ze zijn niet helemaal zoals MicrovisionChain. Dit is waarom: Ten eerste bevinden velen van hen zich nog in de PowerPoint-fase. Het mainnet van MicrovisionChain was meer dan een jaar live en er draaiden tientallen dApps op. Ten tweede hebben ze geen puur Layer1 smart contract, vooral niet gebaseerd op dezelfde UTXO-structuur als Bitcoin, wat het tegenovergestelde is van MVC. En ze zijn misschien niet gedecentraliseerd en veilig genoeg zonder POW-consensus en voldoende hash-kracht, waarin MVC beter heeft gepresteerd dan veel POW-blockchains. Ten derde bieden ze niet genoeg ontwikkelaarstools om bouwers op weg te helpen. Het hele systeem kan dus moeilijk te schalen zijn.</p>
<p>Overigens heeft MVC onlangs een 100 MVC-plan geïntroduceerd, wat het echt onderscheidt van andere concurrenten. Het 100 MVC-plan heeft als doel om alle code van MVC open source te maken en bouwers aan te trekken om samen Bitcoin te schalen. We zijn erg enthousiast over de potentie om een geheel nieuw schaalnetwerk rond Bitcoin te bouwen en we verwelkomen andere teams om een voorbeeld te nemen aan MVC en zich bij ons aan te sluiten bij het bouwen van de volgende generatie internet. BVM is slechts het begin.</p>
<h2 id="h2-Q320Kun20je20ons20vertellen20wat20het20verschil20is20tussen20MVC20en20andere20gecentraliseerde20instellingen20die20werken20aan20BTC20Layer20220en20hoe20gebruikers20kunnen20bijdragen44503"><a name="Q3: Kun je ons vertellen wat het verschil is tussen MVC en andere gecentraliseerde instellingen die werken aan BTC Layer 2 en hoe gebruikers kunnen bijdragen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Kun je ons vertellen wat het verschil is tussen MVC en andere gecentraliseerde instellingen die werken aan BTC Layer 2 en hoe gebruikers kunnen bijdragen?</h2><p>Ken:<br>Allereerst is het begrijpelijk dat mensen twijfels hebben over de architectuur van MVC. Omdat in het verleden niet veel projecten onze architectuur hebben aangenomen die zo eerlijk en transparant is. Zelfs een succesvol project zoals <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> wordt nog steeds gerund door een team. Natuurlijk is het niet uitgesloten dat er voordelen zijn aan het runnen op deze manier, maar de meningen van gewone deelnemers zullen onbeduidend worden. De directe gevolgen hiervan zullen onvoldoende deelname in de gemeenschap zijn, trage ontwikkeling van projecten gerelateerd aan de publieke keten, en uiteindelijk de groei van het project belemmeren. Daarom is de MVC-architectuur in staat om mensen te motiveren om betrokken te zijn en verantwoordelijk te zijn voor de gemeenschapsontwikkeling.</p>
<p>De logica is eenvoudig. Allereerst moet de persoon die stemt eigenaar zijn van $Space en komt één $Space overeen met één stemrecht. Het directe voordeel van hun deelname aan de besluitvorming is dat de resultaten van elke beslissing tot uiting zullen komen in de ontwikkeling van het project en de stijging of daling van de $Space-prijs. Hierdoor zullen alle gewone leden de geest van eigendom en deelname hebben, wat de basis is van een gedecentraliseerde autonome organisatie. We noemen het DAO.</p>
<p>Op een ander niveau moet de architectuur van MVC persistent en continu werken, dus MVC kan niet de architectuur aannemen van andere instellingen die momenteel op de markt zijn. Ter illustratie, iedereen kent Elon Musk, de oprichter van Tesla, maar hij heeft nu een andere rol als eigenaar van Twitter. Vorig jaar heeft hij Twitter overgenomen en het hernoemd naar X. Ik zal hier drie vragen stellen:</p>
<ol>
<li>Welk deel van de mensen is daadwerkelijk bereid om de naam van het bedrijf te veranderen van Twitter naar X?</li><li>Als Elon Musk in de toekomst het bedrijf niet meer bezit of overlijdt, is het dan mogelijk dat het bedrijf weer Twitter genoemd wordt?</li><li>Als gewone Twitter-gebruikers, zullen onze stemmen gehoord worden en invloed hebben op de uiteindelijke beslissingen?</li></ol>
<p>Om eerlijkheid en duurzaamheid te waarborgen, maakt MVC gebruik van een verkiezingsmechanisme. Dit systeem, dat zich uitstrekt over duizenden jaren van het oude Griekenland tot op de dag van vandaag, is door de tijd heen bewezen in staat te zijn om te blijven bestaan. Het superieure mechanisme van MVC, net als Bitcoin, zal zelfs voor onze toekomstige generaties blijven bestaan. Ons huidige model is al succesvol in de praktijk toegepast, met commissies en verschillende administratieve bijdragers die al zijn opgericht. Verkiezingen worden gehouden door middel van een consensus van gewone Space-eigenaren en worden al meer dan een jaar succesvol uitgevoerd.</p>
<h2 id="h2-Q420Hoge20gasvergoedingen20en20trage20snelheden20zijn20bekende20problemen20met20BTC20Hoe20gaat20MVC20deze20twee20belangrijke20pijnpunten20van20BTC20aanpakken20Wanneer20kunnen20we20de20prestaties20van20MVC20verwachten985178"><a name="Q4: Hoge gasvergoedingen en trage snelheden zijn bekende problemen met BTC. Hoe gaat MVC deze twee belangrijke pijnpunten van BTC aanpakken? Wanneer kunnen we de prestaties van MVC verwachten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Hoge gasvergoedingen en trage snelheden zijn bekende problemen met BTC. Hoe gaat MVC deze twee belangrijke pijnpunten van BTC aanpakken? Wanneer kunnen we de prestaties van MVC verwachten?</h2><p>Jason:<br>Introductie van congestieprobleem op Bitcoin:<br>De congestie op Bitcoin [Hoge gasvergoedingen en trage transactiesnelheid] wordt voornamelijk veroorzaakt door de stijging in netwerkgebruik en activiteit, wat typisch het maken van transacties, BRC-20 DApps en bitcoin ecosysteem DeFi platforms inhoudt.<br>Traditionele schaalbaarheidsoplossingen, zoals het vergroten van blokgrootte, werden beperkt door de nadruk van Bitcoin op decentralisatie. Als gevolg hiervan richtte de wereld zich op laag 2 en sidechain-oplossingen om het congestieprobleem van bitcoin aan te pakken.<br>Operationeel kader hoe MVC het congestieprobleem van bitcoin aanpakt:<br>Sidechains functioneren zoals MVC als onafhankelijke blockchains die verbonden zijn met het bitcoin-netwerk via een tweerichtingsbrug, waardoor hetzelfde portefeuilleadres mogelijk is. Deze verbinding vergemakkelijkt de naadloze overdracht van activa tussen bitcoin en de sidechain MVC.<br>Bitcoin en bitcoin ecosysteem activa worden op het bitcoin-netwerk overgedragen via peg-in mechanismen, waarbij equivalent hoeveelheden tokens op de sidechain MVC worden gecreëerd. Peg-out processen maken het mogelijk om de equivalent hoeveelheid token op te vragen door het verbranden van sidechain tokens.<br>Wanneer kunnen we de superieure prestaties van MVC sidechain verwachten?<br>Nou, het goede nieuws is dat de toekomst helder en nabij is! De testnet van de brug is bijna klaar met een geschatte voltooiing eind maart of begin april.<br>Zodra Bitcoin en ecosysteemactiva van het bitcoin-netwerk naar sidechain-netwerk zoals MVC zijn overgebracht, behouden ze naadloos hun eigenschappen, en MVC onderscheidt zich door applicaties binnen het BTC-ecosysteem te laten profiteren van activa op het MVC-netwerk met lagere kosten en een congestievrije omgeving. Door gebruik te maken van deze unieke aanpak opent MVC de deur voor massale adoptie van het gebruik van bitcoin met een efficiëntere en naadloze ervaring in het rijk van DEFI en massaal diverse WEB3-applicaties.</p>
<p>Rachel: Laat me nog een ander project introduceren genaamd orders.exchange, ticker $RDEX, dat al genoteerd staat op Gate.io. Het zal een perfect project zijn om de kracht en prestaties van MicrovisionChain te laten zien. Het is de eerste DEX op BTC om orderboeken, swaps en bridges te aggregaten, en het is ingesteld om in de toekomst MVC te ondersteunen, waardoor de kloof tussen BTC en MVC op Layer1 en Layer2 wordt overbrugd.</p>
<p>Als gebruikers MVC als de top sidechain willen ervaren, is orders.exchange de manier om te gaan. Ik heb gehoord dat ze drie functies zullen uitrollen in maart, waardoor het de meest competitieve gedecentraliseerde exchange op BTC wordt. Gebruikers zullen extreme lage kosten en snelle BTC- en BRC20-handel rechtstreeks via deze DEX kunnen ervaren.</p>
<h2 id="h2-Q520Tot20slot20wat20betreft20de20ecologische20implementatie20MVC20bereidt20zich20voor20om20de20langverwachte20activabrug20te20lanceren20en20is20van20plan20om20miljoenen20dollars20toe20te20wijzen20om20het20MVC20Builder20Grantprogramma20te20ondersteunen20Zou20u20de20laatste20ontwikkelingen20met20het20publiek20willen20delen118923"><a name="Q5: Tot slot, wat betreft de ecologische implementatie. MVC bereidt zich voor om de langverwachte activabrug te lanceren en is van plan om miljoenen dollars toe te wijzen om het MVC Builder Grant-programma te ondersteunen. Zou u de laatste ontwikkelingen met het publiek willen delen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Tot slot, wat betreft de ecologische implementatie. MVC bereidt zich voor om de langverwachte activabrug te lanceren en is van plan om miljoenen dollars toe te wijzen om het MVC Builder Grant-programma te ondersteunen. Zou u de laatste ontwikkelingen met het publiek willen delen?</h2><p>Jason:<br>MVCDAO zal tot 200.000 qyt van Space munten sponsoren om MVC app ontwikkelaars te belonen en zo de groei van het ecosysteem te bevorderen. Bouwer Grant voorstellen worden door het comité beoordeeld, met details die in maart bekend zullen worden gemaakt. Goedgekeurde ontwikkelaars zullen vervolgens Space munten ontvangen als beloning na de voltooiing van de dapp.</p>
<p>Spannende perspectieven wachten met de adoptie van het MVC-netwerk in de toekomst, waarbij praktische Bitcoin-micropayments en real-world asset pricing in Bitcoin op het MVC-netwerk worden voorzien. Verwacht verbeterde gebruikerservaringen bij Bitcoin pinautomaten, e-commerce en meer, waarbij gebruik wordt gemaakt van de lage kosten en Bitcoin-integratie van MVC. Met MVC zijn de mogelijkheden van blockchain onbeperkt, hierboven staan slechts een paar spannende vooruitzichten voor toekomstige ontwikkelaarsreferentie.</p>
<p>Maak je klaar voor een reis naar een gedecentraliseerde en veilige Web3-wereld, met MVC voorop in innovatie. Blijf op de hoogte voor een toekomst waarin elk web2-internetgebruik werkelijkheid wordt in <a href="/web3" target="_blank" class="blog_inner_link">web3</a> met de kracht van MVC en Bitcoin. MVC staat klaar om het voortouw te nemen in een nieuw tijdperk van mogelijkheden!</p>
<p>MVC, een door de wereldwijde gemeenschap gedreven DAO, staat op het punt van opmerkelijke groei en adoptie. De genoemde perspectieven en adoptiescenario’s benadrukken de noodzaak voor diverse ontwikkelaars wereldwijd om gebruik te maken van builder grants. Doe met ons mee om de toekomst van de Bitcoin en blockchain-industrie vorm te geven! We evolueren voortdurend en verwelkomen meer ontwikkelaars om samen het onbegrensde potentieel van MVC te ontsluiten.</p>
<h2 id="h2-Conclusie520116"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>MVC-team:<br>Maak je klaar voor een reis naar een gedecentraliseerde en veilige Web3-wereld, met MVC voorop in innovatie. Blijf op de hoogte van een toekomst waarin elk web2-internetgebruik werkelijkheid wordt in web3 met de kracht van MVC en Bitcoin. MVC staat klaar om de leiding te nemen in een nieuw tijdperk van mogelijkheden!</p>
<p>Laten we samen meedoen om de toekomst van de bitcoin- en blockchain-industrie vorm te geven! We zijn voortdurend in ontwikkeling en nodigen meer ontwikkelaars uit om samen het onbegrensde potentieel van MVC te ontsluiten.</p>
<div class="blog-details-info"><br><div>Auteur: GateLive, Gate.io Team<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt zich alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>