File size: 7,299 Bytes
f998fcd
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.16;

import "./ChallengeDetail.sol";
import "./SafeMath.sol";
import "./ERC20.sol";

contract HistoryChallenges{
    using SafeMath for uint256;

    function challengesInfo1(address payable _contractChallengeAddress) public view returns(
        address sponsor,
        address challenger,
        uint256 challengeStart,
        uint256 challengeEnd,
        uint256 challengeDays,
        uint256 targetChallenge,
        uint256 minimumAchievementDays,
        uint256[] memory awardReceiversPercent
    ){
        sponsor = ChallengeDetail(_contractChallengeAddress).sponsor();
        challenger = ChallengeDetail(_contractChallengeAddress).challenger();
        challengeStart = ChallengeDetail(_contractChallengeAddress).startTime();
        challengeEnd = ChallengeDetail(_contractChallengeAddress).endTime();
        challengeDays = ChallengeDetail(_contractChallengeAddress).duration();
        targetChallenge = ChallengeDetail(_contractChallengeAddress).goal();
        minimumAchievementDays = ChallengeDetail(_contractChallengeAddress).dayRequired();
        awardReceiversPercent = ChallengeDetail(_contractChallengeAddress).getAwardReceiversPercent();
    }

    function challengesInfo2(address payable _contractChallengeAddress) public view returns(
        uint256 depopsitMatic, uint256[] memory amountDepositToken,
        uint256 indexNft, address contractChallengeAddress, 
        address contractNftAddress, uint256 chainId, uint256 challengeResult
    ){  
        bool isChallengeSuccess = ChallengeDetail(_contractChallengeAddress).isSuccess();
        if(isChallengeSuccess) {
            assembly {
                chainId := chainid()
            }
            
            address[] memory erc20ListAddress = ChallengeDetail(_contractChallengeAddress).allContractERC20();
            uint256[] memory depositToken = new uint256[](erc20ListAddress.length); 

            for(uint256 i = 0; i < erc20ListAddress.length; i++) {
                depositToken[i] = 0;
            }

            if(ChallengeDetail(_contractChallengeAddress).allowGiveUp(1)) {
                return(
                    ChallengeDetail(_contractChallengeAddress).totalReward(),
                    depositToken,
                    ChallengeDetail(_contractChallengeAddress).indexNft(),
                    _contractChallengeAddress,
                    ChallengeDetail(_contractChallengeAddress).erc721Address(0),
                    chainId,
                    1
                );
            } else {
                address createByToken = ChallengeDetail(_contractChallengeAddress).createByToken();
                for(uint256 i = 0; i < erc20ListAddress.length; i++) {
                    if(createByToken == erc20ListAddress[0]) {
                        depositToken[i] = ChallengeDetail(_contractChallengeAddress).totalReward();
                    } else {
                        depositToken[i] = 0;
                    }
                }
                return(
                    0,
                    depositToken,
                    ChallengeDetail(_contractChallengeAddress).indexNft(),
                    _contractChallengeAddress,
                    ChallengeDetail(_contractChallengeAddress).erc721Address(0),
                    chainId,
                    1
                );
            }
        } 
    }

    function getData(address payable _contractChallengeAddress) public view returns(bool) {
        return ChallengeDetail(_contractChallengeAddress).isFinished();
    }

    function getHistoryTokenAndCoinSendToContract(address payable _contractChallengeAddress) public view returns(
        uint256, 
        uint256, 
        uint256[] memory, 
        uint256[] memory,
        string[] memory
    ) {
        bool isCoinChallenges = ChallengeDetail(_contractChallengeAddress).allowGiveUp(1);
        uint256 totalReward = ChallengeDetail(_contractChallengeAddress).totalReward();
        address[] memory erc20ListAddress = ChallengeDetail(_contractChallengeAddress).allContractERC20();
        uint256[] memory tokenBalanceBefor = new uint256[](erc20ListAddress.length); 
        string[] memory listTokenSymbol = new string[](erc20ListAddress.length); 
        uint256[] memory tokenBalanceAfter = new uint256[](erc20ListAddress.length); 
        uint256 contractBalance = ChallengeDetail(_contractChallengeAddress).getContractBalance();
        if(isCoinChallenges) {
            for(uint256 i = 0; i < erc20ListAddress.length; i++) {
                tokenBalanceAfter[i] = ERC20(erc20ListAddress[i]).balanceOf(_contractChallengeAddress);
                listTokenSymbol[i] = ERC20(erc20ListAddress[i]).symbol();
            }
            
            uint256 balanceContract;

            if(contractBalance > totalReward) {
                balanceContract = contractBalance.sub(totalReward);
            }
            
            if(ChallengeDetail(_contractChallengeAddress).isFinished()) {
                uint256 balanceMatic = ChallengeDetail(_contractChallengeAddress).totalBalanceBaseToken();
                uint256[] memory balanceToken = ChallengeDetail(_contractChallengeAddress).getBalanceToken();
                return(totalReward, balanceMatic.sub(totalReward), tokenBalanceBefor, balanceToken, listTokenSymbol);
            } else {
                return(totalReward, balanceContract, tokenBalanceBefor, tokenBalanceAfter, listTokenSymbol);
            }
        } else {
            address payable challengeAddress = _contractChallengeAddress;
            uint256 indexCreateToken;
            for(uint256 i = 0; i < erc20ListAddress.length; i++) {
                listTokenSymbol[i] = ERC20(erc20ListAddress[i]).symbol();
                uint256 balance = ERC20(erc20ListAddress[i]).balanceOf(challengeAddress);
                address createByToken = ChallengeDetail(challengeAddress).createByToken();
                if(createByToken == erc20ListAddress[i]) {
                    tokenBalanceBefor[i] = totalReward;
                    indexCreateToken = i;
                    if(balance >= totalReward) {
                        tokenBalanceAfter[i] = balance.sub(totalReward);
                    }
                } else {
                    tokenBalanceAfter[i] = balance;
                }
            }

            if(ChallengeDetail(challengeAddress).isFinished()) {
                uint256 balanceMatic = ChallengeDetail(_contractChallengeAddress).totalBalanceBaseToken();
                uint256[] memory balanceToken = ChallengeDetail(challengeAddress).getBalanceToken();
                balanceToken[indexCreateToken] = balanceToken[indexCreateToken].sub(totalReward);
                return(0, balanceMatic, tokenBalanceBefor, balanceToken, listTokenSymbol);
            } else {
                return(0, contractBalance, tokenBalanceBefor, tokenBalanceAfter, listTokenSymbol);
            }
        }
    }


    function compareStrings(string memory a, string memory b) internal pure returns (bool) {
        return (keccak256(abi.encodePacked((a))) == keccak256(abi.encodePacked((b))));
    }
}