Implementar un contrato inteligente sobre la implementación de Arbitrum

Descripción general​

Bienvenido a la guía sobre la implementación de un contrato inteligente para su implementación de Arbitrum. En este tutorial, aprenderá cómo implementar un contrato inteligente utilizando el devnet L2 Nitro y las claves públicas y privadas proporcionadas para fines de prueba.

Requisitos previos​

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​

Cuentas financiadas​

Su L2 Nitro devnet tendrá un clave pública y privada financiada como un grifo para usar para pruebas:

  • Tanto en L1 como en L2

    • Clave pública: 0x3f1Eae7D46d88F08fc2F8ed27FCb2AB183EB2d0E

    • Clave privada: 0xb6b15c8cb491557369f3c7d2c287b053eb229daa9c22138887752191c9520659

Alternativamente, puedes financia otras direcciones utilizando los scripts send-l1 y send-l2.

El L1 Geth devnet se ejecutará en http://localhost:8545 y el L2 Nitro devnet estará encendido http://localhost:8547 y ws://localhost:8548.

Usando nuestro Arbitrum devnet​

Utilizaremos el punto final local de RPC (http://localhost:8547) y cuentas anteriores para probar con.

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

bash

export L2_PRIVATE_KEY=0xe887f7d17d07cc7b8004053fb8826f6657084e88904bb61590e498ca04704cf2
export ARB_RPC_URL=http://localhost:8547

Ahora, implemente el contrato:

bash

forge create --rpc-url $ARB_RPC_URL \
  --private-key $L2_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 $ARB_RPC_URL --private-key $L2_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 $ARB_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 su devnet de implementación Arbitrum.

¿Qué construirás a continuación? En nuestro próximo tutorial, repasaremos cómo implementar un dapp en su implementación de Arbitrum.

PreviousTestnet de nitrógenoNextImplemente un dapp en su devnet Arbitrum rollup

Last updated