Cryo Explorer Ethereum Mainnet

/// SPDX-License-Identifier: MIT

pragma solidity 0.8.26;

import "./openzeppelin/security/ReentrancyGuard.sol";
import "./interfaces/ERC20Interface.sol";

/* import "./openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; 
    ⫸ This function is not used because it exceeds 24,576 bytes.
*/


/**



        ██   ██  ██████  ██      ██████  ██████  ██       █████  ████████ ███████  ██████  ██████  ███    ███             ██    ██ ██████  
        ██   ██ ██    ██ ██      ██   ██ ██   ██ ██      ██   ██    ██    ██      ██    ██ ██   ██ ████  ████             ██    ██      ██ 
        ███████ ██    ██ ██      ██   ██ ██████  ██      ███████    ██    █████   ██    ██ ██████  ██ ████ ██             ██    ██  █████  
        ██   ██ ██    ██ ██      ██   ██ ██      ██      ██   ██    ██    ██      ██    ██ ██   ██ ██  ██  ██              ██  ██  ██      
        ██   ██  ██████  ███████ ██████  ██      ███████ ██   ██    ██    ██       ██████  ██   ██ ██      ██               ████   ███████ 


        ⫸⫸⫸ https://holdplatform.com                                                                                                                                                                                                                                                                          
**/



    // -----------------------------------------
    // ✦✦✦ Mainnet - Holdplatform V2 
    // -----------------------------------------
    // Dec-29-2024 11:08:59 AM +UTC


    // -----------------------------------------
    // ✦ Disclaimer
    // -----------------------------------------
    
    /*

    By accessing this website address you are deemed to have read, 
    understood and agreed to all terms and conditions that have been written on 
    the Holdplatform.com website. For information, Holdplatform.com is not an 
    investment business, but a decentralized application, which is more likely 
    to be regarded as speculation. You must know, that every investment or 
    speculation always has two inseparable sides, namely potential and risk. 
    So, learn and understand all the potentials and risks, because brilliant 
    results in the past or at present are not a sure guarantee that in the 
    future they will still produce the same thing. Of course, the results can 
    be more or less. Depending on various factors that influence it. 
    Holdplatform.com never guarantees the accuracy of the results you will 
    get in the future. Nothing is certain in this world. The only certainty 
    is that we have tried to provide the best through the decentralized 
    application we made with the Ethereum network. Holdplatform.com never 
    forces you to join or do a Hold token on our platform, because all the 
    processes have been carried out on your own with full awareness. You can 
    only hold a token after agreeing to all the disclaimers written on this 
    website. Holdplatform.com is not responsible for any losses and damage 
    that occur in the future caused by disruptions, inaccuracies, errors, or 
    negligence caused by various factors such as: hacking, changes in market 
    conditions, economic conditions or changes in the laws in a country, and 
    unexpected things that can directly or indirectly affect the existence of 
    Holdplatform.com. If you are a beginner, we strongly recommend consulting 
    in advance with financial experts or people who are more experienced in 
    the field of blockchain. So, before you participate in Holdplatform.com, 
    We remind you that: Never spend money you cannot afford to lose, be wise 
    in making an investment or speculation. Once again, Holdplatform.com never 
    gives a guarantee that you will become a super-rich tomorrow. Because each 
    person has a different business, effort, and persistence. so, NO WARRANTY 
    everyone will get the same thing. The results could be more, could be less, 
    could have been profitable, could have been a loss. We have as much as 
    possible provided the best platform to help your welfare. 
    
    So, everything really depends on your action!
    */


    // -----------------------------------------
    // ✦ Why should you join HoldPlatform V2 ?
    // -----------------------------------------


    /** 
    
        1.Thousands of Web2 businesses have weaknesses due to their centralized nature, 
        where the owner can suddenly change the rules of the system, which of course, harms the users.

        2.The majority of businesses only last 1-2 years, so why should we work hard or even smart to develop them?

        3.Inflation is very real, reaching up to 12% in a year. This quickly erodes a person's wealth in an almost invisible way.
        
        4. Starting any business, whether offline or online, makes it very difficult to break even. Even if it's possible, 
        it takes a very long time. On Holdplatform.com, your capital will return 88% within just 1 year with a 6% monthly unlock rate.

        5. Holdplatform is the best place for you to practice DCA (Dollar Cost Averaging) in Bitcoin. 
        In addition to increasing your Bitcoin holdings, you can also run its affiliate business.

        6. The founder has the best experience in affiliate marketing across various businesses since 2009 and 
        wants to help you succeed in affiliate marketing because becoming an affiliate is the best way to make money.

        7. The bank uses a Fractional Reserve Banking system with a 1:10 ratio, 
        meaning that for every $10,000 of your money, up to $9,000 has been used for loans and other purposes. 
        The Holdplatform is open-source, and 88% of your token is safe. The deployer cannot touch or use your token.

        ✦✦✦✦✦✦✦

        There are only two choices right now: either the value of your fiat wealth decreases by 12% due to inflation, 
        or your WBTC decreases by 12% on Holdplatform. However, with the potential for unlimited affiliate bonuses 
        and, of course, the likely increase in BTC prices, which will surely be more than 12% in the coming time, 
        
        ✦ Holdplatform offers a better opportunity.
    */


    // -----------------------------------------
    // ✦ I'd rather keep my WBTC myself.
    // -----------------------------------------

    /** 
        1. If you have less than 0.1 BTC, it is highly discouraged to keep it yourself. It won't make you rich.
        2. If people can keep their money themselves, why do so many store it in banks?
        3. If everyone can cook, why do so many people go to restaurants where it's 50% more expensive than cooking at home?
        4. If water at home is cheap, or even free, why do so many people buy bottled water at the convenience store?

        ✦✦✦✦

        Because for some people, keeping money in a bank, eating at a restaurant, and drinking bottled water are better options. 
        Similarly, Holdplatform is the best way to protect against inflation and start an affiliate business with minimal risk, 
        as Holdplatform uses WEB3, which is, of course, more transparent and much safer than WEB2 businesses.

    */



    // -----------------------------------------
    // ✦ How the system works
    // -----------------------------------------

    /** 

        -----------------------
        ••• Deployment phase
        -----------------------
        1. The deployer performs the deployment on Remix on the chain being used
        2. The constructor will automatically create the data for the first time for the msg.sender as the deployer. 
        3. The data includes : _idnumber, _holdstatus_bycashbackcode, _searchaddress_bycashbackcode, readdata 
        4. In addition, it also stores deployer data, which consists of mapping(address => User) private _user
        5. Contains permanent data : u.useraddress, u.cashbackcode, u.affiliateid, u.status, u.unixregister, u.firsttimebuybitcoin 
        
        -----------------------
        ••• Launch phase
        -----------------------
        1. The deployer must press the write button for the (Start) function, which will automatically change 0 to the block.timestamp data, and the Dapps can be used.
        2. Once the launch unixtime is successfully updated, it cannot be undone, paused, or even stopped. The smart contract will run forever

        -----------------------
        ••• Add Contract
        -----------------------
        1. Unlike Uniswap, where all users can input the contract address being used, on the Holdplatform, only the deployer can add a new contract address.
        2. The deployer add at least one contract address that can be used permanently. This cannot be paused or stopped.
        3. As an example, the deployer will add the WBTC (Wrapped Bitcoin) token with three important parameters.
        4. The parameters are the contract address, maximum contribution, and the percentage of unlocked tokens per month.
        5. Although the percentage is calculated monthly, in reality, the system calculates it per second
        6. And it can be withdrawn at any time with a maximum accumulation of 10% (if the contract duration has not yet ended).
        7. If the contract duration has ended, then when the user presses the withdraw button, all tokens will be unlocked and sent.
        8. The data that can be updated for the next hold are the percentage of tokens unlocked per month and the maximum contribution amount.
        9. Updates do not apply retroactively and will not change the conditions for existing users who have already held tokens.
        10. The unlock percentage can be changed to a range of 3-12% per month. 
        11. For the maximum contribution, it must be greater than the previous maximum contribution amount.
        12. Creating or updating the maximum contribution must include the token amount in decimals. For example, 100 tokens with 8 decimals should be written as 10000000000

        -----------------------
        ••• Holdplatform
        -----------------------
        1. To participate in holdplatform.com, users must Sign the Disclaimer, and this agreement is recorded on the blockchain.
        2. To participate in locking tokens on the Holdplatform, users can use a cashback code from an inviter or choose not to use a cashback code at all.
        3. Users who use a cashback code will receive a 16% cashback from the total tokens locked, both for the first token lock and subsequent token locks.
        4. Users who do not use a cashback code will not receive a 16% cashback from the total tokens locked for the first token lock. 
        5. However, for the second and subsequent token locks, they will still receive the cashback. The 16% cashback can be withdrawn immediately, even after just 1 second.
        6. Token distribution system: 2% for the deployer, 10% for affiliates, 16% for user cashback, and 72% will be locked for several months based on the specified percentage.
        7. Users who do not use a cashback code will have the 16% tokens marked as not eligible, and they will be added to the deployer's balance.
        -----------------------
        ••• Example
        -----------------------
        For example, the system currently has the WBTC (Wrapped Bitcoin) contract address registered with a 
        Max Contribution of 0.1 BTC, or with decimals as 10,000,000, and an unlock percentage of 6% per month.

        Someone is holding tokens and has already saved a cashback code. 
        This user locked 0.1 BTC at the unixtime 1723691458 (Thu Aug 15 2024 03:10:58 GMT) Then the result is :

        - One second after making the deposit, 
        the user can withdraw the 16% x 0.1 WBTC cashback at unixtime 1723691459 (Thu Aug 15 2024 03:10:59 GMT) --- > 0.016 WBTC
        - One second after making the deposit, 
        the affiliate can withdraw the 10% x 0.1 WBTC cashback at unixtime 1723691459 (Thu Aug 15 2024 03:10:59 GMT) --- > 0.01 WBTC
        - One second after making the deposit, 
        the deployer can withdraw the 2% x 0.1 WBTC cashback at unixtime 1723691459 (Thu Aug 15 2024 03:10:59 GMT) --- > 0.002 WBTC

        72% of the tokens (0.072 WBTC) will be locked for 12 months (31,104,000 seconds), 
        and the tokens will unlock every second at a rate of 6% per month, 0.2% per day, or 0.00833% per hour.

        The user can leave the tokens locked. If at any time the user wishes to withdraw, 
        they can accumulate up to a maximum of 10% if the contract duration has not yet ended.

        If the contract duration has ended at the unixtime 1754795458 (Sun Aug 10 2025 03:10:58 GMT), the user can withdraw everything. 

        -----------------------------------
        ••• Holdplatform Affiliate System 
        -----------------------------------
        By making a token deposit on the Holdplatform at least once, with any amount, your cashback code becomes active and can be used for promotion

        Make sure you have made a deposit with the maximum amount specified by the max contribution. 
        This way, if any of your referrals make a deposit, you can receive the full 10% bonus.

        ✦ Holdplatform uses ACS (Anti Cheat System).
        It is not possible for account-1 to make a small deposit and then account-2 to make a large deposit, 
        as the referral bonus calculation is based on 10% x Bonus Parameter.

        ✦ What is Bonus Parameter ?
        The bonus parameter is the reference used to measure the affiliate bonus you can receive, up to 10%. 
        The bonus parameter is calculated based on the amount of your token deposit that has not yet been withdrawn. 
        You are free to withdraw the tokens you hold, but keep in mind that every time you withdraw the tokens you hold, 
        your bonus parameter decreases. The bonus parameter can increase again up to the max contribution if you deposit again up to the maximum.

        ⫸⫸⫸ Withdrawing tokens reduces the bonus parameter.
        ⫸⫸⫸ Withdrawing the affiliate bonus does not reduce the bonus parameter. 

        Here is the detailed bonus calculation :

        ✦ Bonus Type 1
        ⁎ Example : Your Deposit 0.05 BTC == > Your Bonus Paramater 0.05 BTC --- Referral OLD Contribution = 0 BTC, Referral NEW Contribution 0.05 BTC
        -- if ( Referral_OldContribution == 0 && Your_BonusParameter >= Referral_NewContribution )
        -- Affiliate Bonus  = 10% x Referral_NewContribution
        -- Not Eligible     = 0%

        ✦ Bonus Type 2
        ⁎ Example : Your Deposit 0.05 BTC == > Your Bonus Paramater 0.05 BTC --- Referral OLD Contribution = 0 BTC, Referral NEW Contribution 0.09 BTC
        -- if ( Referral_OldContribution == 0 && Your_BonusParameter < Referral_NewContribution )
        -- Affiliate Bonus  = 10% x Your_BonusParameter
        -- Not Eligible     = 10% x ( Referral_NewContribution - Your_BonusParameter )

        ✦ Bonus Type 3
        ⁎ Example : Your Deposit 0.05 BTC == > Your Bonus Paramater 0.05 BTC --- Referral OLD Contribution = 0.06 BTC, Referral NEW Contribution 0.04 BTC
        -- if ( Referral_OldContribution > Your_BonusParameter  )
        -- Affiliate Bonus  = 0%
        -- Not Eligible     = 10% x Referral_NewContribution

        ✦ Bonus Type 4
         ⁎ Example :  Your Deposit 0.05 BTC == > Your Bonus Paramater 0.05 BTC ---  Referral OLD Contribution = 0.02 BTC,  Referral NEW Contribution 0.02 BTC
        -- if ( Referral_OldContribution > 0 &&  AllContribution <= Your_BonusParameter)
        -- Affiliate Bonus  = 10% x Referral_NewContribution
        -- Not Eligible     = 0%

        ✦ Bonus Type 5
        ⁎ Example : Your Deposit 0.05 BTC == > Your Bonus Paramater 0.05 BTC --- Referral OLD Contribution = 0.02 BTC, Referral NEW Contribution 0.08 BTC
        -- if ( Referral_OldContribution > 0 &&  AllContribution > Your_BonusParameter )
        -- Affiliate Bonus  = 10% x ( Your_BonusParameter - Referral_OldContribution )
        -- Not Eligible     = 10% x ( AllContribution - Your_BonusParameter )

        -----------------------
        ••• Withdraw
        -----------------------
        1. Anyone who has stored tokens can perform a partial withdrawal or withdraw everything when the contract ends.
        2. A referrer can withdraw the affiliate bonus they have received from the combined total of all bonuses they have received, at any time!
        3. The deployer can withdraw the 2% Holdplatform fee and the percentage that is not eligible at any time.

        -----------------------
        ••• Best Practice
        -----------------------

        - Deposit as much as you can up to the maximum contribution. To ensure that your bonus parameters do not decrease, 
        do not withdraw tokens from your deposit. Instead, withdraw from the affiliate bonus earned from your efforts in promoting the Holdplatform.

        -----------------------
        ••• Read Data (Public)
        -----------------------
        1. function GetAffiliate(address address_) public 
        2. function GetAvailabletowithdraw(uint256 hold_id) public 
        3. function GetBonusHistory_byAddress(address address_) public
        4. function GetContractAddress(address address_) public
        5. function GetContractDetail() public 
        6. function GetContractList() public
        7. function GetData_byAddress(address address_) public 
        8. function GetData_byId(uint256 id_) public
        9. function GetStat(address tokenaddress, address useraddress) public 
        10. function GetUserDetail(address address_) public
        11. function GetWithdrawHistory_byAddress(address address_) public

        -----------------------
        ••• Write Data (Public)
        -----------------------
        1. Est. Gas ± 75,302     - function SignDisclaimer() public nonReentrant
        2. Est. Gas ± 166,622    - function CashbackCode(string memory _cashbackcode, uint256 firsttime_buybitcoin) public nonReentrant
        3. Est. Gas ± 2,669,310  - function Holdplatform(address TokenAddress, uint256 amount, uint256 TokenPrice ) public nonReentrant
        4. Est. Gas ± 847,346    - function Withdraw(address TokenAddress, uint256 hold_id, uint256 TokenPrice) public nonReentrant
        5. Est. Gas ± 645,441    - function Affiliate(address TokenAddress, uint256 TokenPrice) public nonReentrant
        5. Est. Gas ± 41,384     - function TryTestnet() public nonReentrant

        -----------------------
        ••• Write Data (Deployer)
        -----------------------
        1. Est. Gas ± 47,888     - function Start() public nonReentrant restricted
        2. Est. Gas ± 239,985    - function Save(address TokenAddress, uint256 _maxcontribution, uint256 _PercentPermonth) public nonReentrant restricted 
        3. Est. Gas ± 26,988     - function LoadData() public nonReentrant  restricted 
        4. Est. Gas ± 48,106     - function GasOptimization() public nonReentrant restricted 

        -----------------------
        ••• Gas Optimization
        -----------------------
        - Holdplatform Gas ± 995,300 ( Reducing gas fees by up to 62% )
        - Withdraw Gas ± 320,218 ( Reducing gas fees by up to 62% )
        - Affiliate Gas ± 109,616 ( Reducing gas fees by up to 84% )

    */




contract HoldplatformV2 is ReentrancyGuard {

    /* using SafeERC20 for IERC20; 
       ⫸ This function is not used because it exceeds 24,576 bytes.
    */

    // ------------------------------------
    // ✦ Constructor
    // ------------------------------------

    	constructor() {     	

        _deployer                                           = msg.sender;                   
        User storage u                                      = _user[_deployer];
    //------------------------------------------------------------------------------------
		_id						                            = 1;                            /// ID number 1 is the deployer's ID.                           
        _holdstatus_bycashbackcode["0x000000000000000"]     = true;                         /// The deployer's cashback code has been held.
        _readdata                                           = true;                         /// The deployer can read their own account data.                             
        _idnumber[1]                                        = _deployer;                    /// ID number 1 is the deployer's ID.                                                        
        _searchaddress_bycashbackcode["0x000000000000000"]  = _deployer;                    /// The cashback code 0x000000000000000 belongs to the deployer
        u.useraddress                                       = _deployer;			        /// Deployer 0x Address
        u.cashbackcode                                      = "0x000000000000000";          /// Default Cashbackcode for deployer
        u.affiliateid                                       = "0x000000000000000";          /// The deployer affiliates with themselves.
        u.status                                            = true;                         /// Is the deployer automatically a user? TRUE.
        u.unixregister                                      = block.timestamp;              /// Unix time of the deployer's account registration / Unix time of deployment.
        u.firsttimebuybitcoin                               = 2015;                         /// The first time the deployer bought Bitcoin.

        _afflist[_deployer].push(msg.sender);
    }

    // ------------------------------------
    // ✦ Modifier ( Restricted )
    // ------------------------------------

    modifier restricted() {
        require(msg.sender == _deployer);                   /// The restricted feature can only be WRITTEN by the deployer.
        _;
    } 

    // ------------------------------------
    // ✦ Holdplatform Web3 Database
    // ------------------------------------

    address         private _deployer;                      // [00] 0x address belonging to the deployer
    uint256         private _id;                            // [01] The number of 0x addresses that have participated
    uint256         private _count;                         // [02] The total hold from all addresses of all participants
    uint256         private _tx_bonushistory;               // [03] Serial number for bonus history
    uint256         private _tx_withdrawhistory;            // [04] Serial number for withdraw history
    uint256         private _launch;                        // [05] The Unix time of this system was started by the deployer
    uint256         private constant _twenty = 1e20;        // [06] (10 ** 20);  
    bool            private _readdata;                      // [07] FALSE/TRUE status indicating whether the deployer can read their own account data.
    bool            private _gas_optimization;              // [08] FALSE/TRUE status indicating whether gas optimization is enabled in the system.
    bool            private _testnet_close;                 // [09] FALSE/TRUE status indicating that the testnet system has been closed (30 days).
    address[]                                                       private _contractlist;		            // [10] Contains contract addresses that have been added by the deployer.
    mapping(address user            => uint256[] HoldId ) 	        private _idaddress;		                // [11]	Hold ID number of each address (all data).
    mapping(address user            => uint256[] Bonushistory ) 	private _id_bonushistory;		        // [12] Bonushistiry ID number of each address (all data).
    mapping(address user            => uint256[] Withdrawhistory )  private _id_withdrawhistory;            // [13]	Withdrawhistory ID number of each address (all data).
	mapping(address user            => address[] team) 	            private _afflist;		                // [14] All 0x referral addresses registered with the cashback code.
    mapping(uint256 serial          => address user ) 	            private _idnumber;	                    // [15] The serial number of the 0x address when registering in the system.
    mapping(string cashbackCode     => bool isHold) 		        private _holdstatus_bycashbackcode;     // [16] Status FALSE/TRUE indicating whether a cashback code has been held.
    mapping(string cashbackCode     => address user )               private _searchaddress_bycashbackcode;  // [17] Searching for a 0x address based on the cashback code.
    mapping(address user            => uint256[] unixtime) 	        private  _disclaimer;		            // [18]	User must sign the disclaimer, and it must be recorded.

    mapping(uint256 holdId          => Safe) 	                                    private _safes; 		                // [S] User data	
    mapping(address tokenDetail     => Tokenlist) 	                                private _tokenlist; 	                // [T] Token data
    mapping(address userDetail      => User) 	                                    private _user; 	                        // [U] User data
    mapping(uint256 bonusId         => Bonushistory)                                private _bonushistory; 	                // [V] Bonushistory data
    mapping(address tokenaddress    => mapping (address useraddress => Stat))       private _stat;                          // [W] Stat data
    mapping(uint256 withdrawId      => Withdrawhistory)                             private _withdrawhistory; 	            // [X] Transaction data


        struct Safe {
            uint256 id;						        /// S00 -- > Hold ID
            uint256 blocknumber;                    /// S01 -- > The block number at the time the transaction was made.
            string  tokensymbol;			        /// S02 -- > A symbol that represents the ticker of a token.
            uint256 tokendecimal; 			        /// S03 -- > The number of decimals for the token, usually 8 (00000000) or 18 (000000000000000000).
            uint256 starttime;				        /// S04 -- > Start time ( Based On Unix Time ).
            uint256 endtime;				        /// S05 -- > The Expiration Of A Hold Platform Based On Unix Time.
            uint256 holdingtime_inseconds;          /// S06 -- > Duration of holding on the platform in seconds.
            uint256 percentage; 			        /// S07 -- > The percentage of tokens that are unlocked every month ( Default 3% )
            uint256 amount;					        /// S08 -- > The total amount of tokens deposited for holding.
            uint256 usdvalue_deposit;               /// S09 -- > The number of tokens multiplied by the token price at the time of deposit.
            uint256 amountbalance; 			        /// S10 -- > 88% from Contribution / 72% Without Cashback.
            uint256 cashbackbalance; 		        /// S11 -- > 16% from Contribution / 0% Without Cashback.
            bool 	cashbackstatus; 		        /// S12 -- > Cashback Status
            uint256 tokenprice_start;               /// S13 -- > The token price at the time of holding.
            uint256 usdvalue_withdraw;              /// S14 -- > Total accumulated withdrawals in USD.
            address user;					        /// S15 -- > The ETH address you are using.
            address tokenaddress;			        /// S16 -- > The Token Contract Address That You Are Using.
            uint256 percentagereceive; 		        /// S17 -- > The Percentage You Have Received.
            uint256 tokenreceive; 			        /// S18 -- > The Number Of Tokens You Have Received.
            string  affiliateid;                    /// S19 -- > It is 0x + a 15-digit random affiliate ID generated by the smart contract.
            string  cashbackcode; 			        /// S20 -- > This is the cashback code you used when registering (your sponsor).
            uint256 bonusparameter;                 /// S21 -- > It is the parameter used to determine the affiliate bonus based on the sponsor's deposit.
            uint256 oldcontribution;                /// S22 -- > The total amount of all previous user deposits.
            uint256 newcontribution;                /// S23 -- > The latest deposit amount from the user.
            uint256 allcontribution;                /// S24 -- > Adding up all the old and new total deposits.
            uint256 bonustype;                      /// S25 -- > It will be determined automatically, with the bonus type set based on the bonus parameters.
            uint256 affiliatebonus;                 /// S26 -- > The amount of bonus received by the affiliate.
            uint256 not_eligible;                   /// S27 -- > The amount of bonus that is not eligible because the sponsor did not meet the maximum contribution limit.
            uint256 percentage_affiliate;           /// S28 -- > The percentage earned by the affiliate.
            uint256 percentage_not_eligible;        /// S29 -- > The percentage that is not eligible because the sponsor did not meet the criteria.        
            uint256 fee;                            /// S30 -- > A 2% fee is given to the deployer who created the hold platform.
            uint256 lasttime; 				        /// S31 -- > The last time you made a withdrawal, the data displayed is in UNIX format.
            uint256 lastwithdraw; 			        /// S32 -- > The amount of the last withdrawal you made.
            uint256 tokenprice_end;                 /// S33 -- > The token price when the contract ended and the last withdrawal was made.
            uint256 tx_withdraw;                    /// S34 -- > The number of withdrawal transactions for that hold ID.
            uint256 payment_queue;                  /// S35 -- > The amount of payment ready to be transferred upon withdrawal.
            uint256 timeframe;                      /// S36 -- > The time difference between the last withdrawal and now (in seconds).
            uint256 unix_signdisclaimer;            /// S37 -- > The terms and conditions, including a disclaimer, were agreed upon before holding the token
        }

        struct Tokenlist  {
            address contractaddress;                /// T00 -- > The contract address that can be used in the holdplatform system.
            bool    contractstatus;                 /// T01 -- > The status of whether a contract address can be used.
            string  tokensymbol;                    /// T02 -- > A symbol that represents the ticker of a token.
            uint256 percentpermonth;                /// T03 -- > The percentage of tokens that are unlocked every month ( Default 3% )
            uint256 holdingtime_inseconds;          /// T04 -- > Duration of holding on the platform in seconds.
            uint256 tokendecimal;                   /// T05 -- > The number of decimals for the token, usually 8 (00000000) or 18 (000000000000000000).
            uint256 tokenprice;                     /// T06 -- > The token price for the latest update based on the function called.
            uint256 min_contribution;               /// T07 -- > The minimum amount required for a deposit in the system.
            uint256 max_contribution;               /// T08 -- > The maximum deposit amount (accumulated from all active deposits).
            uint256 totalcontribution;              /// T09 -- > The total amount of all user deposits for the selected token address.
            uint256 totalpayments;                  /// T10 -- > The total amount of withdrawals made by all users for the selected token address.
            uint256 totalaffiliatepayments;         /// T11 -- > The total amount of withdrawals that have been paid to affiliates.
            uint256 activeuser;                     /// T12 -- > The number of active users with at least one active position.
            uint256 totaluser;                      /// T13 -- > The number of users on the selected token address.
            uint256 totaltx_lock;                   /// T14 -- > The number of token lock transactions in the dApp.
            uint256 totaltx_unlock;                 /// T15 -- > The number of token unlock transactions in the dApp.
            uint256 totaltx_affiliate;              /// T16 -- > The number of token lock transactions in the dApp.
            uint256 unix_contractadded;             /// T17 -- > The number of affiliate (withdrawal) transactions that have been made.
            uint256 totalusdvalue;                  /// T18 -- > The estimated amount of tokens stored in USD.
            uint256 tokenbalance;                   /// T19 -- > The number of tokens recorded according to the system's mechanism.
            uint256 tokenbalance_sync;              /// T20 -- > The number of tokens based on retrieved data from the balanceOf smart contract.   
            uint256 unix_tokenprice;                /// T21 -- > The last price update time (in UNIX time).
         
        }

        struct User {
            address useraddress;		            /// U00 -- > Searching for data based on the selected address.	
            string  cashbackcode;	                /// U01 -- > This is the cashback code you used when registering (your sponsor).		
            string  affiliateid;                    /// U02 -- > It is 0x + a 15-digit random affiliate ID generated by the smart contract.	
            bool    status;                         /// U03 -- > Status (true) if the user has held at least once.	
            uint256 unixregister;                   /// U04 -- > User registration date / cashback code submission (based on UNIX time).	
            uint256 firsttimebuybitcoin;            /// U05 -- > When did the user first purchase Bitcoin?	
            uint256 totaltransaction;               /// U06 -- > The number of deposit transactions made by the user.	
            uint256 totalaffiliate;	                /// U07 -- > The number of users who registered with your cashback code.	
            bool    sign;                           /// U08 -- > The status of the latest disclaimer signing. It will change to false with each hold.	
            uint256 usddeposit;                     /// U09 -- > Total deposit in all tokens if converted to USD.
            uint256 usdaffiliate;                   /// U10 -- > Total affiliate earnings in all tokens, if converted to USD.             
        }

        /// If gas optimization is false, the data (bonus history) will be displayed.
        struct Bonushistory {
            uint256 id;	                            /// V00 -- > Bonus History ID	
            uint256 holdid;                         /// V01 -- > Hold ID
            uint256 blocknumber;                    /// V02 -- > The block number at the time the transaction was made.
            uint256 unixtime;                       /// V03 -- > The time the transaction was made (based on UNIX time).	
            uint256 affiliateprofit;                /// V04 -- > The amount of bonus received by the affiliate.
            uint256 usdvalue;                       /// V05 -- > The number of tokens multiplied by the current price (USD). 
            uint256 percentage_affiliate;           /// V06 -- > The percentage earned by the affiliate.
            uint256 percentage_not_eligible;        /// V07 -- > The percentage that is not eligible because the sponsor did not meet the criteria. 
            uint256 noteligible;                    /// V08 -- > The amount of bonus that is not eligible because the sponsor did not meet the maximum contribution limit.
            uint256 fee;                            /// V09 -- > A 2% fee is given to the deployer who created the hold platform.	
            string transactiontype;                 /// V10 -- > Affiliate Bonus / Deployer
            address from;                           /// V11 -- > Your referral address.	
            address to;                             /// V12 -- > The smart contract address of the hold platform.	
            address tokenaddress;                   /// V13 -- > The currently selected token address.
            string tokensymbol;                     /// V14 -- > A symbol that represents the ticker of a token.	
            uint256 tokendecimal;                   /// V15 -- > The number of decimals for the token, usually 8 (00000000) or 18 (000000000000000000).
            uint256 tokenprice;                     /// V16 -- > The token price when the affiliate bonus enters the system.
            uint256 percentage; 	                /// V17 -- > The percentage of tokens unlocked each month for the referral.
            uint256 oldcontribution;                /// V18 -- > The total amount of all previous user deposits.	
            uint256 amount;                         /// V19 -- > The latest deposit amount from the user.
            uint256 allcontribution;                /// V20 -- > Adding up all the old and new total deposits.	
            uint256 bonusparameter;                 /// V21 -- > The address of the referral.	
            uint256 bonustype;                      /// V22 -- > It will be determined automatically, with the bonus type set based on the bonus parameters.	
            uint256 balancebefore;                  /// V23 -- > Your balance before receiving the bonus in the system.	
            uint256 balanceafter;                   /// V24 -- > Your balance after receiving the bonus in the system.	
            uint256 tokenbalance_before;            /// V25 -- > Dapps balance before receiving the bonus in the system.	
            uint256 tokenbalance_after;             /// V26 -- > Dapps balance after receiving the bonus in the system.	
            uint256 tokenbalance_sync;              /// V27 -- > Synchronizing data with balanceOf.
            uint256 code;                           /// V28 -- > Bonus codes are assigned as 1 (affiliate) and 2 (deployer).
        }

        struct Stat {
            bool activeuser;                        /// W00 -- > The user's status in the system, have they held or not?	
            address tokenaddress;                   /// W01 -- > The currently selected token address.	
            address useraddress;                    /// W02 -- > The user's address.
            string  tokensymbol;			        /// W03 -- > A symbol that represents the ticker of a token.	 	
            uint256 tokendecimal;                   /// W04 -- > The number of decimals for the token, usually 8 (00000000) or 18 (000000000000000000).
            uint256 tokenprice;                     /// W05 -- > The price of the token when the user holds.
            uint256 affiliatevault;                 /// W06 -- > The user's affiliate bonus balance that can be withdrawn.	
            uint256 affiliateprofit;                /// W07 -- > The history of the total affiliate bonus earned by the member.	
            uint256 affiliatepayments;              /// W08 -- > The amount of affiliate bonus that has been successfully withdrawn.	
            uint256 lifetimecontribution;           /// W09 -- > The total deposits made by the user since joining the HoldPlatform.	
            uint256 lifetimepayments;               /// W10 -- > The total number of tokens that have been successfully withdrawn so far (excluding affiliate bonuses).	
            uint256 mybalance;                      /// W11 -- > The token balance on HoldPlatform that you have not withdrawn yet (combined from all storage).
            uint256 activecontribution;             /// W12 -- > The total amount of tokens in storage that have not yet expired.	
            uint256 depositparameter;               /// W13 -- > The parameter used to ensure that the deposit cannot exceed the maximum contribution.	
            uint256 bonusparameter;                 /// W14 -- > This is the parameter used to determine the affiliate bonus that will be received, up to 10%.	
            uint256 tx_deposit;                     /// W15 -- > The total number of deposit transactions in the system.	
            uint256 tx_withdraw;                    /// W16 -- > The total number of withdraw transactions in the system.	
            uint256 tx_affiliatewithdraw;           /// W17 -- > The total number of affiliate withdraw transactions in the system.	
            uint256 unix_lastwithdraw;              /// W18 -- > The last withdrawal time (in Unix time format).

            //Deployeronly
            uint256 stat_fee;                       /// W19 -- > Recording of the fee amount credited to the deployer account.	
            uint256 stat_noteligible;               /// W20 -- > The amount of token balance that is not eligible to be counted as an affiliate bonus and goes to the deployer.	
            uint256 fee_balance;                    /// W21 -- > The translation to English is: "The 2% fee balance ready for withdrawal.	
            uint256 noteligible_balance;            /// W22 -- > The not eligible balance ready for withdrawal.	
            uint256 tx_fee;                         /// W23 -- > The total number of fee withdrawal transactions conducted by the deployer.	
            uint256 tx_noteligible;                 /// W24 -- > The total number of not eligible withdrawal transactions conducted by the deployer.	
            uint256 tx_deployerwithdraw;            /// W25 -- > The total number of withdrawal transactions conducted by the deployer.
            uint256 fee_paid;                       /// W26 -- > The total amount of the 2% fee that has been successfully withdrawn by the deployer.
            uint256 noteligible_paid;               /// W27 -- > The total amount of the Not Eligible balances that has been successfully withdrawn by the deployer.
            uint256 totalwithdraw;                  /// W28 -- > The total accumulated withdrawals from the 2% fee balances and not eligible balances.	

        }

        /// If gas optimization is false, the data (withdraw history) will be displayed.
        struct Withdrawhistory {
            uint256 id;	                            /// X00 -- > Withdraw History ID	
            uint256 holdid;                         /// X01 -- > Hold ID	
            uint256 blocknumber;                    /// X02 -- > The block number at the time the transaction was made.
            uint256 unixtime;                       /// X03 -- > The time the transaction was made (based on UNIX time).	
            uint256 amount;                         /// X04 -- > The total amount of tokens successfully sent from the dApp to the user's account.	
            uint256 usdvalue;                       /// X05 -- > The number of tokens multiplied by the current price (USD).
            string transactiontype;                 /// X06 -- > Type of withdrawal transaction (token / affiliate / deployer).
            address from;                           /// X07 -- > The smart contract address of HoldPlatform	
            address to;                             /// X08 -- > The address where the tokens were successfully withdrawn (user's address).	
            address tokenaddress;                   /// X09 -- > The currently selected token address.		
            string tokensymbol;                     /// X10 -- > A symbol that represents the ticker of a token.			
            uint256 tokendecimal;                   /// X11 -- > The number of decimals for the token, usually 8 (00000000) or 18 (000000000000000000).
            uint256 tokenprice;                     /// X12 -- > The token price when the user withdraws tokens.
            uint256 balancebefore;                  /// X13 -- > The account balance before making the withdrawal.	
            uint256 balanceafter;                   /// X14 -- > The account balance after making the withdrawal.	
            uint256 tokenbalance_before;            /// X15 -- > The Dapps balance before making the withdrawal.
            uint256 tokenbalance_after;             /// X16 -- > The Dapps after before making the withdrawal.
            uint256 bonusparameter_before;          /// X17 -- > Bonus parameter before the user makes a withdrawal (withdrawing tokens reduces the bonus parameter).
            uint256 bonusparameter_after;           /// X18 -- > Bonus parameter after the user makes a withdrawal (withdrawing tokens reduces the bonus parameter).
            uint256 tokenbalance_sync;              /// X19 -- > For data accuracy, each function call will sync with balanceOf.  
            uint256 timeframe;                      /// X20 -- > The time interval since the last withdrawal.   
            uint256 code;                           
            
            /// code - X21 -- > The identification code for the type of withdrawal: 
            // 1. Withdraw history for tokens, where both user and deployer have the same code, which is (1).
            // 2. Withdraw affiliate balance by the user.
            // 3. Withdraw affiliate balance & not eligible balance by the deployer.
        }





    // ------------------------------------
    // ✦ Read Function
    // ------------------------------------



    function _checkAddress(address address_) internal view returns (bool) {
        return (address_ != _deployer || (address_ == _deployer && _readdata));
    }


    /**
    * @notice Enter the user's address in the search field, and all their team data will appear.
    * @return data Contains an array of all referral addresses that have saved the cashback code during initial registration.
    */

    function GetAffiliate(address address_) public view returns (address[] memory data) {
        address[] storage afflist   = _afflist[address_];
        uint256 length              = afflist.length;
        data                        = new address[](length);

        if(_checkAddress(address_)) {

            for (uint256 i  = 0; i < length; ++i) {
                data[i]     = afflist[i];
            }
        }
    }

    /**
    * @notice HoldPlatform V2 has an auto-calculate feature that can be called through a web3 JavaScript
    * @notice . function to get the most accurate estimate of the amount of tokens ready to be withdrawn.
    */

	function GetAvailabletowithdraw(uint256 hold_id) public view returns (uint256 timeframe, uint256 available ) {

        Safe storage s = _safes[hold_id];

        uint256 timeframe_;	
        uint256 availabletowithdraw;
        uint256 onemonth = div(mul(s.amount, s.percentage), 100);

        if(s.endtime <= block.timestamp){
            availabletowithdraw = add(s.amountbalance, s.cashbackbalance);	
        } else {
            // Calculate the difference (in seconds) between the time of the last withdrawal and the current time
            timeframe_ = sub(block.timestamp, s.lasttime);	

            // Calculate the total number of tokens unlocked within one month (30 days - 2592000 seconds)
            uint256 CalculateWithdraw = div(mul(onemonth, timeframe_), 2592000);
            
            // S.amount * s.percentage / 100 * timeframe / seconds30days	
            uint256 MaxWithdraw = div(s.amount, 10);
            uint256 MaxAccumulation;

            // Maximum withdraw before unlocked, Max 10% Accumulation
            MaxAccumulation = (CalculateWithdraw >= MaxWithdraw) ? MaxWithdraw : CalculateWithdraw;
                
            // Maximum withdraw = User Amount Balance   
            availabletowithdraw = (MaxAccumulation >= s.amountbalance) ? s.amountbalance : MaxAccumulation;

            if (s.cashbackbalance != 0) { 
                availabletowithdraw = add(s.cashbackbalance, availabletowithdraw); 
            } 
        }

        timeframe       = timeframe_;
        available       = availabletowithdraw;
    }


    /**
    * @notice If Gas Optimization is set to false, you can view each affiliate bonus transaction here by simply entering the user address.
    * @dev This function retrieves a limited number of bonus history records for a specific address, 
    * @dev ensuring that the number of records does not exceed the requested limit or the available data.
    * @dev The function is designed to avoid issues with excessive data retrieval that could lead to errors in Solidity, 
    * @dev particularly the "stack too deep" error. The records are retrieved in reverse order, starting from the most recent.
    * @param address_ - The address owned by the user.
    * @param limit_ - The maximum limit of data that can be read. The recommended maximum is 1024.
    */

    function GetBonusHistory_byAddress(address address_, uint256 limit_) public view returns (Bonushistory[] memory data) {
        
        if(_...

// [truncated — 119378 bytes total]

// SPDX-License-Identifier: MIT

pragma solidity 0.8.26;

interface ERC20Interface {

    function totalSupply()  external view returns (uint256);

    //view
    function symbol()  external view returns (string memory);
    function decimals()  external view returns (uint256 decimals_);
    function balanceOf(address _owner)  external view returns (uint256 balance);
    function allowance(address _owner, address _spender)  external view returns (uint256 remaining);

    //write
    function transfer(address _to, uint256 _value) external returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
    function approve(address _spender, uint256 _value)  external returns (bool success);


    event Transfer(address indexed _from, address indexed _to, uint256 _value); 
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}