Triger of Block Timeout Generation(TOG)¶

When the entire blockchain network normally discovers new blocks, a timeout mechanism is introduced.

Introduction¶

Mr. Nakamoto set two thresholds for finding a suitable block length of 10 minutes in the CalculateNextWorkRequired function of the BitcoinCore code: nActualTimespan < params.nPowTargetTimespan/4 and nActualTimespan > params.nPowTargetTimespan*4. The approximate time is 3.5 natural days and 56 natural days. When nActualTimespan is less than 3.5 natural days or 56 natural days, the difficulty is increased to find the optimal time required for 10 minutes.

Bitcoin Finance Network adds a block timeout mechanism(TOG) on this basis. The TOG upgrade is an optimization of the Bitcoin code rather than a modification of the Bitcoin consensus rules. In theory, no one can modify the consensus rules of the Bitcoin Finance Network without the support of miners. TOG is designed to find the difficulty required by the mining pool (generating blocks in 10 minutes) faster and avoid blockchain instability caused by fluctuations in computing power.

Check Point of TOG(Triger of Block Timeout Generation) ¶

This checker is used for invalid block attacks, unless the majority of BTF nodes are located in a system time less than NTP time, which does not exist. Therefore, attackers cannot commit fraud by creating an advanced block. If the attacker creates the attack block in advance and broadcasts it at the arrival time, this possibility exists because it complies with the TOG timeout rule. Therefore an additional 3000ms gap is added to avoid this situation.

static bool trigerOfBlockGeneration(const CBlockIndex* pindexLast, const CBlockHeader *pblock ){
    const  int64_t sysStp =  GetSystemTimeInSeconds();
    //Gap 3000 ms for global TCP delay
    if (sysStp + 3  < pblock->GetBlockTime()){
         std::cout<<"BitcoinFinance Network ? TOG(Triger of Block Timeout Generation) -> Warning: Invalid block time or system time not synchronized to NTP service. "<<"\n";
         return false;
    }else if( (pblock->GetBlockTime() -  pindexLast->GetBlockTime() >= 1980)  &&  (sysStp - pindexLast->GetBlockTime() >=  1980)){
         std::cout<<"BitcoinFinance Network <-  TOG been Triggered  <- TOG(Triger of Block Timeout Generation)  "<<"\n";
        return true;
    }else{
        return false;
    }
}

 


/*
Check Point of TOG(Triger of Block Timeout Generation) 
*/
static bool trigerBlockCheckPoint(const CBlockIndex* pindexPrev){
 const int nHeight = pindexPrev->nHeight + 1;
    if (nHeight>=261210){
        return true;
    }else if(nHeight<=261209){
        return false;
    }else{
        return true;
    }
}

Difficulty Retarget <- TOG(Triger of Block Timeout Generation) ¶



unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params& params)
{
            if (params.fPowNoRetargeting)
                return pindexLast->nBits;
           
            int64_t nActualTimespan = pindexLast->GetBlockTime() - nFirstBlockTime;
            std::cout<<"pindexLast->GetBlockTime():"<<(pindexLast->GetBlockTime())<<"\n";
            std::cout<<"nFirstBlockTime:"<  [ActualTimespan]:"< bitcoin default
            if (nActualTimespan < params.nPowTargetTimespan/4){ //ActualTimespan < 3.5 days
                std::cout<<"BTC: BLOCK TOO FAST ->   #[ActualTimespan]:"<
                nActualTimespan = params.nPowTargetTimespan/4;
            std::cout<<"BTC ->  #[CalculateTogRequired] -> Bitcoin Finance EXTEND -> ActualTimespan/4 RTG BTC Default -> (Bitcoin Core Default:ActualTimespan < 3.5 days)"<<"\n";
            }
            
            //Too slow -> bitcoin default
            if ((nActualTimespan >= params.nPowTargetTimespan*4)&&(nActualTimespan < params.nPowTargetTimespan*5)){  
            //ActualTimespan  56 ~ 70 days
                std::cout<<"BTC: BLOCK TOO SLOW ->  #[ActualTimespan]:"<
                nActualTimespan = params.nPowTargetTimespan*4;
                std::cout<<"BTC ->  #[CalculateTogRequired] -> Bitcoin Finance EXTEND -> ActualTimespan*4 BTC Default -> (Bitcoin Core Default:ActualTimespan > 56 days)"<<"\n";
            }
             // Too long block pending -> diff / 4k -> New diff
             
            if( (nActualTimespan >= params.nPowTargetTimespan*5)&&(nActualTimespan < params.nPowTargetTimespan*6)){ 
            //ActualTimespan > 70 ~ 84days
                std::cout<<"BTC ->   #[ActualTimespan]:"<
                nActualTimespan = params.nPowTargetTimespan*100000;
                std::cout<<"BTC ->  #[CalculateTogRequired] -> Bitcoin Finance TOG-> ActualTimespan*100K BTC_RTG -> TOG-ON(Long Block Pending:ActualTimespan  70~84 days)"<<"\n";
            }

            // Too long block pending -> diff / 400k -> New diff
            if (nActualTimespan >= params.nPowTargetTimespan*6){  
            //ActualTimespan > 84 days
                std::cout<<"BTC ->  #[ActualTimespan]:"<
                nActualTimespan = params.nPowTargetTimespan*4000000;
                std::cout<<"BTC ->  #[CalculateTogRequired] -> Bitcoin Finance TOG-> ActualTimespan*400K BTC_RTG -> TOG-ON(Long Block Pending:ActualTimespan > 84 days)"<<"\n";
            }

            // Retarget
            const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
            const arith_uint256 btfFlexPow = UintToArith256(uint256S("0000000000000000000000000000000000000000000000000000000000000003"));
            arith_uint256 bnNew;
            bnNew.SetCompact(pindexLast->nBits);
            if (bnNew<=btfFlexPow){
                //avoid zerx difficulty in Btf network forks
                const arith_uint256 btfInitedPow = UintToArith256(uint256S("0000000000000000000000000000000000000000000000000000000000000003"));
                bnNew *= nActualTimespan*btfInitedPow;
                bnNew /= params.nPowTargetTimespan;
                bnNew +=btfInitedPow;
                std::cout<<"BTC ->  #[CalculateTogRequired] -> Void zero difficulty"<<"\n";
            }else{
                //Start a new difficulty regarting
                std::cout<<"BTC ->  T1#[nActualTimespan]:"<   #[params.nPowTargetTimespan]:"<< params.nPowTargetTimespan<<"\n";
                std::cout <<"BTC ->   #[CalculateTogRequired] -> new difficulty regarting setup"<<"\n";
            }
            if (bnNew > bnPowLimit){
                bnNew = bnPowLimit;
                std::cout<<"BTC ->  #[CalculateTogRequired] -> new difficulty reached Btf.bnPowLimit -> setup (bnNew = bnPowLimit) -> GetCompacted"<<"\n";
            }
            return bnNew.GetCompact();
}

Upgrade BitcoinFinance Network TOG(Triger of Block Timeout Generation) Node¶

Download & Update BitcoinFinance Core Windows Block Sync¶

https://www.doji.today/DojiNode/BitcoinFinanceNetwork_Sync_win_x64_16.1_TOG.zip

Download & Update BitcoinFinance Core Windows¶

https://www.doji.today/DojiNode/BitcoinFinanceNetwork_win_x64_16.1_TOG.zip

Download & Update BitcoinFinance Core Linux¶

https://www.doji.today/DojiNode/BitcoinFinance_x64_unix_16.1_TOG.zip

Update script for linux & mac¶

https://www.btf.finance/togupgrade/upgrade.sh

TOG External Team support ¶

Thanks to the excellent FameEX (www.fameex.com)，Bidacoin(www.bidacoin.com) ，Bitforce (www.bitforcepool.com), Doji(www.doji.today) team in TOG(Triger of Block Timeout Generation) upgrade supporting. The foundation team will focus on completing the second round of financing and the underlying development of the entire SDK.

Table Of Contents

Previous topic

Next topic

Contribute