Interoperabilidad Layer 1 y Layer 2
Tags: solidity, web3, blockchain, layer2
Published: 2022-04-29 17:55:31

---
title: Interoperabilidad Layer 1 y Layer 2
published: true
description: 
tags: solidity, web3, blockchain, layer2
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6lkxxopk1xdmq4f1b9iv.png
---

Poco a poco vemos como diferentes soluciones de escalabilidad de blockchain se hacen realidad. Estas soluciones cada vez ahorran mas gas sin sacrificar seguridad. En este video probaremos la interoperabilidad entre Ethereum Mainnet (Layer 1) y Arbitrum (Optimistic Rollup de Ethereum Layer 2). Los bridges entre Mainnet y los Rollups traen nuevas mecánicas al blockchain y son la manera mas segura y avanzada de operar smart contracts generéricos cross chain. La buena noticia es que ya están disponibles hoy para nosotros los programadores y los usuarios del blockchain.

https://youtu.be/_RFs2TfsKI

## Antes de iniciar

Asegurate de instalar [Metamask](https://metamask.io/) y agregar fondos de Rinkeby Testnet que puedes conseguir desde el [Faucet](https://rinkebyfaucet.io/). También necesitarás [agregar Rinkeby Arbitrum Testnet a tu metamask](https://developer.offchainlabs.com/docs/public_testnet) mover fondos desde Rinkeby a Rinkeby Arbitrum Testnet mediante el [Bridge](https://bridge.arbitrum.io/).

## Contrato en L2

Primero lanzamos el siguiente contrato en Arbitrum Rinkeby Testnet.

```solidity
// SPDX-License-Identifier: Apache-2.0
pragma solidity  0.8.13;

contract HelloWorld {
    string public hello = "Hola Mundo!";

    function setHello(string memory _hello) public {
        hello = _hello;
    }
}
```

## Contrato operador en L1

Luego lanzamos el siguiente contrato y ejecutamos la función `setHelloInL2` pasando como `value` `20000000000000000` wei o `0.01` ether y los siguientes parametros sugeridos:

* l2ContractAddress: `ADDRESS DE CONTRATO EN L2`
* _hello: `¡Hemos ejecutado esto desde L1!`
* maxSubmissionCost: `80000000000`
* maxGas: `90000000`
* gasPriceBid: `90000000`

```solidity
// SPDX-License-Identifier: Apache-2.0
pragma solidity  0.8.13;


interface IInbox {
    function createRetryableTicket(
        address destAddr,
        uint256 l2CallValue,
        uint256 maxSubmissionCost,
        address excessFeeRefundAddress,
        address callValueRefundAddress,
        uint256 maxGas,
        uint256 gasPriceBid,
        bytes calldata data
    ) external payable returns (uint256);
}

interface IHelloWorld {
    function setHello(string memory _hello) external;
}

contract L2Operator {
    IInbox public inbox = IInbox(0x578BAde599406A8fE3d24Fd7f7211c0911F5B29e);

    function setHelloInL2(
        address l2ContractAddress,
        string memory _hello,
        uint256 maxSubmissionCost,
        uint256 maxGas,
        uint256 gasPriceBid
    ) public payable returns (uint256) {
        bytes memory data =
            abi.encodeWithSelector(IHelloWorld.setHello.selector, _hello);
        uint256 ticketID = inbox.createRetryableTicket{value: msg.value}(
            l2ContractAddress,
            0,
            maxSubmissionCost,
            msg.sender,
            msg.sender,
            maxGas,
            gasPriceBid,
            data
        );
        return ticketID;
    }
}
```

Documetación oficial:

* [Documentación general](https://developer.offchainlabs.com/docs/l1_l2_messages)
* [Addresses importantes](https://developer.offchainlabs.com/docs/useful_addresses)
* [Utilería para debuggear](https://developer.offchainlabs.com/docs/arbos_formats)
* [Inbox.sol](https://github.com/OffchainLabs/arbitrum/blob/master/packages/arb-bridge-eth/contracts/bridge/Inbox.sol)
* [Ejemplo de interoperabilidad](https://github.com/OffchainLabs/arbitrum-tutorials/tree/master/packages/greeter)

**¡Gracias por ver este tutorial!**

Sígueme en dev.to y en [Youtube](https://www.youtube.com/c/FilosofiaCodigo) para todo lo relacionado al desarrollo en Blockchain en Español.