🖥️Para Desenvolvedores

Contrato

Contrato WEbdEXFactoryV3

solidityCopy code// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

import "@openzeppelin/contracts/access/Ownable.sol";

SPDX-License-Identifier: Este é um comentário SPDX-License-Identifier indicando que o contrato está licenciado sob o MIT.
pragma solidity ^0.8.18: Indica a versão mínima do compilador Solidity necessária para compilar o contrato.
Importação de bibliotecas:
- O contrato importa a biblioteca Ownable do OpenZeppelin, que fornece funcionalidades básicas de controle de propriedade.

solidityCopy codecontract WEbdEXFactoryV3 is Ownable {

Declaração de Variáveis:
- bots: Uma matriz interna de estruturas Bot.
- faucets, wusd, usdt, dai, usdc, switchWUSD, swapBook, payments: Endereços de contratos relacionados à plataforma WEbdEX.

solidityCopy code    Bot[] internal bots;
    address public faucets;
    address public wusd;
    address public usdt;
    address public dai;
    address public usdc;
    address public switchWUSD;
    address public swapBook;
    address public payments;

Struct Bot:
- Define uma estrutura chamada Bot que armazena informações sobre um bot, incluindo seu nome, endereço da carteira, endereços de contratos relevantes, e outros.

solidityCopy code    struct Bot {
        string name;
        string wallet;
        address faucets;
        address wusd;
        address usdt;
        address dai;
        address usdc;
        address botManager;
        address switchWUSD;
        address swapBook;
        address pass;
        address networkPool;
        address strategies;
        address payments;
    }

Constructor:
- O construtor recebe os endereços iniciais dos contratos relevantes e os atribui às variáveis correspondentes.

solidityCopy code    constructor(
        address faucets_,
        address wusd_,
        address usdt_,
        address dai_,
        address usdc_,
        address switchWUSD_,
        address swapBook_,
        address payments_
    ) {
        faucets = faucets_;
        wusd = wusd_;
        usdt = usdt_;
        dai = dai_;
        usdc = usdc_;
        switchWUSD = switchWUSD_;
        swapBook = swapBook_;
        payments = payments_;
    }

Função addBot:
- Permite ao proprietário adicionar um novo bot à plataforma, fornecendo informações como nome, carteira, e endereços dos contratos relevantes.

solidityCopy code    function addBot(
        string memory name,
        string memory wallet,
        address botManager,
        address pass,
        address strategies,
        address networkPool
    ) public onlyOwner {
        bots.push(
            Bot(
                name,
                wallet,
                faucets,
                wusd,
                usdt,
                dai,
                usdc,
                botManager,
                switchWUSD,
                swapBook,
                pass,
                networkPool,
                strategies,
                payments
            )
        );
    }

Função getBots:
- Permite ao proprietário obter a lista de bots adicionados à plataforma.

solidityCopy code    function getBots() public view onlyOwner returns (Bot[] memory) {
        return bots;
    }
}

Essas são as principais características e funcionalidades do contrato. Ele serve como uma fábrica para criar bots, mantendo uma lista de bots existentes e seus detalhes.

Contrato WEbdEXManagerV3

solidityCopy code// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

import "@openzeppelin/contracts/access/Ownable.sol";
import "../utils/NFT.sol";

interface IWEbdEXPassV3 {
    struct User {
        bool passExpired;
        bool haveFreeTrial;
        uint256 expirationTime;
    }

    function getUserInfoByWallet(address to) external view returns (User memory);
}

Diretivas de Licença e Pragma:
- SPDX-License-Identifier especifica a licença sob a qual o contrato é lançado.
- Pragma solidity ^0.8.18 define a versão mínima do compilador Solidity.
Declarações de Importação:
- O contrato importa o contrato Ownable da biblioteca OpenZeppelin e um contrato NFT personalizado.

solidityCopy codecontract WEbdEXManagerV3 is Ownable {

Declaração do Contrato:
- O contrato herda do contrato Ownable, indicando que possui controle de acesso baseado no proprietário.

solidityCopy code    Bot public bot;
    IWEbdEXPassV3 public webDexPassV3;
    Register[] internal registers;
    address public webDexStrategiesV3;

Variáveis de Estado:
- bot: Armazena informações sobre um bot, incluindo seu nome, contrato de token associado, carteira e endereço do vendedor.
- webDexPassV3: Representa uma interface para o contrato WEbdEXPassV3, permitindo acesso às informações do usuário.
- registers: Uma matriz para armazenar detalhes de registro, incluindo a carteira do usuário e o gerente associado.
- webDexStrategiesV3: Endereço do contrato WebDexStrategies.

solidityCopy code    mapping(address => User) internal users;

    struct User {
        address manager;
        bool status;
    }

    struct Bot {
        string name;
        address token;
        address wallet;
        address seller;
    }

Mapeamento e Estruturas:
- users: Um mapeamento para armazenar informações do usuário com base em seu endereço.
- User: Uma estrutura representando detalhes do usuário, incluindo o gerente associado e o status de registro.
- Bot: Uma estrutura representando detalhes do bot, incluindo seu nome, token associado, carteira e endereço do vendedor.

solidityCopy code    struct Register {
        address wallet;
        address manager;
    }

    struct Display {
        address wallet;
        address manager;
        bool status;
        bool passExpired;
        bool haveFreeTrial;
        uint256 expirationTime;
    }

Estruturas Adicionais:
- Register: Uma estrutura para armazenar detalhes de registro, incluindo a carteira do usuário e o gerente associado.
- Display: Uma estrutura representando detalhes do usuário para fins de exibição, incluindo carteira, gerente, status, expiração do passe, status de teste gratuito e tempo de expiração.

solidityCopy code    event Transaction(
        address indexed from,
        string method,
        uint256 timeStamp,
        address to,
        uint256 value
    );

    constructor(
        string memory name_,
        string memory symbol_,
        address wallet_,
        IWEbdEXPassV3 webDexPassV3_,
        address seller_
    ) {
        bot = Bot(
            name_,
            address(
                new NFT(string(abi.encodePacked(name_, " Affiliated")), symbol_)
            ),
            wallet_,
            seller_
        );
        webDexPassV3 = webDexPassV3_;
    }

Evento e Construtor:
- Transaction event: Registra transações com detalhes como remetente, método, carimbo de data/hora, destinatário e valor.
- Constructor: Inicializa o contrato com os detalhes do bot, incluindo seu nome, token, carteira e vendedor, bem como a interface do contrato WEbdEXPassV3.

solidityCopy code    modifier onlyWebDexStrategiesOrOwner() {
        require(
            msg.sender == webDexStrategiesV3 ||
                (msg.sender == owner() && webDexStrategiesV3 != address(0)),
            "You must own the contract or the WebDexStrategies"
        );

        _;
    }

Modificador:
- onlyWebDexStrategiesOrOwner: Um modificador restringindo o acesso a certas funções ao proprietário ou ao contrato WebDexStrategies.

solidityCopy code    function changeWEbdEXStrategiesV3(
        address newWebDexStrategiesV3
    ) public onlyOwner {
        webDexStrategiesV3 = newWebDexStrategiesV3;
    }

Função:
- changeWEbdEXStrategiesV3: Permite que o proprietário altere o endereço do contrato WebDexStrategies.

solidityCopy code    function registerInBot(address manager) public {
        // Function implementation...
    }

Função:
- registerInBot: Permite que os usuários se registrem no bot, associando-se a um gerente e emitindo um NFT.

solidityCopy code    function getUserInfo() public view returns (Display memory) {
        return _getUser(msg.sender);
    }

Função:
- getUserInfo: Recupera as informações do usuário para o chamador.

solidityCopy code    function getUserInfoByWallet(address to) public view onlyWebDexStrategiesOrOwner returns (Display memory) {
        return _getUser(to);
    }

Função:
- getUserInfoByWallet: Recupera informações do usuário com base no endereço da carteira fornecido, restrito ao proprietário ou ao contrato WebDexStrategies.

solidityCopy code    function getBot() public view returns (Bot memory) {
        return bot;
    }

Função:
- getBot: Recupera informações sobre o bot.

solidityCopy code    function getRegisters() public view returns (Register[] memory) {
        return registers;
    }

Função:
- getRegisters: Recupera uma matriz de detalhes de registro.

solidityCopy code    function _getUser(address to) internal view returns (Display memory) {
        // Function implementation...
    }
}

Função Interna:
- _getUser: Função interna para recuperar informações do usuário com base no endereço fornecido.

Essa análise fornece uma visão detalhada do contrato WEbdEXManagerV3, incluindo suas variáveis de estado, funções e modificadores.

Contrato WEbdEXPassV3

solidityCopy code// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

interface IWEbdEXStrategiesV3 {
    function lpMint(address to, address coin, uint256 amount) external returns (address);
}

interface IWEbdEXNetworkPoolV3 {
    function addBalance(address to, address coin, uint256 amount, address lpToken, address user, string memory method) external;
}

contract WEbdEXPassV3 is Ownable {
    ERC20 public erc20;

    uint256 public monthlyPassValue;
    uint256 public quarterlyPassValue;
    uint256 public semesterPassValue;
    uint256 public annualPassValue;

    uint256 internal constant monthlyExpirationTime = 30 days;
    uint256 internal constant quarterlyExpirationTime = 90 days;
    uint256 internal constant semesterExpirationTime = 180 days;
    uint256 internal constant annualExpirationTime = 365 days;
    uint256 public freeTrialExpirationTime;

    mapping(address => uint256) internal expirationTimes;
    mapping(address => uint256) internal freeTrials;

    enum PassType {
        MONTHLY,
        QUARTERLY,
        SEMESTER,
        ANNUAL
    }

    struct User {
        bool passExpired;
        bool haveFreeTrial;
        uint256 expirationTime;
    }

Diretivas de Licença e Pragma:
- SPDX-License-Identifier especifica a licença sob a qual o contrato é lançado.
- Pragma solidity ^0.8.18 define a versão mínima do compilador Solidity.
Declarações de Importação:
- O contrato importa o contrato ERC20 da biblioteca OpenZeppelin e o contrato Ownable para controle de acesso.

solidityCopy code    event PayFee(address indexed wallet, address indexed coin, uint256 amount);

    event ExtractLogs(address indexed from, string method, uint256 timeStamp, address to, uint256 value);

    event PayPass(address indexed from, address coin, uint256 value);

Eventos:
- PayFee: Emitido quando uma taxa é paga. Inclui detalhes como a carteira, moeda e quantidade.
- ExtractLogs: Emitido para vários registros de transações. Inclui detalhes como o remetente, método, carimbo de data/hora, destinatário e valor.
- PayPass: Emitido quando uma assinatura é paga. Inclui detalhes como o remetente, moeda e valor.

solidityCopy code    struct NetworkData {
        address wallet;
        uint256 amount;
    }

    struct PayFeesAmount {
        NetworkData[] network;
        uint256 seller;
        uint256 bot;
        uint256 manager;
        address token;
        address user;
        string transaction;
    }

    struct PayComissions {
        PayFeesAmount list;
        address seller;
        address bot;
        address manager;
        IWEbdEXStrategiesV3 webDexStrategiesV3;
        IWEbdEXNetworkPoolV3 webDexNetworkPoolV3;
    }

Estruturas:
- NetworkData: Representa dados sobre uma rede, incluindo carteira e quantia.
- PayFeesAmount: Representa quantias para várias taxas, incluindo taxas de rede, taxa de vendedor, taxa de bot, taxa de gerente, token, usuário e tipo de transação.
- PayComissions: Representa a estrutura de comissões com uma lista de taxas e endereços para vendedor, bot, gerente, webDexStrategiesV3 e webDexNetworkPoolV3.

solidityCopy code    mapping(string => bool) private listPayments;

    mapping(address => bool) private privilegedWallets;

    constructor(
        ERC20 erc20_,
        uint256 monthlyPassValue_,
        uint256 quarterlyPassValue_,
        uint256 semesterPassValue_,
        uint256 annualPassValue_,
        uint256 freeTrialExpirationTime_
    ) {
        erc20 = erc20_;
        monthlyPassValue = monthlyPassValue_;
        quarterlyPassValue = quarterlyPassValue_;
        semesterPassValue = semesterPassValue_;
        annualPassValue = annualPassValue_;
        freeTrialExpirationTime = freeTrialExpirationTime_;
    }

Mapeamentos e Construtor:
- listPayments: Um mapeamento para controlar se um pagamento foi feito.
- privilegedWallets: Um mapeamento para gerenciar carteiras privilegiadas.
- Constructor: Inicializa o contrato com detalhes do token ERC20, valores do passe e tempo de expiração do teste gratuito.

solidityCopy code    modifier onlyWalletPrivileged() {
        require(msg.sender == owner() || privilegedWallets[msg.sender], "You must be the owner or privilegedWallets");
        _;
    }

    modifier onlyHaveFreeTrial() {
        require(_haveFreeTrial(msg.sender), "Have you already used your free trial");
        _;
    }

Modificadores:
- onlyWalletPrivileged: Um modificador para restringir o acesso apenas ao proprietário ou a carteiras privilegiadas.
- onlyHaveFreeTrial: Um modificador para verificar se o usuário possui um teste gratuito.

solidityCopy code    function comissionPass(PayComissions memory payments) public onlyOwner {
        // Function implementation...
    }

Função:
- comissionPass: Permite que o proprietário pague várias comissões. Utiliza uma estrutura complexa com diferentes taxas e destinos.

solidityCopy code    function _payFee(
        address coin,
        uint256 amount,
        address to,
        address user,
        IWEbdEXStrategiesV3 webDexStrategiesV3,
        IWEbdEXNetworkPoolV3 webDexNetworkPoolV3
    ) internal {
        // Function implementation...
    }

Função interna:
- _payFee: Função interna para facilitar o pagamento de taxas, envolvendo a emissão de LP e a adição de saldos ao pool de rede.

solidityCopy code    function changeFreeTrialExpirationTime(uint256 newExpirationTime) public onlyWalletPrivileged {
        // Function implementation...
    }

Função:
- changeFreeTrialExpirationTime: Permite que o proprietário ou carteiras privilegiadas alterem o tempo de expiração do teste gratuito.

solidityCopy code    function changePassValue(PassType passType, uint256 value) public onlyWalletPrivileged {
        // Function implementation...
    }

Função:
- changePassValue: Permite que o proprietário ou carteiras privilegiadas alterem os valores do passe com base no tipo de passe.

solidityCopy code    function payPass(PassType passType) public {
        // Function implementation...
    }

Função:
- payPass: Permite que os usuários paguem por um passe com base no tipo de passe.

solidityCopy code    function getFreeTrial() public onlyHaveFreeTrial {
        // Function implementation...
    }

Função:
- getFreeTrial: Permite que os usuários obtenham um teste gratuito.

solidityCopy code    function sendPass(PassType passType, address to) public onlyWalletPrivileged {
        // Function implementation...
    }

Função:
- sendPass: Permite que o proprietário ou carteiras privilegiadas enviem um passe para um endereço especificado.

solidityCopy code    function addWalletPrivilege(address wallet) public onlyOwner {
        privilegedWallets[wallet] = true;
    }

    function revokeWalletPrivilege(address wallet) public onlyOwner {
        privilegedWallets[wallet] = false;
    }

Funções:
- addWalletPrivilege: Permite que o proprietário adicione privilégios a uma carteira.
- revokeWalletPrivilege: Permite que o proprietário revogue os privilégios de uma carteira.

solidityCopy code    function getUserInfo() public view returns (User memory) {
        return _getUserInfo(msg.sender);
    }

    function getUserInfoByWallet(address to) public view returns (User memory) {
        return _getUserInfo(to);
    }

Funções:
- getUserInfo: Recupera informações do usuário para o chamador.
- getUserInfoByWallet: Recupera informações do usuário com base no endereço da carteira fornecido.

solidityCopy code    function _getUserInfo(address to) internal view returns (User memory) {
        return User(_passExpired(to), _haveFreeTrial(to), expirationTimes[to]);
    }

    function _passExpired(address to) internal view returns (bool) {
        return block.timestamp >= expirationTimes[to];
    }

    function _haveFreeTrial(address to) internal view returns (bool) {
        return freeTrials[to] == 0;
    }
}

Funções Internas:
- _getUserInfo: Função interna para recuperar informações do usuário com base no endereço fornecido.
- _passExpired: Função interna para verificar se o passe para o endereço fornecido expirou.
- _haveFreeTrial: Função interna para verificar se o usuário no endereço fornecido possui um período de teste gratuito.

Esta análise fornece uma visão detalhada do contrato WEbdEXPassV3, incluindo suas variáveis de estado, eventos, modificadores, funções e funções internas.

PreviousPara Designers NextIsenção de Responsabilidade

Last updated 1 year ago