25.11.2024

Lição 132: VRF (Funções Aleatórias Verificáveis)

No mundo da blockchain, a geração de números aleatórios pode ser uma tarefa desafiadora. No entanto, as Funções Aleatórias Verificáveis (VRFs) oferecem uma solução que garante que a aleatoriedade seja gerada de forma segura e verificável. Nesta lição, vamos explorar as VRFs, sua importância em contratos inteligentes e como implementá-las usando Solidity.

O que é uma VRF?

Uma Função Aleatória Verificável (VRF) é uma primitiva criptográfica que permite que uma parte gere um número aleatório que pode ser verificado posteriormente por outras partes sem a necessidade de informações adicionais. Essa propriedade é especialmente útil em aplicações descentralizadas (dApps), onde a transparência e a confiança são fundamentais.

Propriedades das VRFs:

1. Determinística: Dada a mesma entrada e chave privada, a saída será sempre a mesma.
2. Verificável: Qualquer pessoa pode verificar que a saída é realmente aleatória e foi gerada pelo detentor da chave privada.
3. Segura: É computacionalmente inviável prever a saída sem a chave privada.

Casos de Uso das VRFs em Contratos Inteligentes

1. Jogos: A aleatoriedade é crucial para um jogo justo, geração de caixas de loot, etc.
2. Sistemas de Loteria: Garante que o vencedor seja escolhido de forma justa e possa ser verificado por todos os participantes.
3. Distribuição Aleatória de Tokens: Distribuindo tokens aleatoriamente sem viés.

Implementando VRF em Solidity

Para usar VRFs em contratos inteligentes Ethereum, podemos utilizar o serviço VRF da Chainlink, que simplifica o processo. Aqui está um guia passo a passo para implementar e usar o VRF da Chainlink em um contrato inteligente em Solidity.

Pré-requisitos

Antes de começarmos, certifique-se de que você:

• Tem um entendimento básico de Solidity e contratos inteligentes Ethereum.
• Tem seu ambiente de desenvolvimento configurado (por exemplo, usando Hardhat ou Truffle).
• Tem um keyhash de VRF da Chainlink e um saldo de token LINK no ambiente onde seu contrato está implantado.

Passo 1: Importar Dependências da Chainlink VRF

Certifique-se de importar as interfaces necessárias da Chainlink VRF. Adicione as seguintes linhas de importação no início de seu contrato inteligente:

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

import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";

Passo 2: Criar um Contrato que Herda de VRFConsumerBase

Em seguida, crie um novo contrato que herde de VRFConsumerBase. Isso permitirá que você solicite números aleatórios e trate as respostas.

contract GeradorNumeroAleatorio is VRFConsumerBase {
    bytes32 internal keyHash;
    uint256 internal fee;
    uint256 public resultadoAleatorio;

    // Este evento será emitido quando o número aleatório for gerado
    event NumeroAleatorioGerado(uint256 numeroAleatorio);

    constructor(address _vrfCoordinator, address _link) 
        VRFConsumerBase(_vrfCoordinator, _link) {
        keyHash = 0x...; // Substitua pelo seu keyHash de VRF
        fee = 0.1 * 10 ** 18; // Taxa LINK (em wei)
    }
}

Passo 3: Solicitar um Número Aleatório

Você precisa de uma função para solicitar um número aleatório da Chainlink:

function obterNumeroAleatorio() public returns (bytes32 requestId) {
    require(LINK.balanceOf(address(this)) >= fee, "LINK insuficiente");
    return requestRandomness(keyHash, fee);
}

Passo 4: Lidar com a Resposta do Número Aleatório

Você deve sobrescrever a função fulfillRandomness para lidar com o número aleatório recebido do Coordenador de VRF.

function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
    resultadoAleatorio = randomness;
    emit NumeroAleatorioGerado(resultadoAleatorio);
}

Exemplo Completo do Contrato

Unindo tudo, aqui está o contrato inteligente completo para gerar um número aleatório usando o VRF da Chainlink:

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

import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";

contract GeradorNumeroAleatorio is VRFConsumerBase {
    bytes32 internal keyHash;
    uint256 internal fee;
    uint256 public resultadoAleatorio;

    event NumeroAleatorioGerado(uint256 numeroAleatorio);

    constructor(address _vrfCoordinator, address _link) 
        VRFConsumerBase(_vrfCoordinator, _link) {
        keyHash = 0x...; // Substitua pelo seu keyHash de VRF
        fee = 0.1 * 10 ** 18; // Taxa LINK (em wei)
    }

    function obterNumeroAleatorio() public returns (bytes32 requestId) {
        require(LINK.balanceOf(address(this)) >= fee, "LINK insuficiente");
        return requestRandomness(keyHash, fee);
    }

    function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
        resultadoAleatorio = randomness;
        emit NumeroAleatorioGerado(resultadoAleatorio);
    }
}

Conclusão

As Funções Aleatórias Verificáveis são um componente essencial no ecossistema blockchain, garantindo que a aleatoriedade em aplicações descentralizadas seja tanto segura quanto verificável. Ao implementar o VRF da Chainlink em seus contratos inteligentes, você pode aproveitar uma fonte de aleatoriedade fácil de usar e confiável, abrindo caminho para aplicações justas e transparentes.

Experimente esse conhecimento para criar suas próprias aplicações que exigem aleatoriedade, e lembre-se de que incorporar VRFs pode aumentar a confiabilidade de suas dApps. Boa codificação!

Video

Navigation