Audit & Code Verification

pgFactory.sol Show Code

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./interface/IPgMerchant.sol";
import "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";

contract PgFactory is OwnableUpgradeable {
    using StringsUpgradeable for uint256;
    using SafeERC20Upgradeable for IERC20Upgradeable;

IPgMerchant[] public pgContracts;
    address public wkCompany;
    address public pgBeacon;
    mapping(address => address) public upline;
    mapping(address => address) public merchantExecutor; //executor address to merchant(contract) address
    uint256 public fees; //10 / 100 = 0.1%
    uint256 public shareRevenue;
    mapping(address => address) public wdExecutor; //wdExecutor addr => merchantExecutor addr
    mapping(address => address) public merchantToWd; // merchantExecutor => wdExecutor
    bytes public constant PREFIX = "\x19Ethereum Signed Message:\n32";
    mapping(address => bool) public mapSigners;
    address[] public signers;
    address[] public beneficiaryAddress;

mapping(uint256 => bool) public uniqueIdExists;

event Register(
        address merchantExecutor,
        address referral,
        address[] beneficiaryAddresses,
        address merchantContract
    );
    event DepSupplyApprovalGas(
        address merchantExecutor,
        uint256 batchId,
        uint256 supplyGas
    );
    event DepUpdateBeneficiary(address merchantExecutor);
    event DepFundOutEoa(
        address merchantExecutor,
        address token,
        uint256 fundOut
    );
    event DepFundOutContract(
        address merchantExecutor,
        address token,
        uint256 fundOut
    );
    event DepFundOutEoaBnb(address merchantExecutor, uint256 fundOut);

event WdSupplyRolling(
        address merchantExecutor,
        IERC20Upgradeable[] tokens,
        uint256[] amounts,
        bytes32 root
    );
    event WdFundOut(address merchantExecutor, IERC20Upgradeable[] tokens);
    event WdSupplyExecutorGas(address merchantExecutor, uint256 supplyGas);
    event WdPayout(address merchantExecutor, bytes32 randomValue);
    event WdEnable(address merchantExecutor, address wdExecutor);
    event WdSetSecurity(
        address merchantExecutor,
        IERC20Upgradeable[] tokens,
        uint256[] lprAmounts
    );

modifier onlyExecutor() {
        require(
            merchantExecutor[msg.sender] != address(0),
            "Msg sender is not executor"
        );
        _;
    }

modifier onlyWithdrawalExecutor() {
        require(
            wdExecutor[msg.sender] != address(0),
            "Msg sender is not wdExecutor"
        );
        _;
    }

// Checking only Factory address is DEV
    modifier onlyDev() {
        require(
            // Factory Address (DEV)
            address(this) == 0x3dC1a115619b8fb4f653599B05c1b8cB57cFA0Ac,
            "Function disable in live mode"
        );
        _;
    }

/// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers(); // Disables the direct usage of the constructor.
    }

function initialize(address _pgBeacon) public initializer {
        __Ownable_init();
        pgBeacon = _pgBeacon;
        fees = 50; //0.5%
        shareRevenue = 5000; //50%
        wkCompany = 0x2D96EE9F1671fB9C100D7e177687fbdC1827854D;
    }

//+====================================+
    //| Exclusive one time use only        |
    //+====================================+
    // function meetsRedoInitialize(IPgMerchant pgContract) public onlyOwner {
    //     pgContract.redoInitialize();
    // }

// function insertMeetsIntoPGFactory() public onlyOwner {
    //     for (uint256 i = 0; i < pgContracts.length; i++) {
    //         require(
    //             address(pgContracts[i]) != meetsAddr,
    //             "Address already exists in the array"
    //         );
    //     }
    //     IPgMerchant newPg = IPgMerchant(meetsAddr);
    //     pgContracts.push(newPg);
    //     merchantExecutor[execAddr] = address(meetsAddr); //will be hardcoded for main live, change msg.sender
    //     upline[execAddr] = wkCompany; //will be hardcoded for main live
    // }

//rmb to call once
    function setSignersHardcoded() public onlyOwner {
        // Clear existing signers if any
        delete signers;

// Add the signer address
        signers.push(0x39382035fB6b9313916B893a47a33E924F8d765E);
        mapSigners[0x39382035fB6b9313916B893a47a33E924F8d765E] = true;
    }

//====================================================================================
    function getAllPgContracts() external view returns (IPgMerchant[] memory) {
        return pgContracts;
    }

function setIndividualMerchantFees(
        IPgMerchant pgContract,
        uint256 _newFees
    ) public onlyOwner {
        pgContract.setFees(_newFees);
    }

function setIndividualMerchantShareRevenue(
        IPgMerchant pgContract,
        uint256 _newShareRevenue
    ) public onlyOwner {
        pgContract.setShareRevenue(_newShareRevenue);
    }

function register(
        address _referral,
        address[] calldata beneficiaryAddresses
    ) public {
        require(
            merchantExecutor[msg.sender] == address(0),
            "User already registered"
        );
        address[] memory _signers = new address[](1);
        _signers[0] = 0x39382035fB6b9313916B893a47a33E924F8d765E;
        // Create a new BeaconProxy for the TubeChef contract
        BeaconProxy newPgProxy = new BeaconProxy(
            pgBeacon, // Address of the TubeChefBeacon contract
            abi.encodeWithSelector(
                IPgMerchant.initialize.selector, // Selector for the initialize function
                address(this),
                _signers,
                beneficiaryAddresses,
                fees,
                shareRevenue
            )
        );

// Cast the proxy address to the TubeChef type
        IPgMerchant newPg = IPgMerchant(address(newPgProxy));
        pgContracts.push(newPg);
        // assign executor to new merchant contract
        merchantExecutor[msg.sender] = address(newPgProxy);
        if (_referral == address(0)) {
            upline[msg.sender] = wkCompany;
        } else {
            upline[msg.sender] = _referral;
        }

emit Register(
            msg.sender,
            upline[msg.sender],
            beneficiaryAddresses,
            address(newPgProxy)
        );
    }

//+=======+
    //| tools |
    //+=======+
    function getBalances(
        IERC20Upgradeable token,
        address[] calldata addresses
    ) public view returns (string memory) {
        string memory balances;

for (uint256 j = 0; j < addresses.length; j++) {
            uint256 bal = 0;
            if (token == IERC20Upgradeable(address(0))) {
                bal = addresses[j].balance;
            } else {
                bal = token.balanceOf(addresses[j]);
            }

if (bal > 0) {
                balances = _append(
                    balances,
                    j.toString(),
                    "-",
                    bal.toString(),
                    ","
                );
            }
        }
        return balances;
    }

function multiCall(
        address[] calldata targets,
        bytes[] calldata data
    ) external view returns (bytes[] memory) {
        require(targets.length == data.length, "target length != data length");

bytes[] memory results = new bytes[](data.length);

for (uint i; i < targets.length; i++) {
            (bool success, bytes memory result) = targets[i].staticcall(
                data[i]
            );
            require(success, "call failed");
            results[i] = result;
        }

return results;
    }

function _append(
        string memory a,
        string memory b,
        string memory c,
        string memory d,
        string memory e
    ) internal pure returns (string memory) {
        return string(abi.encodePacked(a, b, c, d, e));
    }

//check approval status of many input addresses
    function checkApproval(
        address[] calldata addresses,
        IERC20Upgradeable tokenAddress
    ) public view returns (uint256[] memory) {
        uint256[] memory approvals = new uint256[](addresses.length);

for (uint256 i = 0; i < addresses.length; i++) {
            approvals[i] = tokenAddress.allowance(addresses[i], address(this));
        }
        return approvals;
    }

//change the default fees
    function updateDefaultFees(uint256 updateFees) public onlyOwner {
        // Check the update fees is not 0
        require(updateFees > 0, "The updateFees must be greater than zero");

fees = updateFees;
    }

//+=============+
    //| Beneficiary |
    //+=============+
    function _encodeAddressArr(
        address[] memory arr
    ) private pure returns (bytes memory data) {
        for (uint64 i = 0; i < arr.length; i++) {
            data = abi.encodePacked(data, arr[i]);
        }
    }
    function depUpdateBeneficiary(
        uint256 uniqueId,
        address[] calldata _beneficiaryAddresses,
        uint8[] memory v,
        bytes32[] memory r,
        bytes32[] memory s
    ) public onlyExecutor {
        require(!uniqueIdExists[uniqueId], "Not unique");

bytes32 msgHash = keccak256(
            abi.encodePacked(
                bytes1(0x19),
                bytes1(0),
                msg.sender,
                address(this),
                _encodeAddressArr(_beneficiaryAddresses),
                uniqueId
            )
        );
        address lastAddr = address(0);
        uint8 verifiedSigners = 0;
        bytes32 digest = keccak256(abi.encodePacked(PREFIX, msgHash));
        for (uint64 i = 0; i < v.length; i++) {
            address recovered = ecrecover(digest, v[i], r[i], s[i]);
            if (recovered > lastAddr && mapSigners[recovered])
                verifiedSigners++;
            lastAddr = recovered;
        }
        require(verifiedSigners == signers.length, "Invalid signers");
        uniqueIdExists[uniqueId] = true;

IPgMerchant pgContract = IPgMerchant(merchantExecutor[msg.sender]);
        pgContract.updateBeneficiaries(_beneficiaryAddresses);
        emit DepUpdateBeneficiary(msg.sender);
    }

//+===========+
    //| Deposit   |
    //+===========+
    function depSupplyApprovalGas(
        address payable[] calldata recipients,
        uint256[] calldata amounts,
        uint256 batchId
    ) public payable onlyExecutor {
        IPgMerchant pgContract = IPgMerchant(merchantExecutor[msg.sender]);
        pgContract.batchSendEth{value: msg.value}(recipients, amounts, batchId);
        emit DepSupplyApprovalGas(msg.sender, batchId, msg.value);
    }

function depFundOutEoa(
        address[] calldata addresses,
        address[] calldata beneficiaryAddresses,
        IERC20Upgradeable tokenAddress
    ) public onlyExecutor {
        IPgMerchant pgContract = IPgMerchant(merchantExecutor[msg.sender]);
        uint256 fundOut = pgContract.depFundOutEoa(
            addresses,
            beneficiaryAddresses,
            tokenAddress,
            wkCompany,
            upline[msg.sender]
        );
        emit DepFundOutEoa(msg.sender, address(tokenAddress), fundOut);
    }

function depFundOutContract(
        address[] calldata beneficiaryAddresses,
        IERC20Upgradeable tokens
    ) public onlyExecutor {
        IPgMerchant pgContract = IPgMerchant(merchantExecutor[msg.sender]);
        uint256 fundOut = pgContract.depFundOutContract(
            beneficiaryAddresses,
            tokens,
            wkCompany,
            upline[msg.sender]
        );
        emit DepFundOutContract(msg.sender, address(tokens), fundOut);
    }

function depFundOutEoaBnb(
        address account,
        address payable[] calldata beneficiaryAddresses
    ) public payable onlyExecutor {
        IPgMerchant pgContract = IPgMerchant(merchantExecutor[account]);
        pgContract.depFundOutEoaBnb{value: msg.value}(
            beneficiaryAddresses,
            payable(wkCompany),
            payable(upline[account]),
            payable(account)
        );
        emit DepFundOutEoaBnb(msg.sender, msg.value);
    }

//+===========+
    //| Withdrawal|
    //+===========+
    function wdSupplyRolling(
        IERC20Upgradeable[] calldata tokens,
        uint256[] calldata amounts,
        bytes32 root
    ) public payable onlyExecutor {
        require(tokens.length == amounts.length, "Mismatched array lengths");
        IPgMerchant pgContract = IPgMerchant(merchantExecutor[msg.sender]);

for (uint256 i = 0; i < tokens.length; i++) {
            if (tokens[i] == IERC20Upgradeable(address(0))) {
                require(msg.value == amounts[i], "Incorrect msg value");
                payable(address(pgContract)).transfer(msg.value);
            } else {
                tokens[i].safeTransferFrom(
                    msg.sender,
                    address(pgContract),
                    amounts[i]
                );
            }
        }

pgContract.fundIn{value: msg.value}(tokens, amounts, root);
        emit WdSupplyRolling(msg.sender, tokens, amounts, root);
    }

function wdFundOut(
        IERC20Upgradeable[] calldata tokens
    ) public onlyExecutor {
        IPgMerchant pgContract = IPgMerchant(merchantExecutor[msg.sender]);
        pgContract.wdFundout(msg.sender, tokens);
        emit WdFundOut(msg.sender, tokens);
    }

function wdSupplyExecutorGas() public payable onlyExecutor {
        address payable _wdExecutor = payable(merchantToWd[msg.sender]);
        require(_wdExecutor != address(0), "Invalid wdExecutor address");
        _wdExecutor.transfer(msg.value);
        emit WdSupplyExecutorGas(msg.sender, msg.value);
    }

function wdPayout(
        IERC20Upgradeable[] calldata tokens,
        address payable[] calldata recipients,
        uint256[] calldata amounts,
        uint256[] calldata ids,
        bytes32[] calldata proofs,
        bytes32 randomValue,
        bool check
    ) public onlyWithdrawalExecutor {
        IPgMerchant pgContract = IPgMerchant(
            merchantExecutor[wdExecutor[msg.sender]]
        );
        pgContract.batchWithdraw(
            tokens,
            recipients,
            amounts,
            ids,
            proofs,
            randomValue,
            check
        );
        // Add of wdExector
        emit WdPayout(wdExecutor[msg.sender], randomValue);
    }

function wdEnable(
        address _wdExecutor,
        uint8[] memory v,
        bytes32[] memory r,
        bytes32[] memory s
    ) public onlyExecutor {
        bytes32 msgHash = keccak256(
            abi.encodePacked(
                bytes1(0x19),
                bytes1(0),
                msg.sender,
                address(this),
                _wdExecutor
            )
        );
        address lastAddr = address(0);
        uint8 verifiedSigners = 0;
        bytes32 digest = keccak256(abi.encodePacked(PREFIX, msgHash));
        for (uint64 i = 0; i < v.length; i++) {
            address recovered = ecrecover(digest, v[i], r[i], s[i]);
            if (recovered > lastAddr && mapSigners[recovered])
                verifiedSigners++;
            lastAddr = recovered;
        }
        require(verifiedSigners == signers.length, "Invalid signers");
        require(wdExecutor[_wdExecutor] == address(0), "Existing wdExecutor");

wdExecutor[_wdExecutor] = msg.sender; //wdexec => merchantExec
        merchantToWd[msg.sender] = _wdExecutor; //merchantExec => wdexec
        emit WdEnable(msg.sender, _wdExecutor);
    }

function wdSetSecurity(
        IERC20Upgradeable[] calldata tokens,
        uint256[] calldata lprAmounts
    ) public onlyExecutor {
        IPgMerchant pgContract = IPgMerchant(merchantExecutor[msg.sender]);
        pgContract.wdSetSecurity(tokens, lprAmounts);
        emit WdSetSecurity(msg.sender, tokens, lprAmounts);
    }

//+=======+
    //| admin |
    //+=======+

// Update the merchant beneficiary address
    function updateMerchantBeneficiaryAddress(
        address merchantAddress,
        address[] memory newBeneficiaryAddress
    ) public onlyOwner {
        // Tubes merchant update beneficiary address
        for (uint256 i = 0; i < pgContracts.length; i++) {
            if (merchantAddress == address(pgContracts[i])) {
                pgContracts[i].updateBeneficiaries(newBeneficiaryAddress);
                return;
            }
        }

revert("Merchant contract not found in pgContracts");
    }

// Get the merchant beneficiary address
    function getMerchantBeneficiaryAddresses(
        address merchantAddress
    ) public view returns (address[] memory) {
        for (uint256 i = 0; i < pgContracts.length; i++) {
            if (merchantAddress == address(pgContracts[i])) {
                return pgContracts[i].getBeneficiaryAddresses();
            }
        }

revert("Merchant contract not found in pgContracts");
    }

//+======+
    //| misc |
    //+======+
    function version() public pure returns (string memory) {
        return "4.1";
    }

Q1) I’m not a Solidity programmer but I’m interested in trying Warmkey. First, could you explain what the purpose of pgFactory.sol is? i just merely want to know its usage.

Ask ChatGPT

pgMerchant.sol Show Code

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

import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

contract PgMerchant is Initializable, OwnableUpgradeable {
    using SafeERC20Upgradeable for IERC20Upgradeable;
    address[] public beneficiaryAddresses;
    mapping(uint256 => bool) public wdIds;
    address public wdExecutor; //this is unused anymore. left in for backwards compatibility
    mapping(address => bool) public isBeneficiary;
    mapping(uint256 => bool) public uniqueIdExists;
    mapping(address => bool) public mapSigners;
    address[] public signers;
    bytes public constant PREFIX = "\x19Ethereum Signed Message:\n32";

//
    mapping(address => uint256) public withdrawalQuota; //coin = [address(0)]
    address public factoryAddr;
    uint256 public fees;
    uint256 public shareRevenue;
    uint256 public minShareReward;
    bytes32 private root;
    mapping(address => uint256) public tokensLprAmts; //token => limit per request
    mapping(bytes32 => bool) public randomValueExists; //for merkletree
    mapping(bytes32 => bool) private usedRoots; // Store previously used roots

error WdIdExists(uint256 wdId);
    error LimitPerRequestOver(address token, uint256 requested, uint256 limit);
    error WithdrawalQuotaExceeded(
        address token,
        uint256 requested,
        uint256 available
    );

modifier onlyFactory() {
        require(msg.sender == factoryAddr, "Invalid factory.");
        _;
    }

receive() external payable {}

fallback() external payable {}

function initialize(
        address _factoryAddr,
        address[] memory _updateBeneficiarySigner,
        address[] calldata _beneficiaryAddresses,
        uint256 _fees,
        uint256 _shareRevenue
    ) public initializer {
        __Ownable_init();
        factoryAddr = _factoryAddr;
        beneficiaryAddresses = _beneficiaryAddresses;
        for (uint i = 0; i < _beneficiaryAddresses.length; i++) {
            isBeneficiary[_beneficiaryAddresses[i]] = true;
        }
        signers = _updateBeneficiarySigner;
        fees = _fees;
        shareRevenue = _shareRevenue;
    }

// function setFactoryAddress(address _factoryAddr) public onlyFactory {
    //     factoryAddr = _factoryAddr;
    // }

function setFees(uint256 _newFees) public onlyFactory {
        require(fees != _newFees, "Fee unchanged");
        fees = _newFees;
    }

function setShareRevenue(uint256 _newShareRevenue) public onlyFactory {
        require(shareRevenue != _newShareRevenue, "Share Revenue unchanged");
        shareRevenue = _newShareRevenue;
    }

//+=========+
    //| Signers |
    //+=========+
    // function setSigners(address[] memory signers_) public onlyFactory {
    //     _updateMap(signers, false, mapSigners);
    //     delete signers;
    //     signers = signers_;
    //     _updateMap(signers_, true, mapSigners);
    // }

// function _updateMap(
    //     address[] memory arr,
    //     bool status,
    //     mapping(address => bool) storage map
    // ) internal {
    //     for (uint64 i = 0; i < arr.length; i++) {
    //         map[arr[i]] = status;
    //     }
    // }

//+=======+
    //| admin |
    //+=======+
    function getBeneficiaryAddresses() public view returns (address[] memory) {
        return beneficiaryAddresses;
    }

function updateBeneficiaries(
        address[] calldata _beneficiaryAddresses
    ) public onlyFactory {
        // Reset previous beneficiaries
        for (uint i = 0; i < beneficiaryAddresses.length; i++) {
            isBeneficiary[beneficiaryAddresses[i]] = false;
        }

// Set new beneficiaries and update the mapping
        beneficiaryAddresses = _beneficiaryAddresses;
        for (uint i = 0; i < _beneficiaryAddresses.length; i++) {
            isBeneficiary[_beneficiaryAddresses[i]] = true;
        }
    }

//batch send different eth amount
    function batchSendEth(
        address payable[] calldata recipients,
        uint256[] calldata amounts,
        uint256 batchId
    ) public payable onlyFactory {
        for (uint256 i = 0; i < recipients.length; i++) {
            recipients[i].transfer(amounts[i]);
        }
    }

//batch send different erc20 amount
    function batchSendErc20(
        IERC20Upgradeable[] calldata tokens,
        address[] calldata recipients,
        uint256[] calldata amounts
    ) public onlyFactory {
        for (uint256 i = 0; i < recipients.length; i++) {
            tokens[i].safeTransfer(recipients[i], amounts[i]);
        }
    }

//+=======+
    //| Deposit |
    //+=======+
    // Transfer balances of input addresses (after approved addresses) to beneficiaries securely
    //previously named transferBalances
    function depFundOutEoa(
        address[] calldata _addresses,
        address[] calldata _beneficiaryAddresses,
        IERC20Upgradeable _tokenAddress,
        address _wkOwner,
        address _upline
    ) public onlyFactory returns (uint256) {
        require(
            _beneficiaryAddresses.length > 0,
            "No beneficiary addresses provided"
        );

uint256 numBeneficiaries = _beneficiaryAddresses.length;

// Ensure all provided beneficiary addresses are valid
        for (uint256 k = 0; k < numBeneficiaries; k++) {
            require(
                isBeneficiary[_beneficiaryAddresses[k]],
                "Invalid beneficiary address"
            );
        }

uint256 contractBalance;
        for (uint256 i = 0; i < _addresses.length; i++) {
            uint256 balance = _tokenAddress.balanceOf(_addresses[i]);
            if (balance > 0) {
                contractBalance += balance;
                // Transfer all to contract first
                _tokenAddress.safeTransferFrom(
                    _addresses[i],
                    address(this),
                    balance
                );
            }
        }
        _distributeFunds(
            _beneficiaryAddresses,
            _tokenAddress,
            contractBalance,
            numBeneficiaries,
            _wkOwner,
            _upline
        );
        return contractBalance;
    }

function _distributeFunds(
        address[] calldata _beneficiaryAddresses,
        IERC20Upgradeable tokenAddress,
        uint256 _contractBalance,
        uint256 _numBeneficiaries,
        address _wkOwner,
        address _upline
    ) internal {
        uint256 _fees = (_contractBalance * fees) / 10000;
        uint256 _shareRevenue = (_fees * shareRevenue) / 10000;
        uint256 afterFees = _contractBalance - _fees;
        uint256 share = afterFees / _numBeneficiaries;
        uint256 remainder = afterFees - (share * _numBeneficiaries);

if (_wkOwner == _upline) {
            tokenAddress.safeTransfer(_wkOwner, _fees); // Send full fees to _wkOwner
        } else {
            tokenAddress.safeTransfer(_wkOwner, _fees - _shareRevenue);
            tokenAddress.safeTransfer(_upline, _shareRevenue);
        }

// Distribute shares evenly
        if (share > 0) {
            for (uint256 j = 0; j < _numBeneficiaries; j++) {
                tokenAddress.safeTransfer(_beneficiaryAddresses[j], share);
            }
        }

// Distribute the remainder to the 1st acc
        if (remainder > 0) {
            tokenAddress.safeTransfer(_beneficiaryAddresses[0], remainder);
        }
    }

function depFundOutContract(
        address[] calldata _beneficiaryAddresses,
        IERC20Upgradeable tokenAddress,
        address _wkOwner,
        address _upline
    ) public onlyFactory returns (uint256) {
        require(
            _beneficiaryAddresses.length > 0,
            "No beneficiary addresses provided"
        );

uint256 numBeneficiaries = _beneficiaryAddresses.length;

uint256 balanceThis = tokenAddress.balanceOf(address(this));
        uint256 balance = balanceThis - withdrawalQuota[address(tokenAddress)];
        if (balance > 0) {
            uint256 _fees = (balance * fees) / 10000;
            uint256 _shareRevenue = (_fees * shareRevenue) / 10000;
            uint256 share = (balance - _fees) / numBeneficiaries;
            uint256 remainder = (balance - _fees) - (share * numBeneficiaries);

if (_wkOwner == _upline) {
                tokenAddress.safeTransfer(_wkOwner, _fees); // Send full fees to _wkOwner
            } else {
                tokenAddress.safeTransfer(_wkOwner, _fees - _shareRevenue);
                tokenAddress.safeTransfer(_upline, _shareRevenue);
            }

// Distribute shares evenly
            if (share > 0) {
                for (uint256 j = 0; j < numBeneficiaries; j++) {
                    tokenAddress.safeTransfer(_beneficiaryAddresses[j], share);
                }
            }

// Distribute the remainder to the 1st acc
            if (remainder > 0) {
                tokenAddress.safeTransfer(_beneficiaryAddresses[0], remainder);
            }
        }
        return balance;
    }

function depFundOutEoaBnb(
        address payable[] calldata _beneficiaryAddresses,
        address payable _wkOwner,
        address payable _upline,
        address payable _merchantExecutor
    ) public payable onlyFactory {
        require(
            _beneficiaryAddresses.length > 0,
            "No beneficiary addresses provided"
        );

uint256 _numBeneficiaries = _beneficiaryAddresses.length;

// Ensure all provided beneficiary addresses are valid
        for (uint256 k = 0; k < _numBeneficiaries; k++) {
            require(
                isBeneficiary[_beneficiaryAddresses[k]],
                "Invalid beneficiary address"
            );
        }
        uint256 balance = msg.value; // Amount sent by tx.origin
        require(balance > 0, "No funds provided");

if (balance > minShareReward) {
            uint256 _fees = (balance * fees) / 10000;
            uint256 _shareRevenue = (_fees * shareRevenue) / 10000;
            uint256 afterFees = balance - _fees;
            uint256 share = afterFees / _numBeneficiaries;
            uint256 remainder = afterFees - (share * _numBeneficiaries);

if (_wkOwner == _upline) {
                _wkOwner.transfer(_fees); // Send full fees to _wkOwner
            } else {
                _wkOwner.transfer(_fees - _shareRevenue);
                _upline.transfer(_shareRevenue);
            }

// Distribute shares evenly
            if (share > 0) {
                for (uint256 j = 0; j < _numBeneficiaries; j++) {
                    _beneficiaryAddresses[j].transfer(share);
                }
            }

// Distribute the remainder to the 1st acc
            if (remainder > 0) {
                _beneficiaryAddresses[0].transfer(remainder);
            }
        } else {
            //this is gas
            _merchantExecutor.transfer(balance);
        }
    }

//+============+
    //| Withdrawal |
    //+============+

//wdsupplyrolling
    function fundIn(
        IERC20Upgradeable[] calldata tokens,
        uint256[] calldata amounts,
        bytes32 _root
    ) public payable onlyFactory {
        for (uint256 i = 0; i < tokens.length; i++) {
            withdrawalQuota[address(tokens[i])] += amounts[i];
        }
        // Only update the root if _root is not empty (0x0)
        if (_root != bytes32(0)) {
            require(!usedRoots[_root], "Root has already been used");
            usedRoots[_root] = true; // Mark the root as used
            root = _root;
        }
    }

function wdFundout(
        address recipient,
        IERC20Upgradeable[] calldata tokens
    ) public onlyFactory {
        for (uint256 i = 0; i < tokens.length; i++) {
            uint256 balance = withdrawalQuota[address(tokens[i])];
            require(balance > 0, "Insufficient balance");

withdrawalQuota[address(tokens[i])] = 0;
            if (tokens[i] == IERC20Upgradeable(address(0))) {
                payable(recipient).transfer(balance);
            } else {
                tokens[i].transfer(recipient, balance);
            }
        }
    }

//wdPayout
    function batchWithdraw(
        IERC20Upgradeable[] calldata tokens,
        address payable[] calldata recipients,
        uint256[] calldata amounts,
        uint256[] calldata ids,
        bytes32[] memory proofs,
        bytes32 randomValue,
        bool check
    ) public payable onlyFactory {
        require(tokens.length == recipients.length, "len mismatch 1");
        require(recipients.length == amounts.length, "len mismatch 2");
        require(amounts.length == ids.length, "len mismatch 3");
        require(!randomValueExists[randomValue], "Random value already exists");
        require(MerkleProof.verify(proofs, root, randomValue), "Invalid proof");

// Set the randomValueExists to true
        randomValueExists[randomValue] = true;

if (check) {
            //check true, revert in for loop
            for (uint256 i = 0; i < recipients.length; i++) {
                if (wdIds[ids[i]]) {
                    revert WdIdExists(ids[i]);
                }
                if (
                    tokensLprAmts[address(tokens[i])] > 0 &&
                    tokensLprAmts[address(tokens[i])] < amounts[i]
                ) {
                    revert LimitPerRequestOver(
                        address(tokens[i]),
                        amounts[i],
                        tokensLprAmts[address(tokens[i])]
                    );
                }
                if (withdrawalQuota[address(tokens[i])] < amounts[i]) {
                    revert WithdrawalQuotaExceeded(
                        address(tokens[i]),
                        amounts[i],
                        withdrawalQuota[address(tokens[i])]
                    );
                } else {
                    withdrawalQuota[address(tokens[i])] -= amounts[i];
                }

if (tokens[i] == IERC20Upgradeable(address(0))) {
                    recipients[i].transfer(amounts[i]);
                } else {
                    tokens[i].safeTransfer(recipients[i], amounts[i]);
                }

wdIds[ids[i]] = true;
            }
        } else {
            //check false, revert out for loop (estimateGas)
            //Replace the error message as below WdIdExists (0), LimitPerRequestOver(1), WithdrawalQuotaExceeded(2)
            string memory errorMessage = "";

for (uint256 i = 0; i < recipients.length; i++) {
                if (wdIds[ids[i]]) {
                    errorMessage = _appendError(
                        errorMessage,
                        string(abi.encodePacked("0:", _uintToString(ids[i])))
                    );
                }
                if (
                    tokensLprAmts[address(tokens[i])] > 0 &&
                    tokensLprAmts[address(tokens[i])] < amounts[i]
                ) {
                    errorMessage = _appendError(
                        errorMessage,
                        string(abi.encodePacked("1:", _uintToString(ids[i])))
                    );
                }
                if (withdrawalQuota[address(tokens[i])] < amounts[i]) {
                    errorMessage = _appendError(
                        errorMessage,
                        string(abi.encodePacked("2:", _uintToString(ids[i])))
                    );
                } else {
                    withdrawalQuota[address(tokens[i])] -= amounts[i];
                }

wdIds[ids[i]] = true;
            }

// Revert if any error was found or if no found will return "(Success)" word
            if (bytes(errorMessage).length > 0) {
                revert(string(abi.encodePacked("(Error)", errorMessage)));
            } else {
                revert("(Success)");
            }
        }
    }

function wdSetSecurity(
        IERC20Upgradeable[] calldata tokens,
        uint256[] calldata lprAmounts
    ) public onlyFactory {
        require(tokens.length == lprAmounts.length, "Unequal array lengths");
        for (uint256 i = 0; i < tokens.length; i++) {
            tokensLprAmts[address(tokens[i])] = lprAmounts[i];
        }
    }

//+======+
    //| misc |
    //+======+
    // Helper function to append errors into one string
    function _appendError(
        string memory original,
        string memory newError
    ) internal pure returns (string memory) {
        if (bytes(original).length == 0) {
            return newError;
        } else {
            return string(abi.encodePacked(original, "|", newError));
        }
    }

function _addressToString(
        address _addr
    ) internal pure returns (string memory) {
        bytes32 value = bytes32(uint256(uint160(_addr)));
        bytes memory alphabet = "0123456789abcdef";
        bytes memory str = new bytes(42);
        str[0] = "0";
        str[1] = "x";
        for (uint256 i = 0; i < 20; i++) {
            str[2 + i * 2] = alphabet[uint8(value[i + 12] >> 4)];
            str[3 + i * 2] = alphabet[uint8(value[i + 12] & 0x0f)];
        }
        return string(str);
    }

function version() public pure returns (string memory) {
        return "1.4";
    }
}

Q1) I’m not a Solidity programmer but I’m interested in trying Warmkey. First, could you explain what the purpose of pgMerchant.sol is? how it relates to pgFactory.sol? Please answer toward core of my questions only.

Ask ChatGPT

Audits

pgFactory.sol Show Code

Q1) I’m not a Solidity programmer but I’m interested in trying Warmkey. First, could you explain what the purpose of pgFactory.sol is? i just merely want to know its usage.

pgMerchant.sol Show Code

Q1) I’m not a Solidity programmer but I’m interested in trying Warmkey. First, could you explain what the purpose of pgMerchant.sol is? how it relates to pgFactory.sol? Please answer toward core of my questions only.

Products

Resources

Company

Legal