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
Nitro rollup devnet corriendo
Fundición instalado en su máquina
Comprensión básica de Ethereum
Comprensión básica de Solidity y Node.js
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
ytestSetNumber
.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.
Last updated