Devcoin Official Site

Devcoin is an ethically inspired project based on the BitCoin crypto-currency and created to help fund open source projects created by writers and software developers. For a quick overview, there is a an animated introduction to devcoin.

Participants in the DevCoin economy earn DevCoins in proportion to their project development. Writers earn devcoins by writing, Developers earn devcoins by developing, Marketers earn devcoins by Marketing, and Administrators earn devcoins by applying their time and effort to help organize the DevCoin project.

Hopefully devcoin will eventually fund all types of developers including hardware developers, graphic artists, musicians, and filmmakers.

Download

FreeBSD

Linux

Mac

Source

Web

Devcoin web wallet available through devda.ch (aol, hotmail and yahoo mail is disabled). It can not account for generation devcoins.

Yacoin has a web wallet that supports many coins, including devcoin. It can not account for generation devcoins.

Windows

Purpose

The purpose of the devcoin is to give money to open source developers for their work in as fair a manner as possible.

Many open source developers do not get a significant amount of money for their work. Advertising, charity and sometimes consulting provide some income, but many developers, even those with projects used by several thousand people, only get a few dollars a month. In a typical economy, in the ballpark of 1% goes to charity. That is not enough to support people.

Because developers get so little, they can only develop their projects in their spare time, which makes development really slow. Feature requests and critiques do not accelerate development, money will.

Devcoins provide an income for everyone who wants to work, even if they live in an area with more job seekers than jobs. With devcoin, no one who wants to work need be completely out of money. Anyone who does good work will get some devcoins. There is no guarantee that this will be a high income, but something is way better than nothing.

By buying devcoins you help developers and give the world more open source software, books, music, art, and movies.

Motto

From the many, one

From one, the source

Business

There are several businesses which accept devcoins. If you have a business which accepts devcoins, please message Smeagol through the bitcoin forum to get on the business list. There is also a bounty for the first reported sale in devcoins which a business makes.

Mining

Devcoin is merged mined with bitcoin. There are at least two pools which merge mine devcoins along with bitcoins. One is the bitparking pool:

http://mmpool.bitparking.com/pool

The other is P2PMining, which is down at the time of this writing:

http://p2pmining.com

You can also mine devcoins as a secondary chain with P2Pool:

https://bitcointalk.org/index.php?topic=62842.0

If you are mining devcoins as a secondary chain, you will get devcoin blocks much more often than bitcoin blocks, because the devcoin hash rate is much lower than the bitcoin hash rate. The mining portion of the devcoin block is 5,000 devcoins.

Money

There are three common forms of money.

The original is extractive money. Gold and silver and the most common, but other kinds of resources have been used like copper, salt, wheat, etc..

Debt money is the most common today, this includes all major currencies like the USD, Euro, etc..

Token currency is issued by private issuers and communities and has been used centuries. It is used more often in depressions when there is a lack of debt money. Token currencies include the Colonial Scrip, Time Bank, Christiania Coin, Ithaca Hours, and Worgl Schillings.

Extractive money has the advantage of having a minimum value. It has the disadvantage of taking an enormous amount of resources to create.

Debt money has the advantage of needing only a tiny amount of resources to create. It has the disadvantage that there is no minimum value. It has the additional disadvantage that the proceeds go to bankers who do no useful work, furthermore the bankers then use their ill gotten power to enslave everyone else and attack competing currencies.

Token money has the advantage of needing only a tiny amount of resources to create. It has the disadvantage that there is no minimum value.

Bitcoin is extractive money, devcoin is a community token currency.

Given that tokens have all the advantages of debt money and fewer disadvantages, why is debt money used at all? It is only because the debt money bankers attack competing currencies throughout history.

Donation

Devcoin gives people a way to keep their money with open source developers, with the option of taking the money back if it is needed. In other words, with a typical donation, you give the money to a person or organization, and if later you find that the charity is ineffective, or you need your money back because you're in dire straits, the money is gone and there's nothing you can do about it. By holding devcoins, your money is being used by open source organizations, and the longer you keep it there, the more benefit it gives to the developers. If you decide that devcoin is ineffective, or you need your money back because you're in dire straits, you can sell your devcoins.

If you want to give to a developer of your choice, giving them devcoins is a good way to go because by giving them devcoins, you're directly helping that developer, and indirectly helping all the other developers on the share lists. Although, in this case, since it's a direct donation, there is no way to get the devcoins back from the recipient if decide in future that you want your coins back. The reversible donation concept only applies when you're holding devcoins yourself.

Also, people sometimes lose money. If you lose fiat currency, you've made a permanent donation to the banks, if you lose devcoins, you've made a permanent donation to developers.

History

Bounties were offered for the creation of a charity pool which would give 1% of the mining to bitcoin developers. In total 37 BTC in bounties were paid to two people who started charity pools. Shamen made a pool but then abandoned it.

AnnihilaT made the Mainframe Mining Cooperative, and it was successful for a while. I believe at its peak it donated a bit less than 10 BTC/month to the people on the bitcoin share list. At the time the bitcoin share list had around 20 people on it, so that worked out to less than 0.5 BTC/month per developer. It operated at high power for about three months, which works out to roughly a 30 BTC total, 1.5 BTC/developer. However, it was shut down by the threat of a DDOS attack, so now the people on the bitcoin share list are not getting any bitcoins at all. They are only getting devcoins.

The reason devcoin was made was that even when the Mainframe Mining Cooperative was doing well, because it only donated around 1% of the mining, the developers ended up getting only a tiny amount. Charity is typically 1% of an economy and for all the talk of donations, charity is simply not enough to give open source developers a reasonable income. Devcoin gives 90% to developers, it is the only thing which is giving open source developers a substantial income at all right now, and once it gets known that income will be a reasonable amount.

In the beginning, devcoin gave all the donation coins to programmers, nothing was given to profitable projects. It was hoped that people would buy devcoins as a way to give money to developers, and that would keep the devcoin value high. That hope failed. Shortly after merged mining started, which was necessary to give devcoin security and therefore value, in January 2012 the devcoin market capitalization averaged around 0.00000025 BTC/DVC * 1,200,000,000 DVC = 300 BTC in January 2012.

Since pure charity didn't work, devcoin was changed to a beneficial organization, similar in concept to a benefit corporation. Devcoin would primarily fund open source projects whose revenue would be converted to devcoins, and secondarily fund open source developers with no expectation of future revenue. This has been successful, and at the time of this writing in August 18, 2012, the devcoin market capitalization is about 0.00000140 BTC/DVC * 2,720,400,000 DVC = 3,809 BTC, of which 90% * 3,809 BTC = 3,428 BTC went to developers. The first open source revenue project is devtome, whose potential advertising revenue is small but growing.

Projects

Devcoin funds open source projects with bounties for accomplishments and regular payments for active developers.

The bounty files are named bounty_*.csv, for example bounty_16.csv, and they can be seen in the charity folder.

Active developers are on the bitcoin share list and the devcoin share list. At this time, devcoins are going to developers of devtome, devcoin, bitcoin, Open Transactions, and namecoin. New developers join the lists, and some old developers stop developing, so those lists have been changed many times. Old versions can be accessed from the bitcoin share history, and the devcoin share history.

Market Capitalization

The market capitalization is calculated from the average of the bid and ask on vircurex, times the block number, times 50,000 DVC/block. For example on August 18, 2012, the market capitalization was: 0.5 * (0.00000130 + 0.00000150) BTC/DVC * 54408 blocks * 50,000 DVC/block = 3808.56 BTC ~ 3,809 BTC

The market capitalization can also be calculated by multiplying the vircurex price by the block number in the 'Outstanding' column in a devcoin block explorer. For example on August 18, 2012, the market capitalization was: 0.5 * (0.00000130 + 0.00000150) BTC/DVC * 2,720,400,000 DVC = 3808.56 BTC ~ 3,809 BTC

Both methods yield the same result, the advantage of the first method is that it doesn't need a block explorer. Block explorers often go down, and sometimes all the devcoin block explorers are down at the same time.

Categories

Licenses for programming and hardware which qualify for devcoins are the AGPL, Apache, BSD, GPL, LGPL, MIT, public domain, and unlicense. Web code must be licensed under the AGPL, to close the web services loop hole, it could also be dual licensed. Licenses for writers, musicians, painters and graphic artists, and filmmakers which qualify for devcoins are the Creative Commons Share Alike (wikipedia license), Creative Commons Attribution, public domain, and unlicense.

Programmers and hardware developers includes, but is not limited to, people who develop open source software, websites, machinery, circuits, vehicles, housing, games, medicine, and transportation, energy and resource extraction systems.

Writers includes people who write books, articles, fiction, poetry, and documentation. Fan fiction only qualifies if the source license also qualifies for devcoins.

The musicians category includes people who perform music and people who create or record unique sounds. Currently musicians only earn devcoins for their lyrics by the word, in future they will also get devcoins for music videos.

The painters and graphic artists category does not currently include photographers because photography can be done mechanically with little or no creative work.

The filmmakers category includes people who make movies, shorts, and animation. Fan films only qualify if the source license also qualifies for devcoins. Currently filmmakers only earn devcoins for their scripts by the word, in future they will also get devcoins for the film itself.

Voting

Voting will be range voting on a scale of 0 to 99. If the issue is particular to a single developer, bounty or prize, three administrators are chosen at random to vote. If the issue affects the community, every active developer can vote.

Administration

Anyone on who has been on the active developer list and who works well with others can choose to be an adminstrator at any time, and leave at any time. They are paid for the time they administrate. Each administrator has one task that they are responsible for, and if the task is small they are also expected to help others, for example by answering questions on devcoin threads. The account script sends all the admins 1 to 8 shares for their work, such that the total administrative pay is at most 15% of the grand total.

Technical

Devcoin is an alternate bitcoin block chain. The devcoin daemon is a fork of the bitcoin daemon and the client is a fork of the bitcoin wxWindows version. The latest versions are at Marks's site. The block explorers are listed on the devcoin block explorer page.

Create Block

The sending code in CreateBlock looks like the following:

	vector<string> coinAddressStrings = getCoinAddressStrings(GetDataDir(), string("receiver.csv"), (int)pindexPrev->nHeight+1);
	txNew.vout.resize(coinAddressStrings.size() + 1);
	txNew.vout[0].scriptPubKey << reservekey.GetReservedKey() << OP_CHECKSIG;
	int64 minerValue = GetBlockValue(pindexPrev->nHeight+1, nFees);
	int64 sharePerAddress = 0;
	if (coinAddressStrings.size() == 0)
		minerValue -= fallbackReduction;
	else
		sharePerAddress = share / (int64)coinAddressStrings.size();
	for (int i=0; i < coinAddressStrings.size(); i++)
	{
		// Create transaction
		uint160 hash160 = 0;
		if(!AddressToHash160(coinAddressStrings[i], hash160))
		{
			return NULL;
		}

		txNew.vout[i + 1].scriptPubKey << OP_DUP << OP_HASH160 << hash160 << OP_EQUALVERIFY << OP_CHECKSIG;
		txNew.vout[i + 1].nValue = sharePerAddress;
		minerValue -= sharePerAddress
	}
..
//	pblock->vtx[0].vout[0].nValue = GetBlockValue(pindexPrev->nHeight+1, nFees);
	pblock->vtx[0].vout[0].nValue = minerValue + nFees;

The generated block gives 5,000 devcoins to the miner and 45,000 devcoins divided among the receivers. An example of a devcoin block is devcoin block 1.

Difficulty

Because the devcoin difficulty is lower than the bitcoin difficulty, miners can switch in and out of the chain, which means the block generation rate varies wildly. To fix this problem, the difficulty is determined with a continous average rather a step function, and it is calculated over one day instead of two weeks. This leads to greater daily variation than bitcoin because it is being averaged over a small time; but it is a much smaller variation than the current factor of more than two as a miner switches in and out.

The time difference is determined by sorting the blocks by time stamp, then subtracting the time stamp of the sixth block from the bottom from the time stamp of the sixth block from the top. This is to prevent the time travel exploit.

The first attempt at the continuous average function switched over at block 10,700 and was a failure. The next attempt switched over at block 10,800 and was a success. The successful GetNextWorkRequired function follows below.

unsigned int static GetNextWorkRequired(const CBlockIndex* pindexLast)
{
	const int nSmoothBlock = 10700;
	const int64 nTargetSpacing = 10 * 60;
	int64 nTargetTimespan = 24 * 60 * 60; // one day

	if (pindexLast->nHeight < nSmoothBlock)
		nTargetTimespan *= 14; // two weeks

	int64 nInterval = nTargetTimespan / nTargetSpacing;

	// Genesis block
	if (pindexLast == NULL)
		return bnProofOfWorkLimit.GetCompact();

	const int nMedianBlock = 10800;
	int64 nIntervalMinusOne = nInterval-1;

	if (pindexLast->nHeight < 10)
		return pindexLast->nBits;

	// Change at each block after nSmoothBlock
	if (pindexLast->nHeight < nSmoothBlock)
		if ((pindexLast->nHeight+1) % nInterval != 0)
			return pindexLast->nBits;

	// Go back by what we want to be one day worth of blocks
	const CBlockIndex* pindexFirst = pindexLast;
	vector<int64> blockTimes;
	CBigNum averageBits;
	averageBits.SetCompact(0);

	for (int i = 0; pindexFirst && i < nIntervalMinusOne; i++)
	{
		averageBits += CBigNum().SetCompact(pindexFirst->nBits);
		blockTimes.push_back(pindexFirst->GetBlockTime());
		pindexFirst = pindexFirst->pprev;
	}

	assert(pindexFirst);
	int blockTimeEndIndex = blockTimes.size() - 6;
	sort(blockTimes.begin(), blockTimes.end());
	averageBits /= nIntervalMinusOne;

	// Limit adjustment step
	int64 nActualTimespan = pindexLast->GetBlockTime() - pindexFirst->GetBlockTime();
	int64 nMedianTimespan = blockTimes[blockTimeEndIndex] - blockTimes[6];
	nMedianTimespan *= nIntervalMinusOne / (int64)(blockTimeEndIndex - 6);

	// Change nActualTimespan after nMedianBlock
	if (pindexLast->nHeight > nMedianBlock)
	{
		nActualTimespan = nMedianTimespan;
	}

	printf("  nActualTimespan = %"PRI64d"  before bounds\n", nActualTimespan);

	if (nActualTimespan < nTargetTimespan/4)
		nActualTimespan = nTargetTimespan/4;

	if (nActualTimespan > nTargetTimespan*4)
		nActualTimespan = nTargetTimespan*4;

	// Retarget
	CBigNum bnNew;
	bnNew.SetCompact(pindexLast->nBits);

	// Change bnNew after nMedianBlock
	if (pindexLast->nHeight > nMedianBlock)
		bnNew = averageBits;

	bnNew *= nActualTimespan;
	bnNew /= nTargetTimespan;

	if (bnNew > bnProofOfWorkLimit)
		bnNew = bnProofOfWorkLimit;

	/// debug print
	printf("GetNextWorkRequired RETARGET\n");
	printf("nTargetTimespan = %"PRI64d"	nActualTimespan = %"PRI64d"\n", nTargetTimespan, nActualTimespan);
	printf("Before: %08x  %s\n", pindexLast->nBits, CBigNum().SetCompact(pindexLast->nBits).getuint256().ToString().c_str());
	printf("After:  %08x  %s\n", bnNew.GetCompact(), bnNew.getuint256().ToString().c_str());

	return bnNew.GetCompact();
}

Generation Rate

There has been talk about shifting the decimal place in bitcoin, because a maximum of 21,000,000 bitcoins would lead to people having to deal in milliBitcoins if bitcoin gets really popular. However, once a block chain is made, it is really difficult to change the value of the currency. So even though people will generally want to move the decimal place, it would be not be done and people would be stuck with an awkward currency unit. In the RFC: SI-type of naming convention for BTC thread a lot of the problems people have dealing with a large currency unit are discussed.

Since devcoin is a new currency, it is easy to multiply the coins by 1,000. Also, to make spam unprofitable the transactions fees were increased. The new constants for the transaction fees and max money follow below.

//static const int64 MIN_TX_FEE = 50000;
static const int64 MIN_TX_FEE = 100000000;
//static const int64 MIN_RELAY_TX_FEE = 10000;
static const int64 MIN_RELAY_TX_FEE = MIN_TX_FEE;
//static const int64 MAX_MONEY = 21000000 * COIN;
static const int64 MAX_MONEY = 21000000000 * COIN;
and CENT was replaced by the MIN_TX_FEE wherever the min transaction fee was meant to be used.

The generation is constant at 50,000 coins per block, which is 1,000 times higher than the bitcoin starting rate. At a typical rate of 144 blocks a day, 1,008 a week, roughly 4,000 a month, that means the 200,000,000 devcoins are generated each month. Of those, 90% go to the developers, so the developers get 180,000,000 devcoins a month in total.

The generation is unlimited, there is no block halving. The generation pays for ongoing development, which increases revenue. So the revenue per devcoin can keep increasing, even though the number of devcoins keeps increasing.

The MAX_MONEY variable is 21 billion devcoins, it is only a transaction limit. This is to stop someone from breaking the system by overflowing an integer.

Random Number

Random numbers for voting are determined by a hash of the string composed of the post time and the next block of the highest difficulty block chain, which at the time of this writing is bitcoin. For consecutive random numbers, the next number is the hash of the string doubled and so on. For example, say someone applies to be accepted as an active developer. When they post their application, the hash of their post time and the next block after their post is combined to make a string. The hexadecimal hash of that string is used as a number from zero to one, multiplied by the number of administrators, to get the first administrator. The hexadecimal hash of the doubled string is multiplied by the number of remaining adminstrators, to get the second administrator. The hash of the tripled string is multiplied by the remaining, to get the third administrator.

Receiver Files

Client Procedure

Receiver.h accesses a synchronized list of receivers.

For example, say the devcoin client requests the height 9000 receivers, the height step is 4000 and only the root receiver_0.csv saved. Receiver.h will first look for the receiver_2.csv file. Since it's not there it will step down and look for receiver_1.csv. Still not there so it looks for and finds receiver_0.csv. It then downloads receiver_1.csv by looking at the peers in receiver_0.csv and saves in the data directory. It then downloads receiver_2.csv by looking at the peers in receiver_1.csv and saves in the data directory. Once it has receiver_2.csv, it parses it to get the list of receivers and uses height modulo list length to return the receivers for height 9000.

Receiver also looks ahead, after it is a random portion between 0.75 and roughly 0.95 of the way to the next step so that there is no mass downloading when the block height switches from x999 to x000. To resist ddos attacks and to work even when some web sites are down, it picks the page which the majority of peers have available. The step size of 4000 gives an update roughly each month.

Disbursing the Share

The generation share is 90% of the block, which is 90% * 50,000 devcoins = 45,000 devcoins. It is disbursed to the devcoin addresses in the receiver file, in round robin order. In each generation round, for a given block height, the index of the line of addresses is the block height above the start of the round, modulo the number of addresses. The code snippet for that follows below.

vector<string> getCoinAddressStrings(const string& dataDirectory, const string& fileName, int height, int step)
{
..
	int remainder = height - step * (height / step);
	int modulo = remainder % (int)coinLists.size();

	vector<string> originalList = coinLists[modulo];

	for (vector<string>::iterator tokenIterator = originalList.begin(); tokenIterator != originalList.end(); tokenIterator++)
	{
		if (*tokenIterator != string("="))
			oldToken = tokenIterator->substr();

		coinList.push_back(oldToken);
	}

	return coinList;
}

Then in CreateBlock, the share per address is calculated by dividing the generation share by the number of coin addresses in the line of addresses. A subtransaction to create share per address coin value is then added for each coin address to the generation transaction. The transactions from generation can be seen by looking at a devcoin block explorer.

Viewing Disbursements

To view your own disbursements, the easiest way is to download the devcoin-qt client. In that client you'll see payments from generation.

If you can not install that on your system, then you can look for disbursements in a devcoin block explorer. For example, to find the payouts to the devcoin address 17vec4jQGCzMEsTnivizHPaowE715tu2CB in the round 16 receiver file. Counting from zero in the receiver file, the address is at line 22. Round 16 starts on block 16 * 4,000 = 64,000. You'll see the generation share in block 64,022 in a block explorer. In Icoin's block explorer, you can go the 64,022 block, and see the payment for 45,000 devcoins in the generation row of that block. Since there are 47 receiver lines in round 16, another payment to that address will be in block 64,069. Other payments to that address will be in block 64,116, block 64,163, etc.. Round 16 lasts until block 67,999.

Generating the Files

To generate a file, download the github charity repository. Then generate the devtome earnings file, then the marketing earnings file (which requires devtome earnings), then the receiver file (which requires devtome earnings and marketing earnings).

To generate files for round 23, starting with the devtome earnings, in that folder open a terminal and type:

python devtome.py -round 23

Generating the marketing file requires the devtome earnings file, the command is:

python marketing.py -round 23

Generating the receiver file requires the locations in the account_location.csv file, which currently has:

Bitcoin Share List,bitcoinshare.html
Bounty,bounty_xx.csv
Devcoin Share List,devcoinshare.html
Devtome Earnings,devtome_earnings_xx.csv
Marketing Earnings,marketing_earnings_xx.csv

For example, in round 23 those files are the list of bitcoin developers, round 23 bounty file, list of non bitcoin developers, round 23 devtome earnings file, and round 23 marketing earnings file.

Once all those files are in the folder, the command to finally make the receiver file is:

python account.py -round 23

This will create the receiver_23.csv file and the account_23.csv file. The receiver file is then uploaded by all the file administrators to their respective sites. The account_23.csv file is to help people keep track of where the coins are going, it is not necessary for devcoin to function.

A script to download the bounty, earnings, peer and share files and make the receiver and account files follows below:

#!/bin/bash

round=$1
if [ "${round}x" == "x" ]; then
  echo 'USAGE: bountyproc.sh <ROUND>'
  echo 'where ROUND is the number of the round to process.'
  exit 1
fi

# It's time to generate the round 23 receiver file. An example procedure is on the wiki at:
# http://www.devtome.com/doku.php?id=devcoin#generating_the_files

# and the procedure for round 23 follows below.
# First please download the latest version of:

rm -f bitcoinshare.html
wget https://raw.github.com/Unthinkingbit/charity/master/bitcoinshare.html
rm -f devcoinshare.html
wget https://raw.github.com/Unthinkingbit/charity/master/devcoinshare.html
rm -f peer.csv
wget https://raw.github.com/Unthinkingbit/charity/master/peer.csv
rm -f bounty_${round}.csv
wget https://raw.github.com/Unthinkingbit/charity/master/bounty_${round}.csv
rm -f devtome_earnings_${round}.csv
wget https://raw.github.com/Unthinkingbit/charity/master/devtome_earnings_${round}.csv
rm -f marketing_earnings_${round}.csv
wget https://raw.github.com/Unthinkingbit/charity/master/marketing_earnings_${round}.csv
rm -f account.py
wget https://raw.github.com/Unthinkingbit/charity/master/account.py
rm -f account_location.csv
wget https://raw.github.com/Unthinkingbit/charity/master/account_location.csv
rm -f almoner.py
wget https://raw.github.com/Unthinkingbit/charity/master/almoner.py

# Then in that folder open a terminal and type:
python account.py -round round

Renaming Bitcoin to Devcoin

The default data directory, irc channel and pchMessageStart was changed to devcoin.

Data Directory

The default directory code in GetDefaultDataDir was changed to:

	// Windows: C:\Documents and Settings\username\Application Data\Devcoin
	// Mac: ~/Library/Application Support/Devcoin
	// Unix: ~/.devcoin
#ifdef __WXMSW__
	// Windows
	return MyGetSpecialFolderPath(CSIDL_APPDATA, true) + "\\Devcoin";
#else
	char* pszHome = getenv("HOME");
	if (pszHome == NULL || strlen(pszHome) == 0)
		pszHome = (char*)"/";
	string strHome = pszHome;
	if (strHome[strHome.size()-1] != '/')
		strHome += '/';
#ifdef __WXMAC_OSX__
	// Mac
	strHome += "Library/Application Support/";
	filesystem::create_directory(strHome.c_str());
	return strHome + "Devcoin";
#else
	// Unix
	return strHome + ".devcoin";

IRC Channel

The send code in ThreadIRCSeed2 was changed to:

			Send(hSocket, "JOIN #devcoinTEST\r");
			Send(hSocket, "WHO #devcoinTEST\r");
		} else {
			// randomly join #bitcoin00-#bitcoin99
//			int channel_number = GetRandInt(100);
//			Send(hSocket, strprintf("JOIN #bitcoin%02d\r", channel_number).c_str());
//			Send(hSocket, strprintf("WHO #bitcoin%02d\r", channel_number).c_str());
			Send(hSocket, "JOIN #devcoin\r");
			Send(hSocket, "WHO #devcoin\r");

Message Start

The pchMessageStart in LoadBlockIndex was changed to:

		pchMessageStart[0] = 'd';
		pchMessageStart[1] = 'e';
		pchMessageStart[2] = 'v';
		pchMessageStart[3] = '-';
The default port was changed to 53333 and the default test net port changed to 63333:
inline unsigned short GetDefaultPort() { return fTestNet ? 63333 : 53333; }

Spam Proofing

To make spam unprofitable, the following changes were made:

  • 1) Increase the MIN_TX_FEE
  • 2) Set MIN_RELAY_TX_FEE = MIN_TX_FEE
  • 3) Added an extra fee to sendMany for each tiny sub transaction
  • 4) Eliminated free transactions

The MIN_TX_FEE and MIN_RELAY_TX_FEE changes are listed in the Generation Rate section.

To add the extra fee and eliminate free transactions, the following change was made in GetMinFee in main.h:

//		if (fAllowFree)
//		{
//			if (nBlockSize == 1)
//			{
//				// Transactions under 10K are free
//				// (about 4500bc if made of 50bc inputs)
//				if (nBytes < 10000)
//					nMinFee = 0;
//			}
//			else
//			{
//				// Free transaction area
//				if (nNewBlockSize < 27000)
//					nMinFee = 0;
//			}
//		}

//		// To limit dust spam, require MIN_TX_FEE/MIN_RELAY_TX_FEE if any output is less than 0.01
//		if (nMinFee < nBaseFee)
//			BOOST_FOREACH(const CTxOut& txout, vout)
//				if (txout.nValue < CENT)
//					nMinFee = nBaseFee;

		 // To limit dust spam, require an additional one tenth of MIN_TX_FEE/MIN_RELAY_TX_FEE for each output
		BOOST_FOREACH(const CTxOut& txout, vout)
			nMinFee += nBaseFee / 10;

Subsidy and Share

The constants required for the subsidy are changed and constants for share, and fallback reduction are added. In main.cpp, the constants at the beginning are changed:

static const int64 initialSubsidy = 50000 * COIN;
static const int64 share = initialSubsidy * 9 / 10;
static const int64 fallbackReduction = (initialSubsidy + share) / 2;

and code in GetBlockValue is changed:

//int64 nSubsidy = 50 * COIN;
int64 nSubsidy = initialSubsidy;

Also, in the rpc.cpp file, code in AmountFromValue is changed:

//if (dAmount <= 0.0 || dAmount > 21000000.0)
if (dAmount <= 0.0 || dAmount > 21000000000.0)

Validate Block

The validation code in ConnectBlock needs the addition of:

	//
	// Check that the required share was sent to each beneficiary
	//
	if (vtx[0].GetValueOut() > (GetBlockValue(pindex->nHeight, nFees) - fallbackReduction))
	{
		std::vector<std::string> addressStrings;
		std::vector<int64> amounts;

		for (int i = 1; i < vtx[0].vout.size(); i++)
		{
			if (vtx[0].vout[i].scriptPubKey.GetBitcoinAddressHash160() != 0)
			{
				addressStrings.push_back(vtx[0].vout[i].scriptPubKey.GetBitcoinAddress());
				amounts.push_back(vtx[0].vout[i].nValue);
			}
		}

		if (!getIsSufficientAmount(addressStrings, amounts, GetDataDir(), string("receiver.csv"), (int)pindex->nHeight, share))
			return error("ConnectBlock() : Share to beneficiary is insufficient");
	}

Concerns

The primary concern is that in the long term, most organizations become corrupt, regardless of the intentions of the founders. The single best defense against the corruption of an organization is competition. Devcoin would be the first currency to give part of its generation to developers. However, developers are welcome to fork it in turn, and create say a reformcoin, that also gives generation to developers, but starts with another set of founders. If the reformcoin is less corrupt than devcoin, people will sell the devcoin and buy reformcoins. Even if most people remain with devcoin, just the possibility that people could move to reformcoin would tend to rein in the corruption of the devcoin. To increase the availability of competition, there will be bounties for software to easily make alternate currencies derived from devcoin, and bounties for easy to use range voting software. This would also make it easier for people to make other coins like town coins and project coins.

To further reduce corruption, all meetings and votes will be public, because sunshine is the best disinfectant.

For active developers, their receive key will have a large portion of their devcoins, and if that key was lost or stolen they would suffer. So the almoner software might be upgraded to handle a list of keys. There will also be bounties for software and hardware key generators.

Commerce | Computing


QR Code
QR Code devcoin (generated for current page)
 

Advertise with Anonymous Ads