DApp de solidity

En esta guía para desarrolladores de Solidity, aprenderá lo fácil que es crear una interfaz Aptos dApp React y configurar su dApp para Movement Network.

Requisitos

Asegúrese de tener instalado Foundry . Si usa Hardhat, tenga en cuenta que deberá agregar cadenas personalizadas.

Configuración

Arrancaremos nuestro dapp a continuación con el comando proporcionado por Scaffold-ETH .

Copiar

npx create-eth@latest

Una vez que haya ejecutado el npx create-eth@latestcomando en su terminal, siga las instrucciones en pantalla para configurar su Solidity dApp. Tiene la opción de elegir Foundry o Hardhat . Usaremos fundición. Elija instalar dependencias.

Navegue hasta el directorio de su dApp e inicie su entorno de desarrollo integrado (IDE) preferido. En esta guía, usaremos Visual Studio Code (VS Code).

Copiar

cd your-dapp-name
code .

Dentro del directorio del proyecto, encontrará varias carpetas y archivos. Nos centraremos principalmente en lo siguiente:

• packages/foundry

• packages/nextjs

Implementación de un contrato inteligente con MEVM

Primero, requerirá alguna configuración. Navegue packages/foundry/foundry.tomly cambie su contenido a lo siguiente:

Copiar

[profile.default]
src = 'contracts'
out = 'out'
libs = ['lib']
fs_permissions = [{ access = "read-write", path = "./"}]

[rpc_endpoints]
mevm = "https://mevm.testnet.m1.movementlabs.xyz"

A continuación, en paquetes/foundry/.env agregue una clave privada a la variable DEPLOYER_PRIVATE_KEY. Asegúrate de financiarlo con MOVE de nuestro Faucet .

Finalmente, elimine YourContractlas funciones de registro no deseadas de.

Copiar

//SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;

// Use openzeppelin to inherit battle-tested implementations (ERC20, ERC721, etc)
// import "@openzeppelin/contracts/access/Ownable.sol";

/**
 * A smart contract that allows changing a state variable of the contract and tracking the changes
 * It also allows the owner to withdraw the Ether in the contract
 * @author BuidlGuidl
 */
contract YourContract {
    // State Variables
    address public immutable owner;
    string public greeting = "Building Unstoppable Apps!!!";
    bool public premium = false;
    uint256 public totalCounter = 0;
    mapping(address => uint256) public userGreetingCounter;

    // Events: a way to emit log statements from smart contract that can be listened to by external parties
    event GreetingChange(
        address indexed greetingSetter,
        string newGreeting,
        bool premium,
        uint256 value
    );

    // Constructor: Called once on contract deployment
    // Check packages/foundry/deploy/Deploy.s.sol
    constructor(address _owner) {
        owner = _owner;
    }

    // Modifier: used to define a set of rules that must be met before or after a function is executed
    // Check the withdraw() function
    modifier isOwner() {
        // msg.sender: predefined variable that represents address of the account that called the current function
        require(msg.sender == owner, "Not the Owner");
        _;
    }

    /**
     * Function that allows anyone to change the state variable "greeting" of the contract and increase the counters
     *
     * @param _newGreeting (string memory) - new greeting to save on the contract
     */
    function setGreeting(string memory _newGreeting) public payable {
        // Print data to the anvil chain console. Remove when deploying to a live network.

        greeting = _newGreeting;
        totalCounter += 1;
        userGreetingCounter[msg.sender] += 1;

        // msg.value: built-in global variable that represents the amount of ether sent with the transaction
        if (msg.value > 0) {
            premium = true;
        } else {
            premium = false;
        }

        // emit: keyword used to trigger an event
        emit GreetingChange(msg.sender, _newGreeting, msg.value > 0, 0);
    }

    /**
     * Function that allows the owner to withdraw all the Ether in the contract
     * The function can only be called by the owner of the contract as defined by the isOwner modifier
     */
    function withdraw() public isOwner {
        (bool success, ) = owner.call{value: address(this).balance}("");
        require(success, "Failed to send Ether");
    }

    /**
     * Function that allows the contract to receive ETH
     */
    receive() external payable {}
}

Ahora puede ejecutar el siguiente comando para implementar el contrato prediseñado que viene con Scaffold-ETH:

Copiar

yarn deploy --network mevm

¡Debería brindarle una YourContractdirección de implementación que debería escribir en un archivo que Scaffold-ETH tomará y usará para generar un Front End!

Configure su dApp para MEVM

Dirígete a packages/nextjs/scaffold.config.tsy cambia targetNetworksa[chain.mevm]:

Copiar

import * as chains from "viem/chains";
import { type Chain } from "viem"

export type ScaffoldConfig = {
  targetNetworks: readonly chains.Chain[];
  pollingInterval: number;
  alchemyApiKey: string;
  walletConnectProjectId: string;
  onlyLocalBurnerWallet: boolean;
  walletAutoConnect: boolean;
};

export const mevm = {
  id: 336,
  name: "M1 MEVM",
  network: "mevm",
  nativeCurrency: { name: "Move", symbol: "MOVE", decimals: 18 },
  rpcUrls: {
    default: {
      http: ["https://mevm.devnet.m1.movementlabs.xyz"],
    },
    public: {
      http: ["https://mevm.devnet.m1.movementlabs.xyz"],
    },
  },
  blockExplorers: {
    etherscan: { name: "Arbiscan", url: "https://explorer.mevm.devnet.m1.movementlabs.xyz" },
    default: { name: "Arbiscan", url: "https://explorer.mevm.devnet.m1.movementlabs.xyz" },
  },
  contracts: {
    multicall3: {
      address: "0xD67Eca381AAbd0c049554f5714E7d8C21864c560",
      blockCreated: 500,
    },
  },
} as const satisfies Chain


const scaffoldConfig = {
  targetNetworks: [mevm],
  pollingInterval: 30000,
  alchemyApiKey: process.env.NEXT_PUBLIC_ALCHEMY_API_KEY || "oKxs-03sij-U_N0iOlrSsZFr29-IqbuF",
  walletConnectProjectId: process.env.NEXT_PUBLIC_WALLET_CONNECT_PROJECT_ID || "3a8170812b534d0ff9d794f19a901d64",
  onlyLocalBurnerWallet: true,
  walletAutoConnect: true,
} as const satisfies ScaffoldConfig;
export default scaffoldConfig;

Dulce, estás bastante preparado. Ahora puede ejecutar lo siguiente para ejecutar su dApp:

Copiar

yarn start

Acceda a su dApp en https://localhost:3000. Asegúrese de agregar MEVM a Metamask o a su billetera EVM elegida para acceder a todas las funciones del contrato a través dehttp://localhost:3000/debug

Experimente con llamadas a funciones y consultas de valores.

¿Qué dApps desarrollarás en Movement?

Ahora ya sabe cómo configurar una dApp Solidity para MEVM.

Compruebe YourContractla lógica, intente una redistribución modificándola. Como desafío, intente modificar el Front End para mostrar el saludo y el contador del usuario.

¡Estamos ansiosos por ver qué dApps creas e implementas en Movement Network!