03.12.2024

Lição 216: Canais de Pagamento

Os canais de pagamento são uma técnica poderosa na tecnologia blockchain que permite transações eficientes entre partes sem precisar executar cada transação na blockchain. Esse mecanismo possibilita que as partes realizem várias transações fora da cadeia (off-chain) e só submetam o estado final à blockchain, reduzindo significativamente os custos de gás e aumentando a capacidade de processamento.

Nesta lição, discutiremos o que são os canais de pagamento, como funcionam e forneceremos um exemplo implementado em Solidity.

O que são Canais de Pagamento?

Os canais de pagamento criam um canal privado entre duas partes, permitindo que realizem transações fora da cadeia, enquanto oferecem um mecanismo para liquidar o saldo final na blockchain principal. Eles são especialmente úteis para microtransações, onde as transações tradicionais na cadeia podem ser muito custosas.

Características Principais:

• Transações Off-Chain: Permitem que múltiplas transações ocorram fora da cadeia.
• Liquidação Final: Apenas o saldo final é submetido à blockchain, diminuindo os custos de gás.
• Liquidações Atômicas: Se uma das partes tentar enganar a outra, existem mecanismos em vigor para reverter ao último estado válido.

Como Funcionam os Canais de Pagamento

O Processo

1. Criação do Canal: Duas partes bloqueiam uma certa quantia de criptomoeda em um contrato inteligente.
2. Transações Off-Chain: As partes podem trocar mensagens assinadas que representam os pagamentos. Embora essas mensagens sejam off-chain, elas são provas válidas da transação até que o canal seja fechado.
3. Fechamento do Canal: Assim que as partes decidem finalizar suas transações, uma delas pode submeter um estado final à blockchain, que é então verificado pelo contrato inteligente.

Exemplo de Implementação em Solidity

Abaixo está um exemplo simples de um contrato de canal de pagamento em Solidity. Neste exemplo, Alice e Bob podem criar um canal de pagamento, realizar pagamentos fora da cadeia e, finalmente, fechar o canal.

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

contract CanalDePagamento {
    address public pagador;
    address public beneficiario;
    uint public saldo;
    uint public expiracao;

    mapping(bytes32 => bool) public pagamentosProcessados;

    event PagamentoEnviado(address indexed de, uint quantia);
    event CanalFechado(address indexed ganhador, uint quantia);

    constructor(address _beneficiario, uint _duracao) payable {
        require(msg.value > 0, "O saldo inicial não pode ser zero");
        pagador = msg.sender;
        beneficiario = _beneficiario;
        saldo = msg.value;
        expiracao = block.timestamp + _duracao;
    }

    function enviarPagamento(bytes32 _hashPagamento, bytes memory _assinatura) external {
        require(block.timestamp < expiracao, "Canal expirou");
        require(!pagamentosProcessados[_hashPagamento], "Pagamento já processado");

        // Verifica a assinatura
        address signatario = recuperarSignatario(_hashPagamento, _assinatura);
        require(signatario == beneficiario, "Assinatura inválida");

        // Atualiza o estado
        pagamentosProcessados[_hashPagamento] = true;
        saldo -= uint(_hashPagamento);

        emit PagamentoEnviado(pagador, uint(_hashPagamento));
    }

    function fecharCanal(uint _saldoFinal) external {
        require(msg.sender == pagador || msg.sender == beneficiario, "Apenas participantes do canal podem fechar");
        require(block.timestamp >= expiracao, "Canal ainda está aberto");

        if (msg.sender == pagador) {
            payable(pagador).transfer(saldo);
        } else {
            payable(beneficiario).transfer(saldo);
        }

        emit CanalFechado(msg.sender, saldo);
    }

    function recuperarSignatario(bytes32 _hashPagamento, bytes memory _assinatura) private pure returns (address) {
        // Recupera o endereço do signatário a partir de um hash e uma assinatura
        // Implementação para recuperar o endereço vai aqui

        return address(0);
    }
}

Explicação do Código

• Construtor: Inicializa o canal de pagamento, exigindo que um saldo inicial seja definido e especificando o beneficiário e o tempo de expiração do canal.
• enviarPagamento(): Permite que o beneficiário envie pagamentos off-chain fornecendo um valor de pagamento hash e uma assinatura. Os pagamentos são rastreados e não podem ser processados novamente.
• fecharCanal(): Fecha o canal de pagamento e permite que qualquer um dos participantes retire seu saldo após a expiração.
• recuperarSignatario(): Uma função de espaço reservado que implementaria a lógica para recuperar o signatário a partir de uma assinatura (isso requer implementações criptográficas adicionais).

Conclusão

Os canais de pagamento proporcionam um meio de realizar transações eficientes e de baixo custo em ambientes onde os usuários precisam executar inúmeras transações sem sobrecarregar a blockchain.

Ao utilizar canais de pagamento, as aplicações podem aprimorar a experiência do usuário ao permitir transações instantâneas, mantendo a confiabilidade da blockchain. O exemplo fornecido oferece uma estrutura básica para construir um canal de pagamento em Solidity, que pode ser expandida com base em casos de uso específicos.

Com esta base, os desenvolvedores podem explorar otimizações e melhorias adicionais para criar implementações de canais de pagamento robustas adequadas para suas aplicações.

Video

Navigation