28.11.2024

Lição 166: Transações Sem Gas e Meta-Transações

No mundo do Ethereum e de aplicações descentralizadas (dApps), o conceito de gas é fundamental. Cada operação executada na blockchain requer uma certa quantidade de gas, que é paga em Ether (ETH). No entanto, há um crescente interesse nas transações sem gas e nas meta-transações, que permitem aos usuários interagir com contratos sem a necessidade de ter ETH para taxas de gas. Nesta lição, exploraremos esses conceitos, seus benefícios e forneceremos exemplos de código sobre como implementar meta-transações em Solidity.

O que são Meta-Transações?

Uma meta-transação é uma transação que é submetida por uma terceira parte em nome de um usuário. Isso permite que o usuário interaja com um contrato inteligente sem precisar pagar as taxas de gas diretamente. A terceira parte, muitas vezes chamada de relayer, paga as taxas de gas, e os usuários podem enviar transações usando assinaturas para autorizar o relayer a agir em seu nome.

Benefícios das Meta-Transações

1. Experiência do Usuário: Os usuários não precisam ter ETH em suas carteiras para usar a dApp, permitindo uma integração mais tranquila.
2. Redução de Fricção: Usuários podem interagir com a plataforma mesmo sem experiência com tecnologia blockchain.
3. Ecossistema Incentivado: Relayers podem cobrar pelo seu serviço, criando um novo modelo econômico para aplicações descentralizadas.

Implementando Meta-Transações

Vamos implementar um sistema simples de meta-transação usando Solidity. Nosso exemplo incluirá:

1. Um contrato simples que permite aos usuários fazer uma transferência.
2. Um relayer que gerenciará as meta-transações.

Exemplo de Contrato Inteligente

Aqui está um contrato inteligente básico em Solidity que permite que os usuários executem uma operação de transferência via meta-transações:

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

contract MetaTransactionExample {
    mapping(address => uint256) private balances;

    event Transfer(address indexed from, address indexed to, uint256 value);

    constructor() {
        balances[msg.sender] = 1000; // Saldo inicial para o criador do contrato
    }

    function deposit(uint256 amount) external {
        balances[msg.sender] += amount;
    }

    function getBalance(address user) external view returns (uint256) {
        return balances[user];
    }

    function transfer(address to, uint256 amount) external {
        require(balances[msg.sender] >= amount, "Saldo insuficiente");
        balances[msg.sender] -= amount;
        balances[to] += amount;
        emit Transfer(msg.sender, to, amount);
    }

    function executeMetaTransaction(address from, address to, uint256 amount, bytes memory signature) external {
        // Recupera o assinante da mensagem
        bytes32 messageHash = keccak256(abi.encodePacked(from, to, amount));
        address recovered = recoverSigner(messageHash, signature);

        require(recovered == from, "Assinatura inválida");

        // Prosseguir com a transferência
        transfer(to, amount);
    }

    function recoverSigner(bytes32 messageHash, bytes memory signature) internal pure returns (address) {
        (bytes32 r, bytes32 s, uint8 v) = splitSignature(signature);
        return ecrecover(messageHash, v, r, s);
    }

    function splitSignature(bytes memory sig) internal pure returns (bytes32 r, bytes32 s, uint8 v) {
        require(sig.length == 65, "Tamanho de assinatura inválido");
        assembly {
            r := mload(add(sig, 0x20))
            s := mload(add(sig, 0x40))
            v := byte(0, mload(add(sig, 0x60)))
        }
    }
}

Explicação do Contrato Inteligente

1. Variáveis de Estado:

   • balances: Um mapeamento que rastreia os saldos dos usuários.

2. Eventos:

   • Transfer: Emitido quando uma transferência ocorre.

3. Funções:

   • deposit: Permite que usuários depositem fundos.
   • getBalance: Permite consultar o saldo de qualquer usuário.
   • transfer: Uma função de transferência tradicional que deduz do saldo do remetente e credita o saldo do destinatário.
   • executeMetaTransaction: Esta função permite que um usuário assine uma mensagem fora da cadeia, que pode então ser enviada ao relayer para execução. A assinatura é verificada e, se válida, a transferência é executada.

4. Tratamento de Assinaturas:

   • recoverSigner, splitSignature: Estas funções internas trabalham em conjunto para recuperar o endereço do assinante a partir de uma assinatura fornecida, garantindo que a mensagem foi de fato assinada pelo usuário autorizado a realizar a transferência.

Como Usar Isso na Prática

1. Usuário Assina a Transação: O usuário cria uma meta-transação assinando uma mensagem que especifica os detalhes da transferência.
2. Relayer Envia a Transação: O relayer recebe a mensagem assinada e chama executeMetaTransaction no contrato inteligente com a mensagem assinada.
3. Contrato Inteligente Verifica: O contrato inteligente verifica a assinatura e executa a transferência.

Conclusão

Transações sem gas e meta-transações são ferramentas poderosas para aprimorar a experiência do usuário dentro de aplicações descentralizadas. Ao permitir que os usuários interajam com contratos inteligentes sem se preocupar com taxas de gas, você pode aumentar significativamente o engajamento e a adoção dos usuários. Nesta lição, criamos um exemplo simples de um sistema de meta-transação usando Solidity. À medida que o ecossistema blockchain evolui, explorar esses conceitos avançados manterá você na vanguarda do desenvolvimento de dApps.

Navigation