Codablecashのソースコードで、ステーキングの中身を追いかけてみる

// src_blockchain/bc_status_cache_context/StatusCacheContext.cpp
void StatusCacheContext::calcTicketPrice(const BlockHeader *header) {
	uint64_t height = header->getHeight();

	uint64_t window = this->config->getTicketPriceWindow(height);

	uint64_t mod = (height + 1) % window;
	if(mod != 0){
		return;
	}

	uint64_t numTicketMax = this->config->getTicketIdealNumber(height);
	uint64_t ticketPriceDefault = this->config->getTicketPriceDefault(height);

	// ・・・・・（全投票ノードの台帳を list に集める）

	BalanceUnit total(0L);                       // 合計を0から始める

	int maxLoop = list->size();
	for(int i = 0; i != maxLoop; ++i){           // 投票ノードを順に回って
		VoterEntry* entry = list->get(i);

		total += entry->getTicketPriceSum();     // そのノードが抱えるチケットのロック額の合計を足す
	}

	uint64_t price = total.getAmount() / numTicketMax;
	price = price < ticketPriceDefault ? ticketPriceDefault : price;

	this->ticketPrice = price;
}

// src_blockchain/bc/CodablecashSystemParam.cpp
CodablecashSystemParam::CodablecashSystemParam() {
	// ・・・・・

	this->ticketPriceDefault = 2;
	this->ticketPriceWindow = 256;
	this->ticketIdealNumber = 40000;

	// ・・・・・
}

// src_blockchain/bc_finalizer_trx/RegisterTicketTransaction.cpp
TrxValidationResult RegisterTicketTransaction::validateFinal(
		const BlockHeader *header, MemPoolTransaction *memTrx, IStatusCacheContext *context) const {
	{
		uint64_t priceUint = context->getTicketPrice();
		BalanceUnit price(priceUint);
		BalanceUnit amount = this->ticketUtxo->getAmount();
		if(price.compareTo(&amount) > 0){
			return TrxValidationResult::INVALID;
		}
	}

	・・・・・
}

// src_blockchain/bc_finalizer_trx/TicketUtxo.h
class TicketUtxo: public AbstractUtxo {
	// ・・・・・

	virtual BalanceUnit getAmount() const noexcept;

	//・・・・・

private:
	NodeIdentifier* nodeId; // Stake pool
	AddressDescriptor* addressDesc; // registered ticket returned address
	BalanceUnit amount;
};

// src_blockchain/bc_finalizer_trx/RegisterTicketTransaction.cpp
RegisterTicketTransaction::RegisterTicketTransaction() : AbstractFinalizerTransaction() {
	this->ticketUtxo = new TicketUtxo();
}

// ・・・・・

void RegisterTicketTransaction::setNodeId(const NodeIdentifier *nodeId) noexcept {
	this->ticketUtxo->setNodeIndentifier(nodeId);
}

void RegisterTicketTransaction::setAddressDescriptor(const AddressDescriptor *ticketReturnaddressDesc) noexcept {
	this->ticketUtxo->setAddressDescriptor(ticketReturnaddressDesc);
}

void RegisterTicketTransaction::setAmounst(BalanceUnit amount) noexcept {
	this->ticketUtxo->setAmounst(amount);
}

// src_blockchain/bc_wallet_trx/RegisterTicketTransactionWalletHandler.cpp
RegisterTicketTransaction* RegisterTicketTransactionWalletHandler::createTransaction(const NodeIdentifier *nodeId, const BalanceUnit& stakeAmount,
		const BalanceUnit& feeRate, const AddressDescriptor *ticketReturnaddressDesc, const IWalletDataEncoder *encoder, ITransactionBuilderContext *context) {
	// ・・・・・

	RegisterTicketTransaction* trx = new RegisterTicketTransaction(); __STP(trx);
	trx->setNodeId(nodeId);  // 投票ノードのid
	trx->setAddressDescriptor(ticketReturnaddressDesc);
	trx->setAmounst(stakeAmount);

	trx->build();
	trx->sign(musigProvidor, &utxoFinder);

	// ・・・・・

	return __STP_MV(trx);
}

// src_blockchain/bc/CodablecashSystemParam.cpp
CodablecashSystemParam::CodablecashSystemParam() {
	// ・・・・・
	this->ticketMatureIntervalHeight = 256;
	this->ticketExpireHeight = 20 * 24 * 30 * 3;
	// ・・・・・
}

// src_blockchain/bc_finalizer/TicketVoteSelector.cpp
void TicketVoteSelector::makeList() {
	// ・・・・・
	uint64_t matureHeight = this->height - this->tiketMatureIntervalHeight;  // 今のブロック高 − 256
	// ・・・・・
			const VoteTicket* ticket = entry->nextTicket(matureHeight);  // 成熟期を過ぎたチケットの中から1枚出して
	// ・・・・・
}

// src_blockchain/bc_finalizer/TicketVoteSelector.cpp
void TicketVoteSelector::addList(const VoteTicket *ticket) {
	uint64_t ticketHeight = ticket->getHeight();       // このチケットを買ったブロック高
	uint64_t expire = this->height - ticketHeight;    // 買ってから何ブロックたったか

	if(expire < this->ticketExpireHeight){            // 43,200ブロック未満なら
		this->candidateList->addElement(ticket);      // 通常の候補リストへ
	}
	else{
		this->expiredList->addElement(ticket);        // 超えていたら優先リストへ
	}
}

// src_blockchain/bc_finalizer/TicketVoteSelector.cpp
ByteBuffer* TicketVoteSelector::makebuffer() {
	ByteBuffer* buff = ByteBuffer::allocateWithEndian(sizeof(uint64_t), true); __STP(buff);
	buff->putLong(this->height);   // 「何番目のブロックか」という数字を、8マスの箱に左から詰める。書き終わるとペン先は箱の右端にいる
	buff->position(0);             // ペン先を箱の左端に戻す。次に箱を読む人が最初から読めるように

	// Sha
	ByteBuffer* shabuff = Sha256::sha256(buff, true); __STP(shabuff);
	shabuff->put((char)0);
	shabuff->position(0);

	return __STP_MV(shabuff);
}

// src_blockchain/bc_finalizer/TicketVoteSelector.cpp
void TicketVoteSelector::doSelect() {
	// high priority
	int expCount = this->expiredList->size();
	expCount = expCount >= this->votePerBlock ? this->votePerBlock : expCount;

	// normal priority
	int candidateCount = this->votePerBlock - expCount;
	candidateCount = candidateCount > this->candidateList->size() ? this->candidateList->size() : candidateCount;

	ByteBuffer* shabuff = makebuffer(); __STP(shabuff);   // さきほどの「抽選用の乱数表」を作る

	int count = 0;                                          // 何枚目を選んでいるか。0から始まる
	for(int i = 0; i != expCount; ++i){
		const VoteTicket* ticket = selectFromList(this->expiredList, count, shabuff);   // 長く待たされたチケットから先に選ぶ
		this->selected->addElement(ticket);
		count++;                                            // 1枚選ぶたびに1増える
	}

	for(int i = 0; i != candidateCount; ++i){
		const VoteTicket* ticket = selectFromList(this->candidateList, count, shabuff); // 残りの枠を通常の候補から選ぶ
		this->selected->addElement(ticket);
		count++;
	}

}

// src_blockchain/bc/CodablecashSystemParam.cpp
CodablecashSystemParam::CodablecashSystemParam() {
	// ・・・・・
	this->votePerBlock = 5;
	// ・・・・・
}

// src_blockchain/bc_finalizer/TicketVoteSelector.cpp
const VoteTicket* TicketVoteSelector::selectFromList(ArrayList<const VoteTicket> *list, int count, ByteBuffer* shabuff) {
	uint16_t pos = count % 32;
	pos = shabuff->getShort(pos);   // 乱数表のcountバイト目から2バイトを、数字として読む

	// ・・・・・

	pos = pos % list->size();       // 候補の枚数で割った余り＝「何番目のチケットか」

	return list->remove(pos);       // そのチケットを当選として抜き取る
}

// src_blockchain/bc_finalizer/VoterEntry.cpp
const VoteTicket* VoterEntry::nextTicket(uint64_t matureHeight) noexcept {
	int size = this->list->size();
	size = size >= this->capacity ? this->capacity : size;   // 出せるのはcapacity枚まで

	if(this->pos >= size || this->list->get(this->pos)->getHeight() > matureHeight){
		return nullptr;   // 上限に達した、または次のチケットがまだ成熟していない
	}

	return this->list->get(this->pos++);
}

// src_blockchain/bc_block/BlockHeader.cpp
bool BlockHeader::isFinalizing(int votePerBlock) const noexcept {
	const VotedHeaderIdGroup* group = this->votePart->getMaxVotedGroup();

	return group != nullptr && group->size() == votePerBlock;
}

// src_blockchain/bc_block_generator/BlockRewardCalculator.cpp
void BlockRewardCalculator::calcRewords(uint64_t height, uint16_t zone) noexcept {
	BalanceUnit total = getTotalRewords4Shards(height, zone) + this->fee;

	int totalShare = this->list.size();
	if(this->pow != nullptr){
		totalShare++;
	}

	if(totalShare == 0){
		return;
	}

	BalanceUnit perShare = total / totalShare;
	BalanceUnit remain = total - (perShare * BalanceUnit(totalShare));

	int maxLoop = this->list.size();
	for(int i = 0; i != maxLoop; ++i){
		BlockRewardStakeBase* stake = this->list.get(i);
		stake->setReward(perShare);
	}

	if(this->pow != nullptr){
		BalanceUnit powShare = perShare + remain;
		this->pow->setReward(powShare);
	}

}

// src_blockchain/bc_block_generator/BlockRewardStakeBase.cpp
BalanceUnit BlockRewardStakeBase::calcTicketOwnerBalance(uint64_t ticketVoterFeeBasisPoint) const {
	BalanceUnit voterReword = this->reward * BalanceUnit(ticketVoterFeeBasisPoint) / 10000L;
	BalanceUnit ticketReword = this->reward - voterReword;

	BalanceUnit amount = ticketReword + this->ticketVotedUtxo->getAmount();

	return amount;
}

// src_blockchain/bc/CodablecashSystemParam.cpp
CodablecashSystemParam::CodablecashSystemParam() {
	// ・・・・・

	this->ticketVoterFeeBasisPoint = 50;

	// ・・・・・
}

// src_blockchain/bc_block_generator/BlockGenerator.cpp
void BlockGenerator::addRevokeMissedTicket(・・・・・, VoteCandidate *candidate) {
	RevokeMissedTicket* revokeTrx = new RevokeMissedTicket(); __STP(revokeTrx);

	// ・・・・・

	BalanceUnit ticketPrice = candidate->getTicletPrice();              // ロックしていた額
	const AddressDescriptor* desc = candidate->getAddressDescriptor();   // チケットに書いた返却先

	BalanceUtxo utxo(ticketPrice);
	utxo.setAddress(desc);
	revokeTrx->addBalanceUtxo(&utxo);   // 出力: 同じ額を、返却先宛ての普通の小切手として

	// ・・・・・

	block->addControlTransaction(revokeTrx);   // ブロックに載せる
}

// src_blockchain/bc_finalizer/VoterEntry.cpp
void VoterEntry::handleMissed(int missingLimit) noexcept {
	this->extendCount = 0;

	this->missingCount++;
	if(this->missingCount >= missingLimit){
		this->capacity = this->capacity / 2;
		this->missingCount = 0;
	}

	this->updated = true;
}

// src_blockchain/bc/CodablecashSystemParam.cpp
CodablecashSystemParam::CodablecashSystemParam() {
	// ・・・・・

	this->voteMissingLimit = 2;

	// ・・・・・
}