Prefacio
El metaverso se ha vuelto popular recientemente y he estado charlando con mis amigos sobre qué es el metaverso (realidad virtual VR, un gemelo digital del mundo real), y luego hablamos sobre web3.0, hablando de manera realista sobre el metaverso y web3. .0 todavía son pensamientos vagos, pero todos tienen algunas soluciones técnicas prácticas. Hoy no hablaré sobre el metaverso (de hecho, Internet en sí es el metaverso omnipresente.
No hablaré de eso porque no sé mucho sobre la tecnología de realidad virtual, sin embargo, ya existen muchas herramientas infalibles en China, como thingjs, y Youplait Technology tiene buenos productos. en el extranjero). Hoy quiero hablar sobre web3.0, un futuro para todos. Internet que usted puede poseer; en pocas palabras, web1.0 es una red de solo lectura (que representa a NetEase), y web2.0 es una red de lectura. red de escritura (que representa Weibo y WeChat).
Las dos primeras generaciones de redes fueron redes centralizadas y era difícil garantizar los derechos de información de los usuarios de la red, es decir, era difícil confirmar los derechos de contenido. Web3.0 puede garantizar su propiedad. Bueno, ¿cómo garantizar la propiedad? De hecho, es la cadena de bloques. El Metaverso no puede evitar este problema. Todas las redes futuras parecen necesitar la cadena de bloques. Sin embargo, en esta etapa, la cadena de bloques, tanto la cadena principal como la cadena lateral, es lento y requiere Sigue siendo una realidad que la tecnología en esta etapa todavía es lenta para escribir tantos bloques y confirmar los derechos.
¿Por qué aprender web3.0?
Empresa (pública: propiedad de varias personas; empresa: el significado de operación). Con el desarrollo de la sociedad moderna, la cooperación de producción económica entre empresas y personas se está volviendo cada vez más complicada, especialmente los diversos tipos de cooperación en Internet. ¿Cómo confirmar que la propiedad de estas personas o de muchas personas está en una o más personas? • El valor en múltiples actividades económicas de producción es un problema que Internet necesita resolver. Debido a la epidemia, el trabajo desde casa, los autónomos y las necesidades de nuevas relaciones sociales de producción impulsan constantemente la mejora de la web3.0 y el metaverso.
¿Qué tecnologías se deben dominar para aprender web3.0?
Lenguaje de redacción de contratos inteligentes de Solidity
El lenguaje Solidity es un lenguaje de programación orientado a contratos de alto nivel que se utiliza para implementar contratos inteligentes en la red blockchain Ethereum. Para su herramienta de desarrollo Remix, se recomienda utilizar su editor en línea [https://remix.ethereum.org]. El editor en línea se puede conectar sin problemas con matemask. Los contratos inteligentes de Blockchain deben integrarse con billeteras inteligentes.
trufa
Es un entorno de desarrollo de contratos inteligentes localizado, un marco de pruebas y una herramienta en cadena basado en la máquina virtual Ethereum (EVM).
geth
Geth puede construir un nodo Ethereum completo, no entraré en demasiados detalles aquí, porque es suficiente usar Ganache virtual de memoria local para el desarrollo.
ganache
Ganache puede iniciar rápidamente una cadena de bloques Ethereum personal y puede usarse para ejecutar pruebas, ejecutar comandos, verificar el estado y controlar cómo opera la cadena.
nodo js
Todas las soluciones técnicas web3.0 que presenté están instaladas en función de npm, incluidas trufa y Ganache. El siguiente artículo supone que todo el mundo conoce el conocimiento de Node js.
Empezar a codificar
Código de votación de solidez portátil
Aquí hay un contrato simple sobre la votación.
pragma solidity ^0.4.0;
contract Voting{
//投票列表
bytes32[] public candidateList;
//对应的票数
mapping(bytes32=>uint8) public votesReceived;
//构造投票列表
constructor(bytes32[] memory candidateListName) public{
candidateList = candidateListName;
}
//判断投票信息是否在待投票列表
function valiCandidate(bytes32 candidateName) internal view returns(bool)
{
for(uint8 i=0;i〈candidateList.length;i++)
{
if (candidateName==candidateList[i])
{
return true;
}
}
return false;
}
//对投票人增加投票
function voteForCandidate(bytes32 candidateName) public{
require(valiCandidate(candidateName));
votesReceived[candidateName] = votesReceived[candidateName] + 1;
}
function totalVotesFor(bytes32 candidateName) view public returns(uint8){
require(valiCandidate(candidateName));
//返回票数
return votesReceived[candidateName];
}
}instalar ganache
Recuerde agregar -g para instalar globalmente
npm install ganache-cli -g# 6.12
npm install ganache -g# 7.0
ganache-cli -d #启动它ganache
Instalar trufa
Recuerde agregar -g para instalar globalmente
npm install truffle -gInicialice el marco dapp trufa (web3.0)
mkdir voting
cd voting
truffle unbox webpackLa estructura del directorio del proyecto inicializado es la siguiente
El directorio APP es un proyecto web3.0 de nodo js; el directorio de compilación es el directorio de contrato compilado para llamar; contratos es el contrato escrito en remix y migraciones es el archivo de implementación del contrato; el directorio de prueba es el archivo de prueba; trufa-config .js es el archivo de configuración.
configuración de trufa-config.js
Desmarque el comentario 127.0.0.1 puerto 8545 para indicar el enlace al Ganache local.
Implemente vote.sol en el directorio de contratos del proyecto
truffle compileEl contrato predeterminado del proyecto se coloca en este directorio: ejecute el comando (compilación de trufa) para compilar. Una vez completada la compilación, habrá un archivo Voting.json adicional en compilación/contratos.
Cree un nuevo archivo 3_deploy_contracts.js en el directorio de migraciones
const Voting = artifacts.require("Voting");
//0x4100000000000000000000000000000000000000000000000000000000000000 代表 A
//0x4200000000000000000000000000000000000000000000000000000000000000 代表 B
module.exports = function(deployer) {
//初始化合约 第二是投标列表参数
deployer.deploy(Voting, ["0x4100000000000000000000000000000000000000000000000000000000000000","0x4200000000000000000000000000000000000000000000000000000000000000"]);
};Ejecutar comando: migración de trufa // implementar contrato
truffle migrate
la dirección del contrato es la dirección del contrato y la cuenta es la dirección de la cuenta de implementación.
Implementación y operación de código en el directorio de la aplicación.
Hay dos archivos vote.js y vote.html en app/src/:
Código de votación.js:
import Web3 from "web3";
import votingArtifact from "../../build/contracts/Voting.json";
const aInBytes32 ="0x4100000000000000000000000000000000000000000000000000000000000000";
const bInBytes32 ="0x4200000000000000000000000000000000000000000000000000000000000000";
const App = {
web3: null,
account: null,
meta: null,
start: async function() {
const { web3 } = this;
try {
const networkId = await web3.eth.net.getId();
const deployedNetwork = votingArtifact.networks[networkId];
this.voting = new web3.eth.Contract(
votingArtifact.abi,
deployedNetwork.address,
);
const accounts = await web3.eth.getAccounts();
this.account = accounts[0];
this.ready();
this.refreshBalance();
} catch (error) {
console.error("Could not connect to contract or chain.");
}
},
ready:async function(){
try{
this.refresh("Alice",aInBytes32);
this.refresh("Bob",bInBytes32);
}catch(err){
console.log(err)
}
},
refresh:async function(id,nameBytes32){
const {totalVotesFor} = this.voting.methods;
const tickets = await totalVotesFor(nameBytes32).call();
const el = document.getElementById(id);
el.innerHTML = tickets.toString();
},
voteForCandidate:async function(){
try{
const {voteForCandidate} = this.voting.methods;
const condidateName = document.getElementById("candidate").value;
console.log(condidateName)
if (condidateName == "Alice")
{
await voteForCandidate(aInBytes32).send({from:this.account});
this.refresh("Alice",aInBytes32);
}
else{
await voteForCandidate(bInBytes32).send({from:this.account});
this.refresh("Bob",bInBytes32);
}
}catch(err){
console.log(err)
}
}
};
window.App = App;
window.addEventListener("load", function() {
if (window.ethereum) {
// use MetaMask's provider
App.web3 = new Web3(window.ethereum);
window.ethereum.enable(); // get permission to access accounts
} else {
console.warn(
"No web3 detected. Falling back to http://127.0.0.1:8545. You should remove this fallback when you deploy live",
);
// fallback - use your fallback strategy (local node / hosted node + in-dapp id mgmt / fail)
App.web3 = new Web3(
new Web3.providers.HttpProvider("http://127.0.0.1:8545"),
);
}
App.start();
});La primera línea importa web3; la segunda línea importa el contrato de votación; la tercera y cuarta líneas son dos elementos de votación.
import Web3 from "web3";
import votingArtifact from "../../build/contracts/Voting.json";
const aInBytes32 ="0x4100000000000000000000000000000000000000000000000000000000000000";
const bInBytes32 ="0x4200000000000000000000000000000000000000000000000000000000000000";Este código obtiene la red blockchain y la cuenta de billetera e inicializa el contrato de votación.
start: async function() {
const { web3 } = this;
try {
// get contract instance
const networkId = await web3.eth.net.getId();
const deployedNetwork = votingArtifact.networks[networkId];
this.voting = new web3.eth.Contract(
votingArtifact.abi,
deployedNetwork.address,
);
// get accounts
const accounts = await web3.eth.getAccounts();
this.account = accounts[0];
this.ready();
this.refreshBalance();
} catch (error) {
console.error("Could not connect to contract or chain.");
}
},
});método de votación
voteForCandidate:async function(){
try{
const {voteForCandidate} = this.voting.methods;
const condidateName = document.getElementById("candidate").value;
console.log(condidateName)
if (condidateName == "Alice")
{
await voteForCandidate(aInBytes32).send({from:this.account});
this.refresh("Alice",aInBytes32);
}
else{
await voteForCandidate(bInBytes32).send({from:this.account});
this.refresh("Bob",bInBytes32);
}
}catch(err){
console.log(err)
}
}votacion.htmlcode
<!DOCTYPE html>
<html>
<head>
<title>My Voting Dapp</title>
</head>
<style>
input {
display: block;
margin-bottom: 12px;
}
</style>
<body>
<h1>Voting Dapp</h1>
<p>Alice <strong id="Alice">loading...</strong> tickets</p>
<p>Bob <strong id="Bob">loading...</strong> tickets</p>
<input type="text" id="candidate" />
<button onclick="App.voteForCandidate()">Send</button>
<script src="voting.js"></script>
</body>
</html>Inicialice el proyecto DAPP e inícielo
npm install
npm run dev
Visite http://localhost:8080/voting.html 
e ingrese Alice--"Haga clic en enviar (la billetera matemask le indicará que necesita gastar algunas monedas eth para confirmar, yo solo las gasto como monedas simuladas locales) Después de confirmar, usted 
encontrará a Alice votando. El número se ha convertido en 2. Esto no se puede cambiar en la cadena de bloques.
Resumir
En el lenguaje de solidez del contrato, el almacenamiento requiere gas y se almacenará permanentemente en el bloque. Usamos esta característica para escribir el contrato de votación, de modo que la votación no cambie durante mucho tiempo. También hay una memoria que se almacena en la memoria y no cuesta gasolina. . De esta manera, podemos encontrar que web3.0 o dapp guarda contenido que requiere garantía de crédito en la blockchain a través de contratos inteligentes, lo que juega un papel de confianza descentralizado y también asegura la garantía de propiedad. De esta manera, web3.0 proporciona la función de confirmar los derechos y los derechos de propiedad de la red de lectura y escritura anterior, sentando las bases para el metaverso.