Update and clean source code

[drarko]

No description provided.

[drarko]

I'm working on this. If someone want to help, comment here.

[cmelion]

There was consensus reached in the discord dev channel that we should NewYorkCoinIfy the current DogeCoin master branch.

We identified the branch point from Dogecoin as https://github.com/dogecoin/dogecoin/tree/1.4-archive

Excluding copyright and bulk conversion of /Dogecoin/ --> /newyorkc/ there are roughly 100 sloc that were changed.

Changes of significance:

main.cpp

-- starting at line 825 (this is also where we would address block reward reduction)

int64 static GetBlockValue(int nHeight, int64 nFees, uint256 prevHash) {
	int64 nSubsidy = 10000 * COIN;

    std::string cseed_str = prevHash.ToString().substr(7,7);
	const char* cseed = cseed_str.c_str();
	long seed = hex2long(cseed);
	int rand = generateMTRandom(seed, 999999);
	int rand1 = 0;
	int rand2 = 0;
	int rand3 = 0;
	int rand4 = 0;
	int rand5 = 0;

	if (nHeight == 1) {
		nSubsidy = 97000000 * COIN;
	}
	else if (nHeight < 101) {
		nSubsidy = 1 * COIN;
	}

	if (nHeight < 100000) {
		nSubsidy = (1 + rand) * COIN;
	} else if (nHeight < 200000) {
		cseed_str = prevHash.ToString().substr(7,7);
		cseed = cseed_str.c_str();
		seed = hex2long(cseed);
		rand1 = generateMTRandom(seed, 499999);
		nSubsidy = (1 + rand1) * COIN;
	} else if (nHeight < 300000) {
		cseed_str = prevHash.ToString().substr(6,7);
		cseed = cseed_str.c_str();
		seed = hex2long(cseed);
		rand2 = generateMTRandom(seed, 249999);
		nSubsidy = (1 + rand2) * COIN;
	} else if (nHeight < 400000) {
		cseed_str = prevHash.ToString().substr(7,7);
		cseed = cseed_str.c_str();
		seed = hex2long(cseed);
		rand3 = generateMTRandom(seed, 124999);
		nSubsidy = (1 + rand3) * COIN;
	} else if (nHeight < 500000) {
		cseed_str = prevHash.ToString().substr(7,7);
		cseed = cseed_str.c_str();
		seed = hex2long(cseed);
		rand4 = generateMTRandom(seed, 62499);
		nSubsidy = (1 + rand4) * COIN;
	} else if (nHeight < 600000) {
		cseed_str = prevHash.ToString().substr(6,7);
		cseed = cseed_str.c_str();
		seed = hex2long(cseed);
		rand5 = generateMTRandom(seed, 31249);
		nSubsidy = (1 + rand5) * COIN;
	}
	return nSubsidy + nFees;
}

static const int64 nTargetTimespan = 2 * 60 * 60; // every 2 hours
static const int64 nTargetSpacing = 30; // 30 seconds
static const int64 nInterval = nTargetTimespan / nTargetSpacing;

-- Starting at line 910

unsigned int static KimotoGravityWell(const CBlockIndex* pindexLast, const CBlock *pblock, uint64 TargetBlocksSpacingSeconds, uint64 PastBlocksMin, uint64 PastBlocksMax) {
	const CBlockIndex  *BlockLastSolved	= pindexLast;
	const CBlockIndex  *BlockReading	= pindexLast;
	const CBlock *BlockCreating			= pblock;
	BlockCreating						= BlockCreating;
	uint64 PastBlocksMass  				= 0;
	int64 PastRateActualSeconds			= 0;
	int64 PastRateTargetSeconds			= 0;
	double PastRateAdjustmentRatio		= double(1);
	CBigNum PastDifficultyAverage;
	CBigNum PastDifficultyAveragePrev;
	double EventHorizonDeviation;
	double EventHorizonDeviationFast;
	double EventHorizonDeviationSlow;

	if (BlockLastSolved == NULL || BlockLastSolved->nHeight == 0 || (uint64)BlockLastSolved->nHeight < PastBlocksMin) { return bnProofOfWorkLimit.GetCompact(); }

	for (unsigned int i = 1; BlockReading && BlockReading->nHeight > 0; i++) {
            if (PastBlocksMax > 0 && i > PastBlocksMax) { break; }
            PastBlocksMass++;
            
            if (i == 1)        { PastDifficultyAverage.SetCompact(BlockReading->nBits); }
            else                { PastDifficultyAverage = ((CBigNum().SetCompact(BlockReading->nBits) - PastDifficultyAveragePrev) / i) + PastDifficultyAveragePrev; }
            PastDifficultyAveragePrev = PastDifficultyAverage;
            
            PastRateActualSeconds                        = BlockLastSolved->GetBlockTime() - BlockReading->GetBlockTime();
            PastRateTargetSeconds                        = TargetBlocksSpacingSeconds * PastBlocksMass;
            PastRateAdjustmentRatio                        = double(1);
            if (PastRateActualSeconds < 0) { PastRateActualSeconds = 0; }
            if (PastRateActualSeconds != 0 && PastRateTargetSeconds != 0) {
            PastRateAdjustmentRatio                        = double(PastRateTargetSeconds) / double(PastRateActualSeconds);
            }
            EventHorizonDeviation                        = 1 + (0.7084 * pow((double(PastBlocksMass)/double(144)), -1.228));
            EventHorizonDeviationFast                = EventHorizonDeviation;
            EventHorizonDeviationSlow                = 1 / EventHorizonDeviation;
            
            if (PastBlocksMass >= PastBlocksMin) {
                    if ((PastRateAdjustmentRatio <= EventHorizonDeviationSlow) || (PastRateAdjustmentRatio >= EventHorizonDeviationFast)) { assert(BlockReading); break; }
            }
            if (BlockReading->pprev == NULL) { assert(BlockReading); break; }
            BlockReading = BlockReading->pprev;
	}

	CBigNum bnNew(PastDifficultyAverage);
	if (PastRateActualSeconds != 0 && PastRateTargetSeconds != 0) {
		bnNew *= PastRateActualSeconds;
		bnNew /= PastRateTargetSeconds;
	}

    if (bnNew > bnProofOfWorkLimit) { bnNew = bnProofOfWorkLimit; }

	printf("Difficulty Retarget - Kimoto Gravity Well\n");
	printf("PastRateAdjustmentRatio = %g\n", PastRateAdjustmentRatio);
	printf("Before: %08x  %s\n", BlockLastSolved->nBits, CBigNum().SetCompact(BlockLastSolved->nBits).getuint256().ToString().c_str());
	printf("After:  %08x  %s\n", bnNew.GetCompact(), bnNew.getuint256().ToString().c_str());

	return bnNew.GetCompact();
}

unsigned int static GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlock *pblock) {
		static const int64 BlocksTargetSpacing	= 0.5 * 60; // 30 seconds
		unsigned int TimeDaySeconds				= 60 * 60 * 24;
		int64 PastSecondsMin					= TimeDaySeconds * 0.01;
		int64 PastSecondsMax					= TimeDaySeconds * 0.14;
		uint64 PastBlocksMin					= PastSecondsMin / BlocksTargetSpacing;
		uint64 PastBlocksMax					= PastSecondsMax / BlocksTargetSpacing;

		return KimotoGravityWell(pindexLast, pblock, BlocksTargetSpacing, PastBlocksMin, PastBlocksMax);
}

unsigned int static GetNextWorkRequired_V1(const CBlockIndex* pindexLast, const CBlock *pblock) {
 

-- Starting at line 2092

bool LoadBlockIndex(bool fAllowNew)
{
    if (fTestNet)
    {
        pchMessageStart[0] = 0xac;
        pchMessageStart[1] = 0xb1;
        pchMessageStart[2] = 0xc5;
        pchMessageStart[3] = 0xdc;
        hashGenesisBlock = uint256("0x24463e4d3c625b0a9059f309044c2cf0d7e196cf2a6ecce901f24f681be33c8f");
    }

    //
    // Load block index
    //
    CTxDB txdb("cr");
    if (!txdb.LoadBlockIndex())
        return false;
    txdb.Close();

    //
    // Init with genesis block
    //
    if (mapBlockIndex.empty())
    {
        if (!fAllowNew) {
            return false;
        }

        // Genesis block
        const char* pszTimestamp = "A Coin for New York City";
        CTransaction txNew;
        txNew.vin.resize(1);
        txNew.vout.resize(1);
        txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(4) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
        txNew.vout[0].nValue = 88 * COIN;
        txNew.vout[0].scriptPubKey = CScript() << ParseHex("040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9") << OP_CHECKSIG;
        CBlock block;
        block.vtx.push_back(txNew);
        block.hashPrevBlock = 0;
        block.hashMerkleRoot = block.BuildMerkleTree();
        block.nVersion = 1;
        block.nTime    = 1394102925;
        block.nBits    = 0x1e0ffff0;
        block.nNonce   = 2482334;

        if (fTestNet)
        {
            block.nTime    = 1394101189;
            block.nNonce   = 1556996;
        }

        //// debug print
        printf("block.GetHash() = %s\n", block.GetHash().ToString().c_str());
        printf("hashGenesisBlock = %s\n", hashGenesisBlock.ToString().c_str());
        printf("block.hashMerkleRoot = %s\n", block.hashMerkleRoot.ToString().c_str());
        assert(block.hashMerkleRoot == uint256("0x2bad42ac6e0ccc4808d8df0fd50ac8634eea335b1412b1ef52864b430a87b262"));

		if (false && block.GetHash() != hashGenesisBlock) {
		

-- Starting at line 2522

        if (pfrom->nVersion < MIN_PROTO_VERSION)
        {
            // Since February 20, 2012, the protocol is initiated at version 209,
            // and earlier versions are no longer supported

main.h

-- line 51

static const uint256 hashGenesisBlockOfficial("0x5597f25c062a3038c7fd815fe46c67dedfcb3c839fbc8e01ed4044540d08fe48");

-- starting at line 525

    static bool AllowFree(double dPriority)
    {
        // Large (in bytes) low-priority (new, small-coin) transactions
        // need a fee.
        return dPriority > 100 * COIN * 2880 / 250;
    }

net.cpp

-- line 1141

// DNS seeds
// Each pair gives a source name and a seed name.
// The first name is used as information source for addrman.
// The second name should resolve to a list of seed addresses.
static const char *strDNSSeed[][2] = {
       // default hypernode dns seed , change later when network grows
       {"107.155.190.222", "107.155.190.222"}
};

bitcoinrpc.cpp

-- line 2893

    // Try a dual IPv6/IPv4 socket, falling back to separate IPv4 and IPv6 sockets
    const bool loopback = !mapArgs.count("-rpcallowip");
    asio::ip::address bindAddress = loopback ? asio::ip::address_v6::loopback() : asio::ip::address_v6::any();
    ip::tcp::endpoint endpoint(bindAddress, GetArg("-rpcport", 18823));

-- line 3172

Object CallRPC(const string& strMethod, const Array& params)
{
    if (mapArgs["-rpcuser"] == "" && mapArgs["-rpcpassword"] == "")
.
.
.
    if (!d.connect(GetArg("-rpcconnect", "127.0.0.1"), GetArg("-rpcport", "18823")))
        throw runtime_error("couldn't connect to server");

Additionally checkpoints are not included in the original codebase and should be added in checkpoints.cpp.

ex:

    static MapCheckpoints mapCheckpoints =
            boost::assign::map_list_of
            (  0, hashGenesisBlockOfficial )
            (  42279, uint256("0x8444c3ef39a46222e87584ef956ad2c9ef401578bd8b51e8e4b9a86ec3134d3a"))
            (  42400, uint256("0x557bb7c17ed9e6d4a6f9361cfddf7c1fc0bdc394af7019167442b41f507252b4"))
            (  104679, uint256("0x35eb87ae90d44b98898fec8c39577b76cb1eb08e1261cfc10706c8ce9a1d01cf"))
			;

[jamesburrell2]

Ok great thanks for the info!