bookkeeping

type Block struct {
	BlockHeader
	Payset transactions.Payset `codec:"txns"`
}

type BlockHash crypto.Digest

type BlockHeader struct {
	Round basics.Round `codec:"rnd"`

	// The hash of the previous block
	Branch BlockHash `codec:"prev"`

	// Sortition seed
	Seed committee.Seed `codec:"seed"`

	// TxnRoot authenticates the set of transactions appearing in the block.
	// The commitment is computed based on the PaysetCommit type specified
	// in the block's consensus protocol.
	/*
		TxnRoot는 블록에 나타나는 트랜잭션 집합을 인증한다.
	*/
	TxnRoot crypto.Digest `codec:"txn"`

	// TimeStamp in seconds since epoch
	TimeStamp int64 `codec:"ts"`

	// Genesis ID to which this block belongs.
	GenesisID string `codec:"gen"`

	// Genesis hash to which this block belongs.
	/*
		이 블록이 속한 제네시스 해시
	*/
	GenesisHash crypto.Digest `codec:"gh"`

	// Rewards.
	//
	// When a block is applied, some amount of rewards are accrued to
	// every account with AccountData.Status=/=NotParticipating.  The
	// amount is (thisBlock.RewardsLevel-prevBlock.RewardsLevel) of
	// MicroNovas for every whole config.Protocol.RewardUnit of MicroNovas in
	// that account's AccountData.MicroNovas.
	//
	// Rewards are not compounded (i.e., not added to AccountData.MicroNovas)
	// until some other transaction is executed on that account.
	//
	// Not compounding rewards allows us to precisely know how many algos
	// of rewards will be distributed without having to examine every
	// account to determine if it should get one more algo of rewards
	// because compounding formed another whole config.Protocol.RewardUnit
	// of algos.
	/*
		블록이 적용되면 AccountData.Status가 NotParticipating가 아닌 계정들에게 보상이 적립된다.
		보상은 이 계정에서 다른 트랜잭션이 실행되기 전까지 내 자산으로 들어오지 않는다.
	*/
	RewardsState

	// Consensus protocol versioning.
	//
	// Each block is associated with a version of the consensus protocol,
	// stored under UpgradeState.CurrentProtocol.  The protocol version
	// for a block can be determined without having to first decode the
	// block and its CurrentProtocol field, and this field is present for
	// convenience and explicitness.  Block.Valid() checks that this field
	// correctly matches the expected protocol version.
	//
	// Each block is associated with at most one active upgrade proposal
	// (a new version of the protocol).  An upgrade proposal can be made
	// by a block proposer, as long as no other upgrade proposal is active.
	// The upgrade proposal lasts for many rounds (UpgradeVoteRounds), and
	// in each round, that round's block proposer votes to support (or not)
	// the proposed upgrade.
	//
	// If enough votes are collected, the proposal is approved, and will
	// definitely take effect.  The proposal lingers for some number of
	// rounds to give clients a chance to notify users about an approved
	// upgrade, if the client doesn't support it, so the user has a chance
	// to download updated client software.
	//
	// Block proposers influence this upgrade machinery through two fields
	// in UpgradeVote: UpgradePropose, which proposes an upgrade to a new
	// protocol, and UpgradeApprove, which signals approval of the current
	// proposal.
	//
	// Once a block proposer determines its UpgradeVote, then UpdateState
	// is updated deterministically based on the previous UpdateState and
	// the new block's UpgradeVote.
	UpgradeState
	UpgradeVote

	// TxnCounter counts the number of transactions committed in the
	// ledger, from the time at which support for this feature was
	// introduced.
	//
	// Specifically, TxnCounter is the number of the next transaction
	// that will be committed after this block.  It is 0 when no
	// transactions have ever been committed (since TxnCounter
	// started being supported).
	TxnCounter uint64 `codec:"tc"`

	// CompactCert tracks the state of compact certs, potentially
	// for multiple types of certs.
	//msgp:sort protocol.CompactCertType protocol.SortCompactCertTy
	/*
		CompactCert는 잠재적으로 여러 유형의 인증서에 대한 컴팩트 인증서의 상태를 추적.
	*/
	CompactCert map[protocol.CompactCertType]CompactCertState `codec:"cc,allocbound=protocol.NumCompactCertTypes"`

	// ParticipationUpdates contains the information needed to mark
	// certain accounts offline because their participation keys expired
	ParticipationUpdates
	// contains filtered or unexported fields
}

type CompactCertState struct {

	// CompactCertVoters is the root of a Merkle tree containing the
	// online accounts that will help sign a compact certificate.  The
	// Merkle root, and the compact certificate, happen on blocks that
	// are a multiple of ConsensusParams.CompactCertRounds.  For blocks
	// that are not a multiple of ConsensusParams.CompactCertRounds,
	// this value is zero.
	CompactCertVoters crypto.GenericDigest `codec:"v"`

	// CompactCertVotersTotal is the total number of micronovas held by
	// the accounts in CompactCertVoters (or zero, if the merkle root is
	// zero).  This is intended for computing the threshold of votes to
	// expect from CompactCertVoters.
	CompactCertVotersTotal basics.MicroNovas `codec:"t"`

	// CompactCertNextRound is the next round for which we will accept
	// a CompactCert transaction.
	CompactCertNextRound basics.Round `codec:"n"`
	// contains filtered or unexported fields
}

type Genesis struct {

	// The SchemaID allows nodes to store data specific to a particular
	// universe (in case of upgrades at development or testing time),
	// and as an optimization to quickly check if two nodes are in
	// the same universe.
	SchemaID string `codec:"id"`

	// Network identifies the unique algorand network for which the ledger
	// is valid.
	// Note the Network name should not include a '-', as we generate the
	// GenesisID from "<Network>-<SchemaID>"; the '-' makes it easy
	// to distinguish between the network and schema.
	Network protocol.NetworkID `codec:"network"`

	// Proto is the consensus protocol in use at the genesis block.
	Proto protocol.ConsensusVersion `codec:"proto"`

	// Allocation determines the initial accounts and their state.
	Allocation []GenesisAllocation `codec:"alloc,allocbound=MaxInitialGenesisAllocationSize"`

	// RewardsPool is the address of the rewards pool.
	RewardsPool string `codec:"rwd"`

	// FeeSink is the address of the fee sink.
	FeeSink string `codec:"fees"`

	// Timestamp for the genesis block
	Timestamp int64 `codec:"timestamp"`

	// Arbitrary genesis comment string - will be excluded from file if empty
	Comment string `codec:"comment"`

	// DevMode defines whether this network operates in a developer mode or not. Developer mode networks
	// are a single node network, that operates without the agreement service being active. In liue of the
	// agreement service, a new block is generated each time a node receives a transaction group. The
	// default value for this field is "false", which makes this field empty from it's encoding, and
	// therefore backward compatible.
	DevMode bool `codec:"devmode"`
	// contains filtered or unexported fields
}

type GenesisAllocation struct {
	Address string             `codec:"addr"`
	Comment string             `codec:"comment"`
	State   basics.AccountData `codec:"state"`
	// contains filtered or unexported fields
}

type GenesisBalances struct {
	Balances    map[basics.Address]basics.AccountData
	FeeSink     basics.Address
	RewardsPool basics.Address
	Timestamp   int64
}

type ParticipationUpdates struct {

	// ExpiredParticipationAccounts contains a list of online accounts
	// that needs to be converted to offline since their
	// participation key expired.
	ExpiredParticipationAccounts []basics.Address `codec:"partupdrmv,allocbound=config.MaxProposedExpiredOnlineAccounts"`
	// contains filtered or unexported fields
}

type RewardsState struct {

	// The FeeSink accepts transaction fees. It can only spend to
	// the incentive pool.
	FeeSink basics.Address `codec:"fees"`

	// The RewardsPool accepts periodic injections from the
	// FeeSink and continually redistributes them to adresses as
	// rewards.
	RewardsPool basics.Address `codec:"rwd"`

	// RewardsLevel specifies how many rewards, in MicroNovas,
	// have been distributed to each config.Protocol.RewardUnit
	// of MicroNovas since genesis.
	/*

	 */
	RewardsLevel uint64 `codec:"earn"`

	// The number of new MicroNovas added to the participation stake from rewards at the next round.
	RewardsRate uint64 `codec:"rate"`

	// The number of leftover MicroNovas after the distribution of RewardsRate/rewardUnits
	// MicroNovas for every reward unit in the next round.
	RewardsResidue uint64 `codec:"frac"`

	// The round at which the RewardsRate will be recalculated.
	RewardsRecalculationRound basics.Round `codec:"rwcalr"`
	// contains filtered or unexported fields
}

type UpgradeState struct {
	CurrentProtocol       protocol.ConsensusVersion `codec:"proto"`
	NextProtocol          protocol.ConsensusVersion `codec:"nextproto"`
	NextProtocolApprovals uint64                    `codec:"nextyes"`
	// NextProtocolVoteBefore specify the last voting round for the next protocol proposal. If there is no voting for
	// an upgrade taking place, this would be zero.
	NextProtocolVoteBefore basics.Round `codec:"nextbefore"`
	// NextProtocolSwitchOn specify the round number at which the next protocol would be adopted. If there is no upgrade taking place,
	// nor a wait for the next protocol, this would be zero.
	NextProtocolSwitchOn basics.Round `codec:"nextswitch"`
}

type UpgradeVote struct {

	// UpgradePropose indicates a proposed upgrade
	UpgradePropose protocol.ConsensusVersion `codec:"upgradeprop"`

	// UpgradeDelay indicates the time between acceptance and execution
	UpgradeDelay basics.Round `codec:"upgradedelay"`

	// UpgradeApprove indicates a yes vote for the current proposal
	UpgradeApprove bool `codec:"upgradeyes"`
	// contains filtered or unexported fields
}