Topic: [ANN] TagCoin - Multi Token Wallet and Trading Platform - page 37. (Read 301292 times)

AS far as I am concerned the code and the coin are fine...it seems to be fairly stable other than occasional orphans popping up on mining pools - I thought it may have something to do with not everyone being on the latest version. As for anything else nefarious, that would require a hefty chunk of the hashpower to mess with the chain, more than anyone has right now. But if anyone has any concrete info as to why the occasional orphans appear, let us know.

As for the value dropping, well.. BTC has dropped quite a bit and so have most coins. Untill we have a more solid footing with merchants, we are still linked to Bitcoin, as are most coins.

TAG is still moving around ok for transactions, and we are still moving ahead with developments with merchants here in the philippines as well as online via our own developments. I will let you know soon about some interesting projects coming out over the next few weeks..

I've got an idea of why some pools aren't getting hit as hard with orphans lol.

Hey, China... how's the weather over there?

-Fuse

There's still orphans occuring, not as bad as before, but it's odd how some pools seem to get waves and others don't. We're trying to look into possibilities why.

Okay, what's the English version? hehe. LOL, sorry. But I'm asking for everyone else's sake, I'm a some times coder so I can attempt to figure it out.

static const int64 nMaxClockDrift = 2 * 60 * 60; // two hours

unsigned int nStakeMinAge = 60 * 60 * 24 * 30; // minimum age for coin age (2592000s = 30d)
unsigned int nStakeMaxAge = 60 * 60 * 24 * 90; // stake age of full weight (7776000s = 90d)
unsigned int nStakeTargetSpacing = 4 * 60; // 4-minute block spacing (240s)

static const int64 nTargetTimespan = 2 * 60 * 60;  //7200s 2 hrs
static const int64 nTargetSpacingProofOfWork = 4 * 60;   //240s 4 min
static const int64 nTargetSpacingWorkMax = 3 * nTargetSpacingProofOfWork; //720s 12 min

int64 nTargetSpacing = fProofOfStake? nStakeTargetSpacing : min(nTargetSpacingWorkMax, (int64) nStakeTargetSpacing * (1 + pindexLast->nHeight - pindexPrev->nHeight));

//New difficulty algorithm
if (nHeight >= 12000)
{
    CBigNum bnTargetLimit = !fProofOfStake ? bnProofOfWorkLimit : bnProofOfStakeLimit;

    if (pindexLast == NULL)
        return bnTargetLimit.GetCompact(); // genesis block

    const CBlockIndex* pindexPrev = GetLastBlockIndex(pindexLast, fProofOfStake);
    if (pindexPrev->pprev == NULL)
        return bnTargetLimit.GetCompact(); // first block
    const CBlockIndex* pindexPrevPrev = GetLastBlockIndex(pindexPrev->pprev, fProofOfStake);
    if (pindexPrevPrev->pprev == NULL)
        return bnTargetLimit.GetCompact(); // second block

    int64 nActualSpacing = pindexPrev->GetBlockTime() - pindexPrevPrev->GetBlockTime();
   

    // ppcoin: target change every block
    // ppcoin: retarget with exponential moving toward target spacing
    CBigNum bnNew;
    bnNew.SetCompact(pindexPrev->nBits);
    int64 nTargetSpacing = fProofOfStake? nStakeTargetSpacing : min(nTargetSpacingWorkMax, (int64) nStakeTargetSpacing * (1 + pindexLast->nHeight - pindexPrev->nHeight));
    int64 nInterval = nTargetTimespan / nTargetSpacing;
    bnNew *= ((nInterval - 1) * nTargetSpacing + nActualSpacing + nActualSpacing);
    bnNew /= ((nInterval + 1) * nTargetSpacing);

    if (bnNew > bnTargetLimit)
        bnNew = bnTargetLimit;

    return bnNew.GetCompact();
 }
else    //Old difficulty algorithm, prior to block 12000
 {
        if (!fProofOfStake && nHeight<390)                //initial funds for distribution and promotion, keep diff low
                return bnProofOfWorkLimit.GetCompact();
        
        if (!fProofOfStake && nHeight==390)                //starting difficulty of 0.5 for PoW
                return bnInitialProofOfWorkDifficulty.GetCompact();
        
    CBigNum bnTargetLimit = !fProofOfStake ? bnProofOfWorkLimit : bnProofOfStakeLimit;

    if (pindexLast == NULL)
        return bnTargetLimit.GetCompact(); // genesis block

    const CBlockIndex* pindexPrev = GetLastBlockIndex(pindexLast, fProofOfStake);
    if (pindexPrev->pprev == NULL)
        return bnTargetLimit.GetCompact(); // first block
    const CBlockIndex* pindexPrevPrev = GetLastBlockIndex(pindexPrev->pprev, fProofOfStake);
    if (pindexPrevPrev->pprev == NULL)
        return bnTargetLimit.GetCompact(); // second block
        
        CBigNum bnNew;
    bnNew.SetCompact(pindexPrev->nBits);
        
        if (fProofOfStake)                        //PoS difficulty algo. recalc every block.
    {
                int64 nActualSpacing = pindexPrev->GetBlockTime() - pindexPrevPrev->GetBlockTime();
                int64 nTargetSpacing = nStakeTargetSpacing;
                int64 nInterval = nTargetTimespan / nTargetSpacing;
                bnNew *= ((nInterval - 1) * nTargetSpacing + nActualSpacing + nActualSpacing);
                bnNew /= ((nInterval + 1) * nTargetSpacing);
        }
        
        if (!fProofOfStake)                        //PoW difficulty algo. recalc every interval.
   {
        int64 nInterval = nTargetTimespan / nTargetSpacingProofOfWork;
        
    // Only change once per interval
    if ((nHeight) % nInterval != 0)
                return pindexLast->nBits;
                
        // This fixes an issue where a 51% attack can change difficulty at will.
    // Go back the full period unless it's the first retarget after genesis. Code courtesy of Art Forz
    int blockstogoback = nInterval-1;
    if ((nHeight) != nInterval)
        blockstogoback = nInterval;

    // Go back by what we want to be the last intervals worth of blocks
    const CBlockIndex* pindexFirst = pindexLast;
    for (int i = 0; pindexFirst && i < blockstogoback; i++)
        pindexFirst = pindexFirst->pprev;
    assert(pindexFirst);
        
        // Limit adjustment step
    int64 nActualTimespan = pindexLast->GetBlockTime() - pindexFirst->GetBlockTime();
    printf(" nActualTimespan = %"PRI64d" before bounds\n", nActualTimespan);
        
    int64 nActualTimespanMax = nTargetTimespan * 1.25;
    int64 nActualTimespanMin = nTargetTimespan * 0.75;
        
        if (nActualTimespan < nActualTimespanMin)
        nActualTimespan = nActualTimespanMin;
    if (nActualTimespan > nActualTimespanMax)
        nActualTimespan = nActualTimespanMax;
                
    bnNew *= nActualTimespan;
    bnNew /= nTargetTimespan;
   }

    if (bnNew > bnTargetLimit)
        bnNew = bnTargetLimit;

    return bnNew.GetCompact();
 }

   /* Old protocol */
if (GetBlockTime() < FIX_SWITCH_TIME)
 {   
    if (IsProofOfStake())
    {
        // Return trust score as usual
        return (CBigNum(1)<<256) / (bnTarget+1);
    }
    else
    {
        // Calculate work amount for block
        CBigNum bnPoWTrust = (bnProofOfWorkLimit / (bnTarget+1));
        return bnPoWTrust > 1 ? bnPoWTrust : 1;
    }
 }
 
    /* New protocol */
 
    // Calculate work amount for block
    CBigNum nPoWTrust = (CBigNum(nPoWBase) / (bnTarget+1));

    // Set nPowTrust to 1 if we are checking PoS block or PoW difficulty is too low
    nPoWTrust = (IsProofOfStake() || nPoWTrust < 1) ? 1 : nPoWTrust;

    const CBlockIndex* currentIndex = pprev;

    if(IsProofOfStake())
    {
        CBigNum bnNewTrust = (CBigNum(1)<<256) / (bnTarget+1);

        // Return 1/3 of score if parent block is not the PoW block
        if (!pprev->IsProofOfWork())
            return (bnNewTrust / 3);

        int nPoWCount = 0;

        // Check last 12 blocks type
        while (pprev->nHeight - currentIndex->nHeight < 12)
        {
            if (currentIndex->IsProofOfWork())
                nPoWCount++;
            currentIndex = currentIndex->pprev;
        }

        // Return 1/3 of score if less than 5 PoW blocks found
        if (nPoWCount < 5)
            return (bnNewTrust / 3);

        return bnNewTrust;
    }
    else
    {
        CBigNum bnLastBlockTrust = CBigNum(pprev->bnChainTrust - pprev->pprev->bnChainTrust);

        // Return nPoWTrust + 3/4 of previous block score parent block is not PoS
        if (!pprev->IsProofOfStake())
            return nPoWTrust + (3 * bnLastBlockTrust / 4);

        int nPoSCount = 0;

        // Check last 12 blocks type
        while (pprev->nHeight - currentIndex->nHeight < 12)
        {
            if (currentIndex->IsProofOfStake())
                nPoSCount++;
            currentIndex = currentIndex->pprev;
        }

        // Return nPoWTrust + 3/4 of previous block score if less than 4 PoS blocks found
        if (nPoSCount < 4)
            return nPoWTrust + (3 * bnLastBlockTrust / 4);

        bnTarget.SetCompact(pprev->nBits);

        if (bnTarget <= 0)
            return 0;

        CBigNum bnNewTrust = (CBigNum(1)<<256) / (bnTarget+1);

        // Return nPoWTrust + full trust score for previous block nBits
        return nPoWTrust + bnNewTrust;
    }   
   
}

Any updates on the code investigation?  I'm interested to see what's found out.

-Fuse

Suphaan Allah,

May Allah be pleased with all of you for your efforts.

BaraqAllahu fiqom.

Halal feast it is, Jazakallah

Have you guys had a previously-confirmed block (or more than one) turn orphan hundreds or thousands of confirmations later? That's always fun.

A halal feast is in order then.  Baraka Allah.

-Fuse

im muslim i dont drink , but everyone else can have my share

First couple rounds of beers/shots are on me.

-Fuse

we really need a dev to check. i'll see if i can get hold of one