Criar um Canal de pagamento unidirecional

porMatheusem10/06/2022

Nesse artigo iremos aprender a como criar um canal de pagamento unidirecional através de um contrato inteligente.

Canal de pagamento unidirecional

Os canais de pagamento permitem que os participantes transfiram repetidamente o Ether para fora da blockchain.

Veja como este contrato é usado:

  • Alice implanta o contrato, financiando-o com Ether.
  • Alice autoriza um pagamento assinando uma mensagem (fora da blockchain) e envia a assinatura para Bob.
  • Bob reivindica seu pagamento apresentando a mensagem assinada ao contrato inteligente.
  • Se Bob não reivindicar seu pagamento, Alice recupera o Ether após o término do contrato.

Isso é chamado de canal de pagamento unidirecional, pois o pagamento pode ir apenas em uma única direção, de Alice para Bob.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.5/contracts/utils/cryptography/ECDSA.sol";
import "github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.5/contracts/security/ReentrancyGuard.sol";
contract UniDirectionalPaymentChannel is ReentrancyGuard {
using ECDSA for bytes32;
address payable public sender;
address payable public receiver;
uint private constant DURATION = 7 * 24 * 60 * 60;
uint public expiresAt;
constructor(address payable _receiver) payable {
require(_receiver != address(0), "receiver = endereço zero");
sender = payable(msg.sender);
receiver = _receiver;
expiresAt = block.timestamp + DURATION; // Define quando o contrato irá expirar
}
function _getHash(uint _amount) private view returns (bytes32) {
// NOTA: assine com o endereço deste contrato para proteger contra
// ataque de repetição de outros contratos
return keccak256(abi.encodePacked(address(this), _amount));
}
function getHash(uint _amount) external view returns (bytes32) {
return _getHash(_amount);
}
function _getEthSignedHash(uint _amount) private view returns (bytes32) {
return _getHash(_amount).toEthSignedMessageHash();
}
function getEthSignedHash(uint _amount) external view returns (bytes32) {
return _getEthSignedHash(_amount);
}
function _verify(uint _amount, bytes memory _sig) private view returns (bool) {
return _getEthSignedHash(_amount).recover(_sig) == sender;
}
function verify(uint _amount, bytes memory _sig) external view returns (bool) {
return _verify(_amount, _sig);
}
function close(uint _amount, bytes memory _sig) external nonReentrant {
require(msg.sender == receiver, "!receiver");
require(_verify(_amount, _sig), "Assinatura inválida");
(bool sent, ) = receiver.call{value: _amount}("");
require(sent, "Falha ao enviar Ether");
selfdestruct(sender);
}
// Cancela o envio da mensagem
function cancel() external {
require(msg.sender == sender, "!sender");
require(block.timestamp >= expiresAt, "!expired");
selfdestruct(sender);
}
}

Testar no Remix