Tornando Seu Contrato Inteligente Solidity Atualizável

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

contract CheckClaim {
    using ECDSA for bytes32;

    mapping(address => uint256) public balances;
    mapping(address => mapping(uint256 => bool)) public usedNonces;

    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "Saldo insuficiente");
        balances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
    }

    function depositCheck(address recipient, bytes memory signature, uint256 amount, uint256 nonce) public {
        bytes32 message = prefixed(keccak256(abi.encodePacked(recipient, nonce, amount)));
        address signer = recoverSigner(message, signature);

        // Defina o destinatário como o endereço do remetente se ele estiver definido como address(0)
        // Isso permite que qualquer pessoa reivindique o cheque!
        if (recipient == address(0)) {
            recipient = msg.sender;
        }

        require(!usedNonces[signer][nonce], "O cheque ja foi usado");
        require(signer != address(0), "Assinatura invalida");
        require(balances[signer] >= amount, "Saldo insuficiente");

        balances[signer] -= amount;
        balances[recipient] += amount;
        usedNonces[signer][nonce] = true;
    }

    function claimCheckAndWithdraw(address recipient, bytes memory signature, uint256 amount, uint256 nonce) public {
        // Primeiro, solicite o cheque usando a função depositCheck
        depositCheck(recipient, signature, amount, nonce);

        // Em seguida, retire o valor reivindicado para o saldo real do usuário usando a função withdraw existente
        withdraw(amount);
    }

    function prefixed(bytes32 hash) internal pure returns (bytes32) {
        return hash.toEthSignedMessageHash();
    }

    function recoverSigner(bytes32 message, bytes memory signature) internal pure returns (address) {
        return message.recover(signature);
    }
}

// O contrato original atualizado
// SPDX-License-Identifier: MIT 
pragma solidity ^0.8.0;

import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

contract CheckClaimV1 is Initializable {
    using ECDSA for bytes32;

    mapping(address => uint256) public balances;
    mapping(address => mapping(uint256 => bool)) public usedNonces;

    function initialize() public initializer {
    }

    // Outras funções do contrato original devem ser colocadas aqui
    // deposit, withdraw, ...
}

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

import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";

contract YourProxy is TransparentUpgradeableProxy {
    constructor(address _logic, address _admin, bytes memory _data) 
        TransparentUpgradeableProxy(_logic, _admin, _data) {
    }
}

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

import "@openzeppelin/contracts/governance/TimelockController.sol";

contract YourTimelockController is TimelockController {
    constructor(uint256 minDelay, address[] memory proposers, address[] memory executors) 
        TimelockController(minDelay, proposers, executors) {
        renounceRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }
}

Projete um contrato inteligente Solidity atualizável que seja compatível com qualquer blockchain baseada em EVM (como Ethereum, Polygon, etc.) utilizando o padrão Proxy. Use as bibliotecas TransparentUpgradeableProxy, Initializable e TimelockController do OpenZeppelin.

O contrato atualizado deve incluir:

- Um atraso mínimo de 72 horas entre o momento em que um upgrade é iniciado e o momento em que ele entra em vigor, imposto pelo TimelockController.
- Um evento que é disparado no início do processo de atualização, contendo o endereço do novo contrato de implementação para verificação do usuário. Esse atraso tem o objetivo de permitir que os usuários validem as alterações antes de serem implementadas.
- Uma estrutura que permita a fácil adição e modificação de funções em versões futuras, preservando a estrutura das funções existentes. Ela também deve permitir a adição de novas variáveis de estado sem a necessidade de migração de dados.
- Uma convenção de nomenclatura para o contrato de implementação, que deve ser sufixado com V1. Esse contrato não deve ter conhecimento do proxy.

Requisitos:

- O código deve ser compilado sem espaços reservados, exceto para as funções do contrato original que não foram modificadas.
- Mantenha a solução o mais simples possível.
- Cada contrato deve ser escrito em seu próprio bloco de código. Esperamos três blocos de código, um para cada contrato.
- Forneça um script de implantação compatível com o Hardhat. Após a implantação, a função de administrador do TimeLockController deve ser renunciada.
- Tanto o proxy quanto os contratos herdados do TimeLockController devem ser mantidos básicos (apenas o construtor), pois todas as funcionalidades necessárias (upgradeTo, agendamento, execução) já estão incluídas no contrato básico. A maior parte do trabalho será feita no script de implantação e no script de atualização.
- O protótipo mais recente do construtor TimeLockController tem um quarto argumento adicional `TimelockController(uint256 minDelay, address[] memory proposers, address[] memory executors, address admin);`. O último argumento é o administrador. Para simplificar, coloque o administrador como o implantador (msg.sender). Também renuncie à função de administrador chamando renounceRole(DEFAULT_ADMIN_ROLE, msg.sender); dentro do construtor.
Aqui está o contrato inteligente: 
<código original do contrato inteligente>

const hre = require("hardhat");

async function main() {
  const [deployer, admin] = await hre.ethers.getSigners();
  console.log("Deployed by:", deployer.address, "admin", admin.address);

  const minDelay = 72 * 60 * 60; // 72 horas em segundos
  const proposers = [admin.address];
  const executors = [admin.address];

  const CheckClaimV1 = await ethers.getContractFactory("CheckClaimV1");
  const checkClaimV1 = await CheckClaimV1.deploy();
  await checkClaimV1.deployed();
  console.log("CheckClaimV1 deployed at:", checkClaimV1.address);

  const CheckClaimTimelock = await ethers.getContractFactory("CheckClaimTimelock");
  const timelock = await CheckClaimTimelock.deploy(minDelay, proposers, executors, admin.address);
  await timelock.deployed();
  console.log("CheckClaimTimelock deployed at:", timelock.address);

  const CheckClaimProxy = await ethers.getContractFactory("CheckClaimProxy");
  const proxy = await CheckClaimProxy.deploy(checkClaimV1.address, timelock.address, '0x');
  await proxy.deployed();
  console.log("CheckClaimProxy deployed at:", proxy.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });