07.12.2024

Lição 259: Interações entre Cadeias

No cenário em constante evolução da tecnologia blockchain, as interações entre cadeias emergiram como um tema crucial de discussão. As interações entre cadeias permitem que diferentes redes de blockchain se comuniquem, compartilhem dados e transfiram ativos de forma transparente, melhorando a interoperabilidade e ampliando o escopo das aplicações descentralizadas (dApps). Nesta lição, vamos explorar o que são as interações entre cadeias e como implementá-las, particularmente utilizando Solidity.

Compreendendo as Interações entre Cadeias

As interações entre cadeias permitem a troca de informações ou ativos entre diferentes redes de blockchain. Existem vários métodos para alcançar isso, incluindo:

1. Trocas Atômicas: Trocas ponto a ponto de criptomoedas de diferentes blockchains sem a necessidade de um terceiro confiável.
2. Tokens Envolvidos: Tokens de uma blockchain são encapsulados em um padrão de token de outra blockchain, proporcionando assim liquidez e usabilidade entre as cadeias.
3. Ponte entre Cadeias: Protocolos ou contratos inteligentes que facilitam a transferência de tokens e dados entre diferentes blockchains.

Para esta lição, iremos focar no conceito de tokens envolvidos.

Tokens Envolvidos

Tokens envolvidos são ativos digitais que representam outro ativo em uma blockchain diferente. Por exemplo, o Bitcoin Envolvido (WBTC) é um token ERC20 no Ethereum que é lastreado 1:1 por Bitcoin. Isso permite que os detentores de Bitcoin participem do ecossistema Ethereum.

Exemplo: Criando um Token Envolvido

Vamos escrever um contrato simples de token ERC20 em Solidity para representar uma versão envolvida de um ativo hipotético. O contrato do token envolvido permitirá que os usuários depositem o token original e recebam uma quantidade equivalente do token envolvido.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract TokenEnvolvido is ERC20Burnable, Ownable {
    IERC20 public tokenOriginal;

    constructor(IERC20 _tokenOriginal) ERC20("Token Envolvido", "TE") {
        tokenOriginal = _tokenOriginal;
    }

    function envolver(uint256 quantidade) external {
        require(quantidade > 0, "A quantidade deve ser maior que zero");
        require(tokenOriginal.transferFrom(msg.sender, address(this), quantidade), "Transferência falhou");
        _mint(msg.sender, quantidade);
    }

    function desvincular(uint256 quantidade) external {
        require(quantidade > 0, "A quantidade deve ser maior que zero");
        require(balanceOf(msg.sender) >= quantidade, "Saldo de token envolvido insuficiente");
        _burn(msg.sender, quantidade);
        require(tokenOriginal.transfer(msg.sender, quantidade), "Transferência falhou");
    }
}

Análise do Código

1. Imports: Importamos os contratos ERC20 e ERC20Burnable da biblioteca OpenZeppelin para facilitar a criação do nosso token.
2. Declaração do Contrato: Definimos nosso contrato TokenEnvolvido, herdando funcionalidades através de ERC20 e Ownable.
3. Variáveis de Estado: Definimos tokenOriginal para manter o ativo original.
4. Construtor: O construtor inicializa o contrato com o token original.
5. Função Envolver: Esta função permite que os usuários depositem seus tokens originais e recebam tokens envolvidos em troca.
6. Função Desvincular: Esta função permite que os usuários queimem seus tokens envolvidos para recuperar os tokens originais.

Interagindo com o Contrato

Para interagir com o contrato TokenEnvolvido, você alternará entre duas ações—envolver e desvincular. Aqui está um exemplo de como interagir com este contrato usando JavaScript com ethers.js:

const { ethers } = require("ethers");

// Conectar à rede Ethereum
const provider = new ethers.providers.JsonRpcProvider("http://localhost:8545");
const wallet = new ethers.Wallet("chave_privada", provider);

// Contrato de token envolvido
const enderecoTokenEnvolvido = "0xSeuEnderecoTokenEnvolvido";
const abiTokenEnvolvido = [...]; // ABI do contrato TokenEnvolvido
const contratoTokenEnvolvido = new ethers.Contract(enderecoTokenEnvolvido, abiTokenEnvolvido, wallet);

// Envolver tokens originais
async function envolverTokens(quantidade) {
    const tx = await contratoTokenEnvolvido.envolver(quantidade);
    await tx.wait();
    console.log(`Envolvidos ${quantidade} tokens!`);
}

// Desvincular tokens envolvidos
async function desvincularTokens(quantidade) {
    const tx = await contratoTokenEnvolvido.desvincular(quantidade);
    await tx.wait();
    console.log(`Desvinculados ${quantidade} tokens!`);
}

Conclusão

As interações entre cadeias são um aspecto vital da tecnologia blockchain, e os tokens envolvidos permitem que os usuários aproveitem as capacidades de múltiplas blockchains de maneira fácil. Nesta lição, exploramos o conceito de tokens envolvidos, como criar um token básico envolvido em Solidity e como interagir com o contrato usando JavaScript.

À medida que a tecnologia blockchain continua a se desenvolver, compreender as interações entre cadeias permitirá que os desenvolvedores criem aplicações descentralizadas mais complexas e eficientes. Continue experimentando com esses conceitos para fortalecer sua compreensão das soluções entre cadeias!

Video

Navigation