Implemente un contrato inteligente en Bubs testnet

En este tutorial, implementaremos un contrato inteligente en la red de prueba de Bubs.

Dependencias​

• Fundición instalado en su máquina

• Nodo.js

• Comprensión básica de Ethereum

• Comprensión básica de Solidity y Node.js

• Bubs ETH de la Grifo de burbujas

• Una URL de RPC de Bubs desde el Página de testnet de bubs

Configuración​

Primero, en tu $HOME directorio, configure una nueva carpeta de proyecto para este tutorial e inicie el proyecto con npm:

bash

cd $HOME
mkdir counter-project && cd counter-project && npm init -y

A continuación, inicializa un proyecto de Foundry con el siguiente comando:

bash

forge init counter_contract

Crea tu contrato inteligente​

Echa un vistazo a la Counter.sol archivo en tu counter-project/counter_contract/src directorio:

solidez

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

contract Counter {
    uint256 public number;

    function setNumber(uint256 newNumber) public {
        number = newNumber;
    }

    function increment() public {
        number++;
    }
}

El contrato contiene una variable entera pública sin firmar llamada "número". Hay dos funciones públicas en este contrato. El setNumber la función permite a cualquiera establecer un nuevo valor para la variable "número", mientras que el increment la función aumenta el valor del "número" en uno cada vez que se llama.

Puedes obtenga más información sobre Solidity y programación de contratos inteligentes.

Para compilar el contrato, ejecute el siguiente comando forge del $HOME/counter-project/counter_contract/ directorio:

bash

forge build

Su salida debe ser similar a la siguiente:

bash

[⠢] Compiling...
[⠔] Compiling 21 files with 0.8.19
[⠑] Solc 0.8.19 finished in 1.24s
Compiler run successful

Prueba tu contrato inteligente​

Ahora, abre el test/Counter.t.sol archivo:

solidez

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/Test.sol";
import "../src/Counter.sol";

contract CounterTest is Test {
    Counter public counter;

    function setUp() public {
        counter = new Counter();
        counter.setNumber(0);
    }

    function testIncrement() public {
        counter.increment();
        assertEq(counter.number(), 1);
    }

    function testSetNumber(uint256 x) public {
        counter.setNumber(x);
        assertEq(counter.number(), x);
    }
}

Este archivo realiza pruebas unitarias en el contrato que creamos en la sección anterior. Esto es lo que está haciendo la prueba:

• El contrato incluye una variable de tipo "Contador" pública llamada "contador". En el setUp función, inicializa una nueva instancia del contrato "Contador" y establece la variable "número" en 0.

• Hay dos funciones de prueba en el contrato: testIncrement y testSetNumber.

• El testIncrement la función prueba la función de "incremento" del contrato de "Contador" llamándolo y luego afirmando que el "número" en el contrato de "Contador" es 1. Verifica si la operación de incremento aumenta correctamente el número en uno.

• El testSetNumber la función es más genérica. Toma un argumento entero sin firmar 'x' y prueba la función "setNumber" del contrato "Counter. Después de llamar a la función "setNumber" con 'x', afirma que el "número" en el contrato "Counter" es igual a 'x'. Esto verifica que la función "setNumber" actualiza correctamente el "número" en el contrato "Counter.

Ahora, para probar su código, ejecute lo siguiente:

bash

forge test

Si la prueba es exitosa, su salida debe ser similar a esto:

bash

[⠆] Compiling...
No files changed, compilation skipped

Running 2 tests for test/Counter.t.sol:CounterTest
[PASS] testIncrement() (gas: 28334)
[PASS] testSetNumber(uint256) (runs: 256, μ: 27709, ~: 28409)
Test result: ok. 2 passed; 0 failed; finished in 8.96ms

Implementación de su contrato inteligente​

Usando Anvil​

Primero, probaremos nuestro contrato en un devnet local llamado "anvil". Para iniciar el servidor local, ejecute:

bash

anvil

Verá un punto final local de RPC (127.0.0.1:8545) y cuentas para probar.

Desplieguemos el contrato ahora. Primero, establezca una clave privada del yunque:

bash

export PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
export ANVIL_RPC_URL=http://localhost:8545

Ahora, implemente el contrato:

bash

forge create --rpc-url $ANVIL_RPC_URL \
--private-key $PRIVATE_KEY \
src/Counter.sol:Counter

Usando Bubs​

Primero, establezca una clave privada de su billetera Ethereum financiada y establezca la BUBS_RPC_URL variable con un RPC de su elección:

bash

export BUBS_PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
export BUBS_RPC_URL=https://bubs.calderachain.xyz/http

Ahora que estamos listos para implementar el contrato inteligente en Bubs, ejecutaremos el forge create comando.

bash

forge create --rpc-url $BUBS_RPC_URL \
--private-key $BUBS_PRIVATE_KEY \
src/Counter.sol:Counter

Una implementación exitosa devolverá una salida similar a la siguiente:

bash

[⠆] Compiling...
No files changed, compilation skipped
Deployer: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
Deployed to: 0x5FbDB2315678afecb367f032d93F642f64180aa3
Transaction hash: 0xf1a793a793cd9fc588f5132d99008565ea361eb3535d66499575e9e1908200b2

Una vez que haya implementado el contrato, ¡está listo para interactuar con él!

Primero, lo estableceremos como una variable:

bash

export CONTRACT_ADDRESS=0x5FbDB2315678afecb367f032d93F642f64180aa3

Interactuando con su contrato inteligente​

Usos de fundición cast, una CLI para realizar llamadas RPC de Ethereum.

Para escribir al contrato, usaremos el cast send comando:

bash

cast send $CONTRACT_ADDRESS "setNumber(uint256)" 10 --rpc-url $BUBS_RPC_URL --private-key $BUBS_PRIVATE_KEY

Su salida se verá similar:

bash

blockHash               0x131822bef6eb59656d7e1387c19b75be667e587006710365ec5cf58030786c42
blockNumber             3
contractAddress
cumulativeGasUsed       43494
effectiveGasPrice       3767182372
gasUsed                 43494
logs                    []
logsBloom               0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
root
status                  1
transactionHash         0x8f15d6004598f0662dd673a9898dceef77be8cc28408cecc284b28d7be32307d
transactionIndex        0
type                    2

Ahora, podemos hacer una llamada de lectura para ver el estado de la variable numérica, utilizando el cast call comando:

bash

cast call $CONTRACT_ADDRESS "number()" --rpc-url $BUBS_RPC_URL

El resultado se verá similar:

bash

0x000000000000000000000000000000000000000000000000000000000000000a

Convierta el resultado de hexadecimal a un valor base 10 con:

bash

echo $((0x000000000000000000000000000000000000000000000000000000000000000a))

Próximos pasos​

¡Felicitaciones! Ha aprendido cómo implementar un contrato inteligente en Bubs testnet.

¿Qué construirás a continuación? Ahora, estás listo para ver el tutorial del portal GM.