Implementación de contratos de solidez en M1 usando Hardhat y Fractal

Este tutorial lo guiará en la implementación de un contrato inteligente de Solidity en M1 usando Fractal Transpiler y Hardhat.

Nuestro kit de herramientas

¿Qué es el casco?

Hardhat es una potente cadena de herramientas de desarrollo de contratos inteligentes de Javascript para máquinas virtuales Ethereum.

¿Qué es Fractal?

Fractal es el transpilador de Movement Labs que permite a cualquier desarrollador implementar cualquier contrato inteligente de Solidity en M1, una máquina virtual basada en lenguaje Move , convirtiendo efectivamente el código de Solidity en código Move, heredando todas las propiedades de seguridad disponibles de forma nativa para los contratos inteligentes de Move.

Requisitos previos

Antes de comenzar este tutorial, deberá:

Instalar casco

Paso 1: Financia tu billetera con tokens MOV

Financia una dirección de billetera EVM con algunos MOVtokens usando nuestro faucet . Otro método para obtener MOVes conectar desde M1 a su billetera EVM usando nuestro puente . Para conectarse a nuestra testnet y verificar si ha recibido los MOVtokens, puede seguir los siguientes pasos:

Agregue la red move-evm a su billetera compatible con EVM.
Propiedad
Valor
Nombre de red
mover-evm
RPC de red
https://mevm.devnet.m1.movementlabs.xyz
Identificación de red
0x0150
Moneda de la red
MOVIMIENTO
Asegúrese de haber cambiado su red Wallet a la red agregada anteriormente, es decir, move-evm.

Paso 2: Configure su proyecto Hardhat

Crea el directorio de tu proyecto:

Copiar

mkdir hardhat-move-evm

Y accede a él:

Copiar

cd hardhat-move-evm

Inicie su proyecto Hardhat:

Copiar

npx hardhat init

Sigue los pasos y elige tus preferencias. Aquí revisaremos los valores predeterminados y elegiremos un proyecto de JavaScript. Llamamos al proyecto hardhat-move-evm.

Si no ha aceptado la instalación de la dependencia, hágalo. Si está realizando una instalación personalizada, asegúrese de utilizar las dependencias correctas:

Copiar

npm install --save-dev "hardhat@^2.19.0" "@nomicfoundation/hardhat-toolbox@^3.0.0"

Asegúrese de instalar también dotenv:

Copiar

npm install dotenv

Abra el proyecto en su editor favorito. Aquí estamos usando VSCode

Copiar

code .

Crear un archivo .env

Copiar

touch .env

Agregue su clave privada al archivo .env. Puede obtener su clave privada de su billetera EVM con la que financió MOV. Por ejemplo, si está utilizando MetaMask , puede encontrar su clave privada en Configuración > Avanzado > Exportar clave privada. Asegúrese de mantener segura su clave privada y nunca la comparta con nadie.

Copiar

PRIVATE_KEY=<your private key>

En la carpeta raíz podrá encontrar hardhat.config.js. Este es el archivo de configuración del casco. Agregue configuraciones de red M1 reemplazando su contenido con lo siguiente:

Copiar

require("@nomicfoundation/hardhat-toolbox");
require('dotenv').config();

module.exports = {
  defaultNetwork: "m1",
  networks: {
    hardhat: {
    },
    m1: {
      url: "https://mevm.devnet.m1.movementlabs.xyz",
      accounts: [process.env.PRIVATE_KEY],
      chainId: 336
    }
  },
  solidity: {
    version: "0.8.21",
    settings: {
      optimizer: {
        enabled: true,
        runs: 200
      }
    }
  },
  paths: {
    sources: "./contracts",
    tests: "./test",
    cache: "./cache",
    artifacts: "./artifacts"
  }
}

Paso 3: escriba su contrato de Solidity

Aquí introduciremos cambios mínimos en nuestros contratos para hacerle la vida más fácil. No hay nada intrínseco aquí que sea específico de M1. Puede redactar sus contratos como lo haría normalmente.

Debajo contracts/abra el archivo Lock.sol. Este es el contrato inteligente que implementará en M1. Puede reemplazar el contenido de este archivo con su propio contrato.

Copiar

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
// Uncomment this line to use console.log
// import "hardhat/console.sol";
contract Lock {
    uint public unlockTime;
    address payable public owner;
    event Withdrawal(uint amount, uint when);
    constructor(uint _unlockTime) payable {
        require(
            block.timestamp < _unlockTime,
            "Unlock time should be in the future"
        );
        unlockTime = _unlockTime;
        owner = payable(msg.sender);
    }
    function withdraw() public {
        // Uncomment this line, and the import of "hardhat/console.sol", to print a log in your terminal
        // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);
        require(block.timestamp >= unlockTime, "You can't withdraw yet");
        require(msg.sender == owner, "You aren't the owner");
        emit Withdrawal(address(this).balance, block.timestamp);
        owner.transfer(address(this).balance);
    }
}

Tienes una variable de estado unlockTimey una función withdrawpara retirar los fondos del contrato.

Ahora, en scripts, abra el archivo deploy.js. Este es un script simple que usaremos para implementar nuestro contrato en M1. Puede reemplazar el contenido de este archivo con su propio script.

Copiar

// We require the Hardhat Runtime Environment explicitly here. This is optional
// but useful for running the script in a standalone fashion through `node <script>`.
//
// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
// will compile your contracts, add the Hardhat Runtime Environment's members to the
// global scope, and execute the script.
const hre = require("hardhat");

async function main() {
  const currentTimestampInSeconds = Math.round(Date.now() / 1000);
  const unlockTime = currentTimestampInSeconds + 60;

  const lockedAmount = hre.ethers.parseEther("0.001");

  const lock = await hre.ethers.deployContract("Lock", [unlockTime], {
    value: lockedAmount,
  });

  await lock.waitForDeployment();

  console.log(
    `Lock with ${ethers.formatEther(
      lockedAmount
    )}ETH and unlock timestamp ${unlockTime} deployed to ${lock.target}`
  );
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Esto implementará el contrato disponible en contratos/Lock.sol. Puedes jugar con él y cambiar su lógica, ¡siéntete libre de probar cosas!

Paso 4: Implemente su contrato de Solidity

Para implementar su contrato, ejecute el siguiente comando:

Copiar

npx hardhat run scripts/deploy.js --network m1

Después de ejecutarlo, deberías ver un mensaje similar en tu consola:

Copiar

Lock with 0.001ETH and unlock timestamp <currentTimestamp> deployed to <lockAddress>

¡Éxito! Ha implementado exitosamente su contrato usando Hardhat. Ahora debería poder interactuar con el contrato proporcionado en el mensaje anterior.

Paso 5: interactúe con su contrato de Solidity

Ahora que tienes tu contrato, también puedes interactuar con él usando Hardhat. Para ello, escribiremos otro guión. En script, cree un nuevo archivo withdraw.jsy agregue el siguiente contenido:

Copiar

// We require the Hardhat Runtime Environment explicitly here. This is optional
// but useful for running the script in a standalone fashion through `node <script>`.
//
// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
// will compile your contracts, add the Hardhat Runtime Environment's members to the
// global scope, and execute the script.
const hre = require("hardhat");

async function main() {
    const lockAddress = "<lockAddress>";
    console.log(`Lock address: ${lockAddress}`)
    const [deployer] = await hre.ethers.getSigners();
    console.log(`Deployer address: ${deployer.address}`);
    const lockedAmount = await hre.ethers.provider.getBalance(lockAddress);
    const currentBalance = await hre.ethers.provider.getBalance(deployer.address);
    console.log(
        `Current balance of ${deployer.address} is ${hre.ethers.formatEther(currentBalance)}ETH`
    );
    const lock = await hre.ethers.getContractAt("Lock", lockAddress);

    const tx = await lock.withdraw();
    await tx.wait();

    console.log(
        `Withdrawn ${hre.ethers.formatEther(lockedAmount)}ETH from ${lockAddress} to ${deployer.address}`
    );

    const posBalance = await hre.ethers.provider.getBalance(deployer.address);

    console.log(
        `Balance after withdrawal of ${deployer.address} is ${hre.ethers.formatEther(posBalance)}ETH`
    );
    console.log(`sum of previous balance and withdrawn value: ${currentBalance + lockedAmount}`);
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
    console.error(error);
    process.exitCode = 1;
});

Asegúrese de reemplazar <lockAddress>con la dirección de su contrato implementado. Puede encontrarlo en el mensaje impreso en su consola después de implementar su contrato.

Ahora, todo lo que tienes que hacer es ejecutar el siguiente comando:

Copiar

npx hardhat run scripts/withdraw.js --network m1

Si tiene éxito, debería ver el siguiente mensaje:

Copiar

Balance after withdrawal of <yourAddress> is <xValue> ETH
sum of previous balance and withdrawn value: <xValue>

¡Eso es todo! Si está acostumbrado a implementar contratos en redes EVM, debería sentirse como en casa. Si no es así, esperamos que este tutorial haya sido útil y que ahora esté listo para trabajar en su contrato, implementar sus propios contratos y continuar construyendo en M1.

Si desea obtener más información sobre M1 e implementar contratos Move, consulte la documentación .

No dudes en comunicarte con nosotros en Discord si tienes algún problema, pregunta o comentario. ¡Nos encantaría saber de usted!

PreviousImplementación de contratos de solidez en movimiento utilizando Foundry y Fractal NextImplementación de contratos inteligentes de Solidity en M1 utilizando el tiempo de ejecución Fractal

Last updated 1 year ago