Nexus - Pure SHA3 + CPU/GPU + nPoS + 15 Active Innovations + More to Come

[Videlicet]

It's not a fixed threshold, it is relative to other payouts. Highest balance always gets highest priority on payout, which means if it takes longer, there are miners getting higher payouts from larger amounts of mining power.

Thank You,
Viz.

[cestballot]

CSD pool sources :
https://github.com/VidereLicet/PrimeBetaPool
https://github.com/VidereLicet

We have 3 cpu pool now :
https://bitcointalk.org/index.php?topic=657601.0#post_Pools
Viz Beta CPU Pool: 204.27.62.234:9549  2% fee -min diff 4.5
Cestballot CPU pool faster then beta pool / more uptime: 92.222.190.111 or pool.cestballot.fr  2% fee -min diff 3.8
Nonce-pool CPU pool : http://csd-cpu.nonce-pool.com multiworkers options, 2% fee ?? min diff ??

http://coinshieldpool.cestballot.fr/ use last CSD Viz source code.
Here you can see actual CPU usage for min diff set at 4.0 with only 4 core use (16 core ready)
5843 block found


If you need more help or information, you can easily contact us here, or http://coinshieldtalk.org or https://kiwiirc.com/client/irc.freenode.net/coinshield/ or http://coinshieldpool.cestballot.fr/ at https://twitter.com/cestballot

Best regards

Cest Ballot

[qwep1]

what about GPU pool 

[AliMan]

Yea I don't think we really needed another cpu pool :p

[MeGaDoOm]

It's not a fixed threshold, it is relative to other payouts. Highest balance always gets highest priority on payout, which means if it takes longer, there are miners getting higher payouts from larger amounts of mining power.

Thank You,
Viz.

Wouldn't it be more fair to first do balance payouts (for instance) older than 24h, then do payouts for the highest balances/fast miners.
That way small miners see something happen too !

My miner currently displays: Balance: 20.447240 CSD | Payout: 0.000000 CSD

[macorcina]

It's not a fixed threshold, it is relative to other payouts. Highest balance always gets highest priority on payout, which means if it takes longer, there are miners getting higher payouts from larger amounts of mining power.

Thank You,
Viz.

Wouldn't it be more fair to first do balance payouts (for instance) older than 24h, then do payouts for the highest balances/fast miners.
That way small miners see something happen too !

My miner currently displays: Balance: 20.447240 CSD | Payout: 0.000000 CSD

if biggest miner / balances take payout first, then they can dump, and smal miner only watch they small balances on pool ?

[cestballot]

It's not a fixed threshold, it is relative to other payouts. Highest balance always gets highest priority on payout, which means if it takes longer, there are miners getting higher payouts from larger amounts of mining power.

Thank You,
Viz.

Wouldn't it be more fair to first do balance payouts (for instance) older than 24h, then do payouts for the highest balances/fast miners.
That way small miners see something happen too !

My miner currently displays: Balance: 20.447240 CSD | Payout: 0.000000 CSD

if biggest miner / balances take payout first, then they can dump, and smal miner only watch they small balances on pool ?

no, you receive payout, biggest and smallest miner, your balance is you csd.

Pool core :

Code:

#include "LLP/pool.h"
#include "LLP/server.h"
#include "LLP/daemon.h"
#include "LLP/webui.h"
#include "LLD/record.h"

#include "core.h"
#include "base58.h"
#include <algorithm>

namespace Core
{

	/** Coinbase Transaction for this Block. **/
	Coinbase cGlobalCoinbase;
	std::string POOL_VERSION = "1.0.0";
	

	/** Wallet Connection Variables. **/
	std::map<std::string, double> ROUND_SHARES;
	std::map<std::string, uint64> ACCOUNT_BALANCE;
	
	std::vector<LLP::DaemonHandle*> DAEMON_CONNECTIONS;
	LLP::Server<LLP::PoolConnection>* SERVER;
	LLP::Server<LLP::UiConnection>* WEBSERVER;
	
	LLP::Thread_t MASTER;
	
	
	/** Mutex for Thread Synchronization [std::map is not thread safe]. **/
	boost::mutex              PRIMES_MUTEX;
	
	
	/** Map to hold the Prime Clusters Found. **/
	std::map<uint1024, double> PRIMES_MAP;
	
	
	/** Global Height to flag Pool Threads there is a new Block. **/
	unsigned int nBestHeight = 0;
	
	
	/** The Rewards for the Current Round. **/
	uint64 nRoundReward = 0;
	
	
	unsigned int nDifficultyShares[] = {0, 0, 0, 0, 0};
	
	
	/** Flag to track the new round and when it is setup by the Master Thread. **/
	bool fCoinbasePending = false, fNewRound = false, fSubmittingBlock = false;
	
	
	/** Hash of the Block being Submitted. **/
	uint1024 hashBlockSubmission(0);
	
	
	/** The current Round for the Pool. **/
	unsigned int nCurrentRound = 1;
	
	uint64 nMinimumShare = 45000000;
	
	/** The Database Handles. **/
	LLD::Database<uint1024, LLD::Block> BlockDB("blk.dat");
	LLD::Database<std::string, LLD::Account> AccountDB("acct.dat");
	
	/** DDOS map by Address. **/
	std::map<std::string, LLP::DDOS_Filter*> DDOS_BY_ADDRESS;
	
	
	/** The Address for the Last Round. **/
	std::string LAST_ROUND_BLOCKFINDER = "2S4PPSznWfPVLtPJNpi8Ly46Wft3wGbayGkhaGzKLVcepmrhKTP";
	
	
	/** Used to Sort the Database Account Keys by Balance. **/
	bool BalanceSort(const std::string& firstElem, const std::string& secondElem) { return Core::AccountDB.GetRecord(firstElem).nAccountBalance > Core::AccountDB.GetRecord(secondElem).nAccountBalance; }
	
	
	/** Return List of Accounts Sorted by Balance [Highest Balance First]. **/
	std::vector<std::string> GetSortedAccounts()
	{
		std::vector<std::string> vAccounts = AccountDB.GetKeys();
		std:sort(vAccounts.begin(), vAccounts.end(), BalanceSort);
		
		return vAccounts;
	}
	
	
	/** Entry Function to Start the Daemon Threads and Pool Server. **/
	void StartPool(int nMaxDaemons, int nPoolThreads, bool fDDOS, int rScore, int cScore, int nMinShare)
	{
		printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nCoinshield LLP Prime Pool %s Initializing...\n", POOL_VERSION.c_str());
		printf("[MASTER] Starting Pool with %u Daemon Handles, %u Pool Threads %f Min Share %s | rScore = %u cScore = %u\n", nMaxDaemons, nPoolThreads, nMinShare / 10000000.0, fDDOS ? "With DDOS Protection" : "", rScore, cScore);
		
		nMinimumShare = nMinShare;
		
		InitializePrimes();
		Sleep(1000);
		
		printf("[MASTER] Initializing Databases.\n");

		std::vector<std::string> vAccounts = GetSortedAccounts();
		for( int nIndex = 0; nIndex < vAccounts.size(); nIndex++)
		{
			CoinshieldAddress cAddress(vAccounts[nIndex]);
			if(!cAddress.IsValid())
			{
				printf("[DATABASE] Erasing Invalid Record: %s\n", vAccounts[nIndex].c_str());
				AccountDB.EraseRecord(vAccounts[nIndex].c_str());
			}
			else
				AccountDB.GetRecord(vAccounts[nIndex]).Print();
				//printf("%s:%f\n", vAccounts[nIndex].c_str(), AccountDB.GetRecord(vAccounts[nIndex]).nAccountBalance / 1000000.0);
		}
		AccountDB.WriteToDisk();

		
		std::vector<uint1024> vBlocks = BlockDB.GetKeys();
		for( int nIndex = 0; nIndex < vBlocks.size(); nIndex++)
		{
			LLD::Block cBlock = BlockDB.GetRecord(vBlocks[nIndex]);
			if(cBlock.nRound > nCurrentRound)
				nCurrentRound = cBlock.nRound;
		}
		
		LLP::Thread_t MASTER(MasterThread);
		LLP::Thread_t ORPHAN(OrphanThread);
		for(int nIndex = 0; nIndex < nMaxDaemons; nIndex++)
			DAEMON_CONNECTIONS.push_back(new LLP::DaemonHandle(nIndex, "127.0.0.1", "9325"));
			
		Sleep(1000);
		SERVER    = new LLP::Server<LLP::PoolConnection>(9549, nPoolThreads, fDDOS, cScore, rScore, 60);
		//WEBSERVER = new LLP::Server<LLP::UiConnection>  (9555, 5, false, 0, 0, 10);
	}
	
	
	/** Clear the Shares for the Current Round. **/
	void ClearShares()
	{
		std::vector<std::string> vKeys = AccountDB.GetKeys();
		for(int nIndex = 0; nIndex < vKeys.size(); nIndex++)
		{
			LLD::Account cAccount = AccountDB.GetRecord(vKeys[nIndex]);
			cAccount.nRoundShares = 0;
			AccountDB.UpdateRecord(cAccount);
		}
	}
	
	
	/** Get the Total Weight of Shares from the Current Round. **/
	uint64 TotalWeight()
	{	
		uint64 nWeight = 0;
		
		std::vector<std::string> vKeys = AccountDB.GetKeys();
		for(int nIndex = 0; nIndex < vKeys.size(); nIndex++)
			nWeight += AccountDB.GetRecord(vKeys[nIndex]).nRoundShares;
		
		return nWeight;
	}
	
	
	/** Refund the Payouts if the Block was Orphaned. **/
	void RefundPayouts(uint1024 hashBlock)
	{
		/** Get a Record from the Database. **/
		LLD::Block cBlock = BlockDB.GetRecord(hashBlock);
		
		
		/** Set the Flag that Block is an Orphan. **/
		cBlock.nRound = 0;
		
		
		printf("\n---------------------------------------------------\n\n");
		
		
		/** Clear out the Credits for the Round. **/
		for(std::map<std::string, uint64>::iterator nIterator = cBlock.cCredits.mapCredits.begin(); nIterator != cBlock.cCredits.mapCredits.end(); nIterator++)
		{
			LLD::Account cAccount = AccountDB.GetRecord(nIterator->first);
			if(nIterator->second > cAccount.nAccountBalance)
				cAccount.nAccountBalance = 0;
			else
				cAccount.nAccountBalance -= nIterator->second;
			
			printf("[MASTER] Account %s Removed %f Credits\n", nIterator->first.c_str(), nIterator->second / 1000000.0);
			AccountDB.UpdateRecord(cAccount);
		}
		
		
		/** Refund the Payouts for the Round. **/
		for(std::map<std::string, uint64>::iterator nIterator = cBlock.cCoinbase.mapOutputs.begin(); nIterator != cBlock.cCoinbase.mapOutputs.end(); nIterator++)
		{
			LLD::Account cAccount = AccountDB.GetRecord(nIterator->first);
			cAccount.nAccountBalance += nIterator->second;
			
			printf("[MASTER] Account %s Refunded %f CSD\n", nIterator->first.c_str(), nIterator->second / 1000000.0);
			AccountDB.UpdateRecord(cAccount);
		}
		
		printf("\n---------------------------------------------------\n\n");
		
		
		/** Update the Record into the Database. **/
		BlockDB.UpdateRecord(cBlock);
		BlockDB.WriteToDisk();
	}
	
	
	/** Update the Account Balances from Weights in Current Round. **/
	void UpdateBalances(uint64 nReward)
	{
		printf("\n---------------------------------------------------\n\n");
		
		
		/** Create a New Block Record to Track Payouts. **/
		LLD::Block cBlock(hashBlockSubmission);
		cBlock.cCoinbase = cGlobalCoinbase;
		cBlock.nCoinbaseValue = cGlobalCoinbase.nMaxValue + cGlobalCoinbase.nPoolFee;
		cBlock.nRound = nCurrentRound;
		
		
		/** Make Sure Miners Aren't Credited the Pool Fee [2% for Now]. **/
		nReward -= (nReward * 0.02);
		
		
		/** The 2% Block Finder Bonus from Previous Round. **/
		if(LAST_ROUND_BLOCKFINDER != "")
		{
			uint64 nCredit = (nReward * 0.02);
			LLD::Account cAccount = AccountDB.GetRecord(LAST_ROUND_BLOCKFINDER);
			cAccount.nAccountBalance += nCredit;
			AccountDB.UpdateRecord(cAccount);
			
			cBlock.cCredits.AddCredit(LAST_ROUND_BLOCKFINDER, nCredit);
			nReward -= nCredit;
		}
		
		
		/** Calculate the Total Weight of the Last Round. **/
		uint64 nTotalWeight = TotalWeight();
		uint64 nTotalReward = 0;
		
		
		/** Update the Accounts in the Database Handle. **/
		std::vector<std::string> vKeys = AccountDB.GetKeys();
		for(int nIndex = 0; nIndex < vKeys.size(); nIndex++)
		{
			LLD::Account cAccount = AccountDB.GetRecord(vKeys[nIndex]);
				
			/** Update the Account Balance After Payout was Successful. **/
			if(cGlobalCoinbase.mapOutputs.count(vKeys[nIndex]))
			{
				if(cGlobalCoinbase.mapOutputs[vKeys[nIndex]] > cAccount.nAccountBalance)
					cAccount.nAccountBalance = 0;
				else
					cAccount.nAccountBalance -= cGlobalCoinbase.mapOutputs[vKeys[nIndex]];
					
				AccountDB.UpdateRecord(cAccount);
			}
			
			
			/** Don't Credit Account if there are no Shares for this Round. **/
			if(cAccount.nRoundShares == 0)
				continue;	
					
					
			/** Credit the Account from its Weight. **/
			unsigned int nCredit = (((double)cAccount.nRoundShares / nTotalWeight) * nReward);
			cAccount.nAccountBalance += nCredit;
			nTotalReward += nCredit;
			
			
			/** Update the New Credits in the Block Database. **/
			cBlock.cCredits.AddCredit(vKeys[nIndex], nCredit);
			
			
			/** Commit the New Account Record to Database. **/
			AccountDB.UpdateRecord(cAccount);
			
			
			printf("[ACCOUNT] Account: %s | Credit: %f CSD | Balance: %f CSD\n", cAccount.cKey.c_str(), nCredit / 1000000.0, cAccount.nAccountBalance / 1000000.0);
		}
		
		/** Any Remainder of the Rewards give to Blockfinder. **/
		if(nReward > nTotalReward)
		{
			LLD::Account cAccount = AccountDB.GetRecord(LAST_ROUND_BLOCKFINDER);
			cAccount.nAccountBalance += (nReward - nTotalReward);
			AccountDB.UpdateRecord(cAccount);
			
			printf("[ACCOUNT] Block Finder Bonus to %s of %f CSD\n", LAST_ROUND_BLOCKFINDER.c_str(), (nReward - nTotalReward) / 1000000.0 );
		}
		
		/** Commit the New Block Record to the Block Database. **/
		BlockDB.UpdateRecord(cBlock);
		BlockDB.WriteToDisk();
		cBlock.cCredits.Print();
		
		/** Commit the Account Changes to Database. **/
		AccountDB.WriteToDisk();
		
		
		printf("[ACCOUNT] Balances Updated. Total Round Weight = %f | Total Round Reward: %f CSD\n", nTotalWeight / 1000000.0, nReward / 1000000.0);
		printf("\n---------------------------------------------------\n\n");
	}
	

	/** Reset the Daemon Threads **/
	void ResetDaemons()
	{
		for(int index = 0; index < DAEMON_CONNECTIONS.size(); index++)
			DAEMON_CONNECTIONS[index]->fNewBlock = true;
	}
	
	
	/** Declare a new Round for the Pool. **/
	void NewRound()
	{
		fNewRound = true;
		fCoinbasePending = true;
		
		LLP::Timer TIMER;
		TIMER.Start();
		
		UpdateBalances(nRoundReward);
		ClearShares();
		nCurrentRound++;
		
		{ LOCK(PRIMES_MUTEX);
		  PRIMES_MAP.clear();
		}
		
		fNewRound = false;
		
		printf("[MASTER] New Round, Reset Handlers in %u ms\n", TIMER.ElapsedMilliseconds());
	}
	
	
	/** Determine the thread with the least amount of active connections.
		This keeps the load balanced across all server threads. **/
	LLP::DaemonHandle* FindDaemon()
	{
		int nIndex = 0, nConnections = DAEMON_CONNECTIONS[0]->nTotalConnections;
		for(int index = 1; index < DAEMON_CONNECTIONS.size(); index++)
		{
			if(DAEMON_CONNECTIONS[index]->nTotalConnections < nConnections)
			{
				nIndex = index;
				nConnections = DAEMON_CONNECTIONS[index]->nTotalConnections;
			}
		}
			
		return DAEMON_CONNECTIONS[nIndex];
	}
	
	/** Thread to Determine what Block and Rewards the Coinshield Network is on. **/
	void OrphanThread()
	{
		printf("[MASTER] Initialized Orphan Thread\n");
		LLP::Timer TIMER;
		TIMER.Start();
		
		LLP::DaemonConnection* CLIENT = new LLP::DaemonConnection("127.0.0.1", "9325");
		loop
		{
			Sleep(1);
			
			/** Attempt with best efforts to keep the Connection Alive. **/
			if(!CLIENT->Connected() || CLIENT->Errors() || CLIENT->Timeout(30))
			{
				Sleep(1000);
				
				TIMER.Reset();
				if(!CLIENT->Connect())
					continue;
					
				fSubmittingBlock = false;
				fNewRound = false;
				
			}

			/** Read a Packet until it is Complete. **/
			CLIENT->ReadPacket();
			if(CLIENT->PacketComplete())
			{
				LLP::Packet PACKET = CLIENT->NewPacket();
				CLIENT->ResetPacket();
				
				if(PACKET.HEADER == CLIENT->ORPHAN_BLOCK)
				{
					uint1024 hashOrphan;
					hashOrphan.SetBytes(PACKET.DATA);
					
					printf("[MASTER] Block %s - Round %u Has Been Orphaned\n", hashOrphan.ToString().substr(0, 20).c_str(), BlockDB.GetRecord(hashOrphan).nRound);
					Core::RefundPayouts(hashOrphan);
					
					fCoinbasePending = true;
				}
				
				else if(PACKET.HEADER == CLIENT->GOOD_BLOCK)
				{
					uint1024 hashBlock;
					hashBlock.SetBytes(PACKET.DATA);
						
					printf("[MASTER] Block %s - Round: %u Is in Main Chain\n", hashBlock.ToString().substr(0, 20).c_str(), BlockDB.GetRecord(hashBlock).nRound);
				}
			
			}
			
			/** Don't make any new requests until Master Thread is Set. **/
			if(fNewRound || fSubmittingBlock || fCoinbasePending)
				continue;
			
			/** Check last 5 blocks every 20 seconds. **/
			if(TIMER.ElapsedMilliseconds() > 20000)
			{
				std::vector<uint1024> vKeys = BlockDB.GetKeys();
				for(int nIndex = 0; nIndex < vKeys.size(); nIndex++)
					if(BlockDB.GetRecord(vKeys[nIndex]).nRound >= nCurrentRound)
						CLIENT->CheckBlock(vKeys[nIndex]);
					
				TIMER.Reset();
			}	
		}
	}
	
	/** Thread to Determine what Block and Rewards the Coinshield Network is on. **/
	void MasterThread()
	{
		printf("[MASTER] Initialized Master Thread\n");
		LLP::Timer TIMER;
		TIMER.Start();
		
		LLP::Timer METER_TIMER;
		METER_TIMER.Start();
		
		
		LLP::DaemonConnection* CLIENT = new LLP::DaemonConnection("127.0.0.1", "9325");
		loop
		{
			Sleep(1);
			
			/** Let thread idle while account balances are updated. **/
			if(fNewRound || fSubmittingBlock)
				continue;
				
			/** Attempt with best efforts to keep the Connection Alive. **/
			if(!CLIENT->Connected() || CLIENT->Errors() || CLIENT->Timeout(30))
			{
				Sleep(1000);
				
				if(!CLIENT->Connect())
					continue;

				CLIENT->SetChannel(1);
				
				CLIENT->GetHeight();
				CLIENT->GetRound();
				
				TIMER.Reset();
				METER_TIMER.Reset();
				
				fNewRound = false;
				fSubmittingBlock = false;
				fCoinbasePending = true;
				
				printf("[MASTER] Connect to Daemon Server...\n");
			}
			
			
			if(METER_TIMER.ElapsedMilliseconds() > 10000)
			{
				
				printf("[METERS] 4 ch: x %f | 5 ch: x %f | 6 ch: x %f | 7 ch: x %f\n", (double)nDifficultyShares[0] / nDifficultyShares[1],
				(double)nDifficultyShares[1] / nDifficultyShares[2], (double)nDifficultyShares[2] / nDifficultyShares[3], (double)nDifficultyShares[3] / nDifficultyShares[4]);
				
				METER_TIMER.Reset();
			}
			
			
			if(TIMER.ElapsedMilliseconds() > 2000)
			{
				CLIENT->GetHeight();
				CLIENT->GetRound();
					
				if(fCoinbasePending)
				{
					//printf("[MASTER] Getting Reward.\n");
					CLIENT->GetReward();
				}
						
				//printf("[MASTER] Checking Round.\n");
				
				TIMER.Reset();
			}
			
				
			/** Read a Packet until it is Complete. **/
			CLIENT->ReadPacket();
			if(!CLIENT->PacketComplete())
				continue;
					
					
			/** Handle the New Packet, and Interpret its Data. **/
			LLP::Packet PACKET = CLIENT->NewPacket();
			CLIENT->ResetPacket();
					
			if(fCoinbasePending)
				printf("[MASTER} There is a New Packet...\n");
						
			/** Update the Global Round Height if there is a new Block. **/
			if(PACKET.HEADER == CLIENT->BLOCK_HEIGHT) 
			{ 
				unsigned int nHeight = bytes2uint(PACKET.DATA);
				//printf("[MASTER] Height Received %u\n", nHeight);
				
				if(nHeight > nBestHeight)
				{
					printf("[MASTER] Coinshield Network: New Block [Height] %u\n", nHeight);
					fCoinbasePending = true;

				}
				
				nBestHeight = nHeight;
			}
			
			
			/** Response from Mining LLP that there is a new block. **/
			else if(PACKET.HEADER == CLIENT->NEW_ROUND)
			{
				printf("[MASTER] Coinshield Network: New Block [Round] %u\n", nBestHeight);
				fCoinbasePending = true;
			}
			
			/** After the Coinbase Transaction is Set on Master Thread, Check the Blocks for Orphans. **/
			else if(PACKET.HEADER == CLIENT->COINBASE_SET)
			{
				printf("[MASTER] Coinbase Transaction Set on Master\n");
				fCoinbasePending = false;
				ResetDaemons();
				
					
				/** Commit Shares to Database on New Block. **/
				AccountDB.WriteToDisk();				
			}
			
			/** If the Coinbase Tx Fails to Update, get data again and attempt to rebuild it. **/
			else if(PACKET.HEADER == CLIENT->COINBASE_FAIL)
			{
				printf("[MASTER] ERROR: Coinbase Transaction Not Set. Retrying...\n");
				
				fCoinbasePending = true;
			}
				
			/** Update the Current Round Rewards. **/
			else if(PACKET.HEADER == CLIENT->BLOCK_REWARD)
			{
				nRoundReward = bytes2uint64(PACKET.DATA);
				printf("[MASTER] Received Reward of %f\n", nRoundReward / 1000000.0);
				
				if(nCurrentRound > 1 && fCoinbasePending)
				{
					
					cGlobalCoinbase.nPoolFee = (nRoundReward * 0.02);
					cGlobalCoinbase.Reset(nRoundReward - cGlobalCoinbase.nPoolFee);
					
					
					std::vector<std::string> vAccounts = GetSortedAccounts();
					for(int nIndex = 0; nIndex < vAccounts.size(); nIndex++)
					{
						/** Read the Account Record from the Database. **/
						LLD::Account cAccount = AccountDB.GetRecord(vAccounts[nIndex]);
						
						/** Only add a Payout if Above the 0 CSD Threshold. **/
						if(cAccount.nAccountBalance > 0)
						{
							int nValue = cGlobalCoinbase.AddTransaction(vAccounts[nIndex], cAccount.nAccountBalance);
							if(nValue < 0)
							{
								cGlobalCoinbase.AddTransaction(vAccounts[nIndex], cAccount.nAccountBalance + nValue);
										
								break;
							}
						}
					}
						
					/** Add CSD Block Finder Bonus [On top of Larger Weight] on Rounds where Coinbase is Incomplete. **/
					if(!cGlobalCoinbase.IsComplete())
					{
						int nBonus = cGlobalCoinbase.GetRemainder();
						cGlobalCoinbase.AddTransaction(LAST_ROUND_BLOCKFINDER, nBonus);
					}
						
					cGlobalCoinbase.Print();
					CLIENT->SetCoinbase();
				}
				else
					fCoinbasePending = false;
				
				printf("[DAEMON] Round %u Block %u Rewards %f CSD\n", nCurrentRound, nBestHeight, nRoundReward / 1000000.0);
			}
		}
	}
}

What modification you need ?

Best regards

Cest Ballot

[macorcina]

/** Return List of Accounts Sorted by Balance [Highest Balance First]. **/
   std::vector<std::string> GetSortedAccounts()
all coins have problem with distribution with small and big miners.
maybe smaller balance first four payout ?
that will give fast result for small miners if they see csd in wallet after few hour, and
could be stimulation for more people to mine
also that will prevent big miner to dump large amount of coins before small miner get coins

[cestballot]

/** Return List of Accounts Sorted by Balance [Highest Balance First]. **/
   std::vector<std::string> GetSortedAccounts()
all coins have problem with distribution with small and big miners.
maybe smaller balance first four payout ?
that will give fast result for small miners if they see csd in wallet after few hour, and
could be stimulation for more people to mine
also that will prevent big miner to dump large amount of coins before small miner get coins

Payout first Highest balance, where is the probleme ?

Exemple payout for i5-2410M (2 core intel) :


we have to wait 1.0.3 to have better block creation, if we make little payout like 0.01 csd this can create long and big block hard to create when you send CSD like 1000+.

Example : if i mined 1000 csd during XXX day with little payout like 0.01 csd and I need to send this coin to a friend the new block I create is 0.1+0.1+0.1+ [...]+0.1 = 1000 it can stuck you wallet for big wait time

So, wait 1.0.3 and let see how Viz prepare for you

Best regards

Cest Ballot

ps : I'm not in CSD dev team, I'm just big supporter  

[MeGaDoOm]

The explanation about the payout system looks okay. Although I still wonder what happens when the number of GPU miners increases.

Perhaps the 'balance/payment'-problem lies in understanding what the miner reports on-screen.
Payout is almost always 0 csd, while balance is like 20 csd or so.
My expectation is a 'single transaction' of the 20 csd to my wallet. My Wallet does receive 0.1, 1 or 2 csd every hour or so.
-->     Perhaps an extra counter like 'Sent to wallet: x csd' would be nice,     <--
because just Balance y and payout 0.0 may give the impression that payments are stuck.

[cestballot]

The explanation about the payout system looks okay. Although I still wonder what happens when the number of GPU miners increases.

Perhaps the 'balance/payment'-problem lies in understanding what the miner reports on-screen.
Payout is almost always 0 csd, while balance is like 20 csd or so.
My expectation is a 'single transaction' of the 20 csd to my wallet. My Wallet does receive 0.1, 1 or 2 csd every hour or so.
-->     Perhaps an extra counter like 'Sent to wallet: x csd' would be nice,     <--
because just Balance y and payout 0.0 may give the impression that payments are stuck.

We will add worker setting with payout set by users.
This probably come with GPU pool.  

thx for your post, all this question help use to found new feature.

If you have any question about csd, csd pool and more, just ask use, we will give the best

Best regards

CestBallot

[macorcina]

 worker setting with payout set by users.
That will fix problems for small miners.
Nice.  
And  Coinshield database : http://www.cestballot.fr/downn/coinshield/blkindex20150318.zip
link missing form OP. 

[COOLERbyPSP]

Coinshield database : http://www.cestballot.fr/downn/coinshield/blkindex20150318.zip

http://joxi.ru/DBA0MJDCPnzjry.png
Useless

file unknown has LSN 176/2282454, past end of log at 1/68429
Commonly caused by moving a database from one database environment
to another without clearing the database LSNs, or by removing all of
the log files from a database environment
__db_meta_setup: C:\Users\Лaypa\AppData\Roaming\Coinshield\blkindex.dat: unexpected file type or format
Database handles still open at environment close
Open database handle: addr.dat/main
Open database handle: time.dat/main

[cestballot]

Coinshield database : http://www.cestballot.fr/downn/coinshield/blkindex20150318.zip

http://joxi.ru/DBA0MJDCPnzjry.png
Useless

file unknown has LSN 176/2282454, past end of log at 1/68429
Commonly caused by moving a database from one database environment
to another without clearing the database LSNs, or by removing all of
the log files from a database environment
__db_meta_setup: C:\Users\Лaypa\AppData\Roaming\Coinshield\blkindex.dat: unexpected file type or format
Database handles still open at environment close
Open database handle: addr.dat/main
Open database handle: time.dat/main

I tested this database save on new wallet using windows 7, windows 8.1 and 2012 R2

for exemple pool wallet was resync in just 5 minutes after database corruption. ( my bad )

Todo list :  

1/Start sync your wallet For testing I wait 25000 blocks sync first

2/close the wallet (you have to wait like 5 minutes to be sure wallet close properly)
3/ copy/paste file : blkindex.dat and blk0001.dat


4/ restart wallet and finish sync

Now you are ready.



Best regards

Cest Ballot

Edit : Pool min diff is now set at 3.9, I'll decrease tomorow at 3.8 if all works good.

[MeGaDoOm]

Just curious,,
  why do you manually have to set the (min) difficulty ?

[cestballot]

Just curious,,
  why do you manually have to set the (min) difficulty ?

auto diff is not dev yet 

[Namsbreh]

Thanks for your work with the CPU pool Cestballot.  Providing a solution to the payouts for smaller miners is good and important.

No rush with the GPU pool....solo works fine......

[MeGaDoOm]

Just curious,,
  why do you manually have to set the (min) difficulty ?

auto diff is not dev yet  

No Kimoto Gravity Well ?

[starblocks]

Hello Everyone, Viz. Here  

I am introducing this account for use in the Coin Shield Alerts System.
This will be driven by a collection of bots performing specific analysis to then feed alerts to BitcoinTalk.

These alerts will be Clone Alerts, Scam Alerts, Scam BCT Accounts, etc.
They will be developed for better informing of the public as to current Red Zones in the industry.

"Red Zones" defined is "Threads in which you will surely be scammed and lose most if not all of your money. These places will hold no way for profit unless you are adept in the game of alt coin scams"

Thank You,
Viz.

Interesting concept but is it the most objective way to go

Edit: To be more specific how does this account work work does it post in this thread or the scammers threads or?

[Razerglass]

Just curious,,
  why do you manually have to set the (min) difficulty ?

auto diff is not dev yet  

No Kimoto Gravity Well ?

kgw was the easiest to instamine. im glad Vid redid everything from scratch