🚀PVP Contract

Participants Contract Betting

Different from the regular PVP Space, which uses UFO tokens, the On-Chain PVP Space requires a game contract from $UFO.

All participating players must deposit a specified amount of $UFO. The contract will lock these tokens until the end of the competition.

• Game Result Determination: At the end, an external trusted source (such as the game server backend/Oracle) must submit the players' final scores to the contract. The contract determines the winner based on the scores and distributes the rewards accordingly.

• Permissions and Security:

  • The contract checks NFT ownership to ensure that NFT holders can create specific PVP spaces.

  • After the competition ends, the administrator (which can later be replaced by a DAO or Oracle) submits the results to ensure that the contract's internal logic remains closed and uncontrollable.

  • Utilize the OpenZeppelin security library to enhance security.

Players lock their tokens in the contract, and the winner of the prize pool is determined based on the competition results, implementing a centralized game logic on-chain.

Contract Design Process

• Contract Roles:

  • Owner/Manager: Contract manager (can be a multi-signature address from the project team or a DAO).

  • NFT Contract Address: Can verify ownership permissions through the IERC721 interface.

  • Host (NFT Holder): Player who opens the PVP room.

  • Participating Players: Players who inject $UFO to join the competition.

• Contract Data Structures:

Data Structures	Definition
MatchInfo	Stores information for each match
host	Address of the initiator
entryFee	Betting amount required to participate
startTime	Start times of the match
endTime	End times of the match
participants	List of participants
scores	Final scores of participants
finished	Whether the match has been settled
totalPool	Total prize pool amount
feeRate	Platform fee rate (e.g., 2%)

• Contract Workflow:

  1. Host Creates Room: NFT holders call createMatch to generate a new match ID, setting the betting amount, start/end times, fee rate mode, etc.

  2. Players Participate: Players call joinMatch(matchId) and pay the entryFee (via ERC20 approve + transferFrom). The contract records the player's address and accumulates the amount into the totalPool.

  3. Upload Scores (After Match Ends): After the match ends (endTime), a trusted backend service/administrator calls submitScores(matchId, players[], scores[]) to submit the final results on-chain.

     • Contract Verification:

       • Has the endTime been exceeded?

       • Only the designated administrator (backend oracle) can submit the results.

  4. Settlement and Prize Distribution: finalizeMatch(matchId) distributes the prize pool to the highest scorer.

     • Deduct platform fees

     • Transfer the remaining amount to the highest scorer

The code here only shows the architecture design, the actual code will be refined and optimized.

Code Example / Solidity

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

interface IERC20 {
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
}

interface IERC721 {
    function ownerOf(uint256 tokenId) external view returns (address);
}

contract PVPMatch {
    IERC20 public UFO;           // $UFO ERC20 Contract
    IERC721 public NFT;          // NFT Contract
    address public owner;        // Contract Manager (platform owner)
    uint256 public platformFeeRate; // Platform fee rate (e.g., 2% => 200 / 10000)
    
    uint256 public normalRoomFee = 100e18; // Normal player room fee (100 UFO)
    uint256 public matchCounter;

    struct MatchInfo {
        address host;
        uint256 nftId;           
        uint256 entryFee;        // Entry fee required to participate
        uint256 startTime;       
        uint256 endTime;         
        bool finished;
        address[] participants;
        uint256 totalPool;       // Total prize pool
        bool isNftHolderMatch;   // Whether the room was created by an NFT holder
        uint256 nftRewardRate;   // NFT room owner reward rate (based on NFT level, e.g., 200~400 =>2%-4%)
    }

    mapping(uint256 => mapping(address => uint256)) public scores;
    mapping(uint256 => MatchInfo) public matches;

    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

    constructor(IERC20 _UFO, IERC721 _NFT, uint256 _platformFeeRate) {
        UFO = _UFO;
        NFT = _NFT;
        owner = msg.sender;
        platformFeeRate = _platformFeeRate; // e.g., 2% => 200
    }

    // Helper function: Calculate reward rate based on NFT level
    // In practice, NFT contracts or other mappings provide level information, simplifying here.
    function getNftHolderRewardRate(uint256 nftId) internal view returns (uint256) {
        // Example: NFT ID segments determine level
        // 1~100: 2% => 200
        // 101~200: 3% => 300
        // 201+: 4% => 400
        if (nftId <= 100) {
            return 200; // 2%
        } else if (nftId <= 200) {
            return 300; // 3%
        } else {
            return 400; // 4%
        }
    }

    // Create room function: Normal players need to pay normalRoomFee, NFT holders are exempt
    // entryFee is the fee each participating player needs to pay
    function createMatch(
        uint256 nftId,        // If player has no NFT, pass 0 or invalid ID
        uint256 entryFee, 
        uint256 startTime, 
        uint256 endTime
    ) external returns (uint256) {
        require(endTime > startTime, "Invalid time");
        
        bool isNftHolder = false;
        uint256 nftRewardRate = 0;

        // Check if NFT holder
        if (nftId != 0) {
            address nftOwner = NFT.ownerOf(nftId);
            if (nftOwner == msg.sender) {
                isNftHolder = true;
                nftRewardRate = getNftHolderRewardRate(nftId);
            } else {
                // Passed nftId is not owned by msg.sender, treat as normal player
                nftId = 0; 
            }
        }

        matchCounter += 1;
        uint256 matchId = matchCounter;

        // If normal player creates room, pay normalRoomFee to contract as setup cost
        // This fee can be added to the prize pool or partially taken as platform fee
        // Simplified here: Add normalRoomFee directly to totalPool
        if (!isNftHolder) {
            require(UFO.transferFrom(msg.sender, address(this), normalRoomFee), "Room fee transfer failed");
        }

        MatchInfo storage m = matches[matchId];
        m.host = msg.sender;
        m.nftId = nftId;
        m.entryFee = entryFee;
        m.startTime = startTime;
        m.endTime = endTime;
        m.finished = false;
        m.isNftHolderMatch = isNftHolder;
        m.nftRewardRate = nftRewardRate;

        // If normal player creates room, already deposited normalRoomFee to contract
        if (!isNftHolder) {
            m.totalPool = normalRoomFee; 
        }

        return matchId;
    }

    // Player joins match
    function joinMatch(uint256 matchId) external {
        MatchInfo storage m = matches[matchId];
        require(block.timestamp >= m.startTime && block.timestamp < m.endTime, "Not in join time");
        require(!m.finished, "Match finished");

        require(UFO.transferFrom(msg.sender, address(this), m.entryFee), "Transfer failed");
        m.participants.push(msg.sender);
        m.totalPool += m.entryFee;
    }

    // Owner (platform) or specified oracle submits match results
    function submitScores(
        uint256 matchId, 
        address[] calldata players, 
        uint256[] calldata _scores
    ) external onlyOwner {
        MatchInfo storage m = matches[matchId];
        require(block.timestamp > m.endTime, "Match not ended");
        require(!m.finished, "Already finalized");
        require(players.length == _scores.length, "Invalid length");

        for (uint256 i = 0; i < players.length; i++) {
            scores[matchId][players[i]] = _scores[i];
        }
    }

    // Finalize match
    function finalizeMatch(uint256 matchId) external {
        MatchInfo storage m = matches[matchId];
        require(block.timestamp > m.endTime, "Match not ended");
        require(!m.finished, "Already finalized");

        address winner;
        uint256 highestScore = 0;

        for (uint256 i = 0; i < m.participants.length; i++) {
            address p = m.participants[i];
            uint256 s = scores[matchId][p];
            if (s > highestScore) {
                highestScore = s;
                winner = p;
            }
        }

        // If no participants or no score results
        if (winner == address(0)) {
            // Return all to host or platform, can be adjusted based on logic
            // Simplified: Directly transfer totalPool to host
            UFO.transfer(m.host, m.totalPool);
            m.finished = true;
            return;
        }

        uint256 totalPool = m.totalPool;

        // Platform fee
        uint256 platformFee = (totalPool * platformFeeRate) / 10000;

        uint256 nftHolderFee = 0;
        uint256 hostFee = 0;
        uint256 winnerAmount = 0;

        if (m.isNftHolderMatch) {
            // NFT holder creates room, platform takes platform fee first
            uint256 afterPlatform = totalPool - platformFee;

            // NFT room owner reward
            nftHolderFee = (afterPlatform * m.nftRewardRate) / 10000;
            uint256 afterNftHolder = afterPlatform - nftHolderFee;

            // Remaining goes to winner
            winnerAmount = afterNftHolder;
            hostFee = nftHolderFee; // NFT room owner receives this portion
        } else {
            // Normal player creates room, no NFT reward
            // After platform fee, remaining all goes to winner
            uint256 afterPlatform = totalPool - platformFee;
            winnerAmount = afterPlatform;
        }

        // Distribute rewards
        if (platformFee > 0) {
            UFO.transfer(owner, platformFee);
        }

        if (hostFee > 0) {
            UFO.transfer(m.host, hostFee);
        }

        UFO.transfer(winner, winnerAmount);
        m.finished = true;
    }

    function getParticipants(uint256 matchId) external view returns (address[] memory) {
        return matches[matchId].participants;
    }
}