ChainMaker.go

package service

import (
	"fmt"
	"log"
	"os"
	"os/exec"
	"sort"
	"strings"
	"time"

	"saseul/config"
	"saseul/data/bunch"
	"saseul/data/chain"
	"saseul/data/env"
	"saseul/data/mainchain"
	"saseul/data/tracker"
	"saseul/datasource/poolclient"
	"saseul/model"
	"saseul/staff/observer"
	"saseul/staff/processmanager"
	"saseul/util/clock"
	"saseul/vm/machine"
)

type ChainMaker struct {
	Description string
	Iterate     int
}

// NewChainMaker 함수는 ChainMaker의 인스턴스를 생성하고 초기화합니다.
func NewChainMaker() *ChainMaker {
	cm := &ChainMaker{
		Description: "ChainMaker service",
		Iterate:     100000,
	}

	// 환경이 "process"인 경우, 체인 메이커 프로세스가 이미 실행 중인지 확인하고 실행 중이면 종료합니다.
	if config.Environment == "process" {
		if processmanager.IsRunning(processmanager.CHAIN_MAKER) {
			log.Println("The chain maker process is already running.")
			os.Exit(1)
		}
		processmanager.Save(processmanager.CHAIN_MAKER)
	}

	// Pool 클라이언트를 "rewind" 모드로 설정합니다.
	poolclient.Instance().SetMode("rewind")

	return cm
}

// Main 함수는 ChainMaker의 메인 작업을 수행합니다.
func (cm *ChainMaker) Main() {
	defer func() {
		if processmanager.PID(processmanager.CHAIN_MAKER) == os.Getpid() {
			log.Println("Chain maker process has been successfully removed.")
			processmanager.Delete(processmanager.CHAIN_MAKER)
		}
	}()

	cm.Init()
	for i := 0; i < cm.Iterate; i++ {
		cm.Operation()
		time.Sleep(1 * time.Second) // 필요한 경우 조정
	}
}

// Init 함수는 ChainMaker를 초기화합니다.
func (cm *ChainMaker) Init() {
	log.Println("The chain maker process has started.")
}

// Operation 함수는 ChainMaker의 주요 작업을 수행합니다.
func (cm *ChainMaker) Operation() {
	lastBlock := mainchain.Instance().LastBlock()
	cm.Refresh(lastBlock)

	var errMsg string
	sync := cm.Sync(lastBlock, &errMsg)
	if !sync {
		cm.Consensus(lastBlock, &errMsg)
	}
}

// Refresh 함수는 최신 블록에 따라 데이터를 정리합니다.
func (cm *ChainMaker) Refresh(lastBlock *model.MainBlock) {
	bunch.Clean(lastBlock)

	info := bunch.InfoTxs()
	count := info["count"].(int)
	size := info["size"].(int)

	countLimit := config.BLOCK_TX_COUNT_LIMIT * 2
	sizeLimit := config.BLOCK_TX_SIZE_LIMIT * 2

	if count > countLimit || size > sizeLimit {
		poolclient.Instance().FlushTxs()
	}
}

// Sync 함수는 블록 동기화를 수행합니다.
func (cm *ChainMaker) Sync(lastBlock *model.MainBlock, errMsg *string) bool {
	peers := tracker.GetPeers()
	hosts := cm.Hosts(peers)
	syncHosts := cm.SyncHosts(hosts)

	hosts = syncHosts["hosts"].([]string)
	longest := syncHosts["longest"].(map[string]interface{})

	decisions := observer.Instance().SeeBlocks(hosts, lastBlock.Height+1)

	var pull bool
	for _, decision := range decisions {
		if !pull {
			blocks := decision["blocks"].([]interface{})
			isLongest := decision["host"] == longest["host"]

			if cm.Pull(blocks, isLongest, errMsg) {
				pull = true
			}
		}
	}

	return pull
}

// Hosts 함수는 피어 목록에서 호스트 목록을 추출합니다.
func (cm *ChainMaker) Hosts(peers []map[string]interface{}) []string {
	hosts := make([]string, len(peers))
	for i, peer := range peers {
		hosts[i] = peer["host"].(string)
	}
	return hosts
}

// SyncHosts 함수는 동기화할 호스트를 결정합니다.
func (cm *ChainMaker) SyncHosts(hosts []string) map[string]interface{} {
	height := max(chain.FixedHeight(), 1)
	rounds := observer.Instance().SeeMiningRounds(hosts, height)

	var longest map[string]interface{}
	var maxSyncLimit int
	var maxHash string
	var syncHosts []string

	for hash, cases := range rounds {
		for _, round := range cases {
			syncLimit := round["sync_limit"].(int)
			if syncLimit > maxSyncLimit {
				longest = round
				maxSyncLimit = syncLimit
				maxHash = hash
			}
		}
	}

	if longestHost, ok := longest["host"]; ok {
		syncHosts = append(syncHosts, longestHost.(string))
	}

	for hash, cases := range rounds {
		sort.SliceStable(cases, func(i, j int) bool {
			if cases[i]["sync_limit"].(int) == cases[j]["sync_limit"].(int) {
				return cases[i]["exec_time"].(int) < cases[j]["exec_time"].(int)
			}
			return cases[i]["sync_limit"].(int) > cases[j]["sync_limit"].(int)
		})

		syncHosts = append(syncHosts, cases[0]["host"].(string))
		if len(cases) > 1 {
			if hash == maxHash {
				for i := 0; i < 3; i++ {
					j := randInt(1, len(cases)-1)
					syncHosts = append(syncHosts, cases[j]["host"].(string))
				}
			} else {
				j := randInt(1, len(cases)-1)
				syncHosts = append(syncHosts, cases[j]["host"].(string))
			}
		}
	}

	return map[string]interface{}{
		"longest": longest,
		"hosts":   uniqueStrings(syncHosts),
	}
}

// Pull 함수는 블록 데이터를 가져와 추가합니다.
func (cm *ChainMaker) Pull(blocks []interface{}, isLongest bool, errMsg *string) bool {
	var result bool
	for _, blockData := range blocks {
		block := model.NewMainBlock(blockData.(map[string]interface{}))
		if !cm.Append(block, isLongest, errMsg) {
			break
		}
		result = true
	}
	return result
}

// Append 함수는 블록을 추가합니다.
func (cm *ChainMaker) Append(block *model.MainBlock, isLongest bool, errMsg *string) bool {
	machine := machine.Instance()
	lastBlock := mainchain.Instance().LastBlock()
	confirmedHeight := chain.ConfirmedHeight(block.STimestamp)
	confirmedHeight = hardfork.ConfirmedHeight(block, confirmedHeight)
	validators := chain.SelectValidators(confirmedHeight)

	if block.Height != lastBlock.Height+1 || len(validators) == 0 {
		*errMsg = "Waiting for resource blocks.. "
		poolclient.Instance().SetPolicy("main_chain_waiting", false)
		return true
	}

	block.Validators = validators
	machine.Init(lastBlock, block.STimestamp)
	machine.SetTransactions(block.Transactions)
	machine.PreLoad(block.UniversalUpdates, block.LocalUpdates)
	machine.PreCommit(confirmedHeight, errMsg)

	expectedBlock := machine.ExpectedBlock()

	validity := block.Validity() && (hardfork.MainCondition(block) || len(machine.Transactions) > 0) &&
		block.Blockhash == expectedBlock.Blockhash
	continuity := block.Height == lastBlock.Height+1 &&
		block.PreviousBlockhash == lastBlock.Blockhash &&
		block.STimestamp >= lastBlock.STimestamp+config.MAIN_CHAIN_INTERVAL

	if validity && continuity {
		poolclient.Instance().SetPolicy("main_chain_waiting", false)
		machine.Commit(block)
		return true
	} else if !continuity && isLongest {
		*errMsg = "Main chain fork."
		log.Println(*errMsg)
		poolclient.Instance().SetPolicy("main_chain_waiting", true)
		return false
	}

	*errMsg = "Blockhash is different."
	log.Println(*errMsg)
	return false
}

// Consensus 함수는 합의 작업을 수행합니다.
func (cm *ChainMaker) Consensus(lastBlock *model.MainBlock, errMsg *string) {
	roundKey := lastBlock.Blockhash
	chunks := bunch.ListChunk(roundKey)

	now := clock.UFloorTime()
	min := max(now-config.REFRESH_INTERVAL, lastBlock.STimestamp)
	roundTimestamp := now
	refresh := false

	if len(chunks) > 0 {
		roundTimestamp = maxInt(chunksTimes(chunks))
		if roundTimestamp < min {
			refresh = true
			roundTimestamp = now
		}
	}

	transactions := bunch.ListTx(roundTimestamp)
	if len(transactions) == 0 {
		return
	}

	confirmedHeight := chain.ConfirmedHeight(roundTimestamp)
	validators := chain.SelectValidators(confirmedHeight)
	main := validators[8]
	address := env.Node().Address()

	if !contains(validators, address) || lastBlock.STimestamp >= roundTimestamp {
		return
	}

	validChunks := filterChunks(chunks, validators)
	machine := machine.Instance()

	machine.Init(lastBlock, roundTimestamp)
	machine.SetTransactions(transactions)
	machine.PreCommit(confirmedHeight, errMsg)

	chunk := machine.Chunk()
	chunkHashes := getChunkHashes(validChunks)
	chunkHashes[address] = chunk.ChunkHash

	hypothesis := machine.Hypothesis(chunkHashes)
	expectedBlock := machine.ExpectedBlock()
	expectedBlock.Validators = validators

	if !hardfork.MainCondition(expectedBlock) && machine.TransactionCount() == 0 {
		return
	}

	if refresh || !chunkExists(validChunks, address) {
		bunch.AddChunk(chunk)
	}

	if address == main {
		bunch.AddHypothesis(hypothesis)
		hypotheses := bunch.ListHypothesis(lastBlock.Blockhash)
		cm.commitExpectedBlock(expectedBlock, hypotheses, lastBlock, validators)
	} else {
		if !cm.Votes(validators, getChunkKeys(validChunks)) {
			return
		}
		bunch.AddHypothesis(hypothesis)
		hypotheses := bunch.ListHypothesis(lastBlock.Blockhash)
		if !cm.Votes(validators, getHypothesisKeys(hypotheses)) {
			return
		}
	}
}

// commitExpectedBlock 함수는 예상 블록을 커밋합니다.
func (cm *ChainMaker) commitExpectedBlock(expectedBlock *model.MainBlock, hypotheses []map[string]interface{}, lastBlock *model.MainBlock, validators []string) {
	expectedBlock = cm.Seal(expectedBlock, hypotheses)
	validity := expectedBlock.Validity() &&
		expectedBlock.Height == lastBlock.Height+1 &&
		(hardfork.MainCondition(expectedBlock) || len(expectedBlock.Transactions) > 0)

	continuity := expectedBlock.PreviousBlockhash == lastBlock.Blockhash &&
		expectedBlock.STimestamp >= lastBlock.STimestamp+config.MAIN_CHAIN_INTERVAL

	if validity && continuity {
		machine.Instance().Commit(expectedBlock)
	}
}

// Seal 함수는 예상 블록을 봉인합니다.
func (cm *ChainMaker) Seal(expectedBlock *model.MainBlock, hypotheses []map[string]interface{}) *model.MainBlock {
	sealedSTimestamp := maxInt(hypothesesTimes(hypotheses))
	sealedHypotheses := sealHypotheses(hypotheses)

	expectedBlock.Seal = sealedHypotheses
	expectedBlock.STimestamp = sealedSTimestamp

	return expectedBlock
}

// Votes 함수는 투표를 집계합니다.
func (cm *ChainMaker) Votes(validators, datas []string) bool {
	quorum := len(validators) * config.MAIN_CONSENSUS_PER
	votesCast := countVotes(validators, datas)

	return votesCast > quorum
}

// 부가 함수들

// contains 함수는 슬라이스에 항목이 포함되어 있는지 확인합니다.
func contains(slice []string, item string) bool {
	for _, s := range slice {
		if s == item {
			return true
		}
	}
	return false
}

// uniqueStrings 함수는 슬라이스에서 고유한 문자열을 반환합니다.
func uniqueStrings(input []string) []string {
	unique := make(map[string]struct{}, len(input))
	for _, str := range input {
		unique[str] = struct{}{}
	}

	output := make([]string, 0, len(unique))
	for str := range unique {
		output = append(output, str)
	}

	return output
}

// max 함수는 두 정수 중 더 큰 값을 반환합니다.
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// maxInt 함수는 정수 슬라이스에서 가장 큰 값을 반환합니다.
func maxInt(ints []int) int {
	if len(ints) == 0 {
		return 0
	}
	max := ints[0]
	for _, v := range ints {
		if v > max {
			max = v
		}
	}
	return max
}

// randInt 함수는 주어진 범위 내에서 무작위 정수를 반환합니다.
func randInt(min, max int) int {
	return min + int(rand.Int31n(int32(max-min+1)))
}

// chunksTimes 함수는 청크의 타임스탬프를 반환합니다.
func chunksTimes(chunks []map[string]interface{}) []int {
	times := make([]int, len(chunks))
	for i, chunk := range chunks {
		times[i] = chunk["s_timestamp"].(int)
	}
	return times
}

// getChunkHashes 함수는 청크의 해시를 반환합니다.
func getChunkHashes(chunks map[string]map[string]interface{}) map[string]string {
	hashes := make(map[string]string, len(chunks))
	for key, chunk := range chunks {
		hashes[key] = chunk["chunk_hash"].(string)
	}
	return hashes
}

// getChunkKeys 함수는 청크의 키를 반환합니다.
func getChunkKeys(chunks map[string]map[string]interface{}) []string {
	keys := make([]string, 0, len(chunks))
	for key := range chunks {
		keys = append(keys, key)
	}
	return keys
}

// chunkExists 함수는 청크가 존재하는지 확인합니다.
func chunkExists(chunks map[string]map[string]interface{}, address string) bool {
	_, exists := chunks[address]
	return exists
}

// filterChunks 함수는 검증자 목록에 따라 유효한 청크를 필터링합니다.
func filterChunks(chunks []map[string]interface{}, validators []string) map[string]map[string]interface{} {
	validChunks := make(map[string]map[string]interface{})
	for _, chunk := range chunks {
		signer := chunk["signer"].(string)
		if contains(validators, signer) {
			validChunks[signer] = chunk
		}
	}
	return validChunks
}

// hypothesesTimes 함수는 가설의 타임스탬프를 반환합니다.
func hypothesesTimes(hypotheses []map[string]interface{}) []int {
	times := make([]int, len(hypotheses))
	for i, hypothesis := range hypotheses {
		times[i] = hypothesis["s_timestamp"].(int)
	}
	return times
}

// getHypothesisKeys 함수는 가설의 키를 반환합니다.
func getHypothesisKeys(hypotheses map[string]map[string]interface{}) []string {
	keys := make([]string, 0, len(hypotheses))
	for key := range hypotheses {
		keys = append(keys, key)
	}
	return keys
}

// sealHypotheses 함수는 가설을 봉인합니다.
func sealHypotheses(hypotheses []map[string]interface{}) []map[string]interface{} {
	sealed := make([]map[string]interface{}, len(hypotheses))
	for i, hypothesis := range hypotheses {
		h := model.NewHypothesis(hypothesis)
		sealed[i] = h.Seal()
	}
	return sealed
}

// countVotes 함수는 투표 수를 집계합니다.
func countVotes(validators, datas []string) int {
	votes := 0
	for _, validator := range validators {
		if contains(datas, validator) {
			votes++
		}
	}
	return votes
}

// main 함수는 ChainMaker의 인스턴스를 생성하고 메인 작업을 수행합니다.
func main() {
	cm := NewChainMaker()
	cm.Main()
}

이 코드는 ChainMaker라는 구조체와 그와 관련된 메서드를 정의하여 블록체인 네트워크에서 체인 생성을 관리하는 기능을 제공합니다. 각 함수와 메서드에 대해 하나하나 설명하겠습니다.

패키지 선언 및 임포트

package service

import (
	"fmt"
	"log"
	"os"
	"os/exec"
	"sort"
	"strings"
	"time"

	"saseul/config"
	"saseul/data/bunch"
	"saseul/data/chain"
	"saseul/data/env"
	"saseul/data/mainchain"
	"saseul/data/tracker"
	"saseul/datasource/poolclient"
	"saseul/model"
	"saseul/staff/observer"
	"saseul/staff/processmanager"
	"saseul/util/clock"
	"saseul/vm/machine"
)

• package service: 이 파일이 service 패키지에 속함을 나타냅니다.

• import (...): 이 스크립트에서 사용될 외부 패키지들을 가져옵니다.

ChainMaker 구조체와 생성자 함수

type ChainMaker struct {
	Description string
	Iterate     int
}

func NewChainMaker() *ChainMaker {
	cm := &ChainMaker{
		Description: "ChainMaker service",
		Iterate:     100000,
	}
	
	if config.Environment == "process" {
		if processmanager.IsRunning(processmanager.CHAIN_MAKER) {
			log.Println("The chain maker process is already running.")
			os.Exit(1)
		}
		processmanager.Save(processmanager.CHAIN_MAKER)
	}

	poolclient.Instance().SetMode("rewind")

	return cm
}

• type ChainMaker struct { ... }: ChainMaker 구조체는 체인 생성을 관리하는 작업에 대한 설명과 반복 횟수를 담는 필드를 가집니다.

• func NewChainMaker() *ChainMaker { ... }: NewChainMaker 함수는 ChainMaker 구조체의 새 인스턴스를 생성하여 반환합니다. 여기서 Description 필드는 "ChainMaker service"로 설정되고, Iterate는 100000으로 설정됩니다.

Main 함수

func (cm *ChainMaker) Main() {
	defer func() {
		if processmanager.PID(processmanager.CHAIN_MAKER) == os.Getpid() {
			log.Println("Chain maker process has been successfully removed.")
			processmanager.Delete(processmanager.CHAIN_MAKER)
		}
	}()

	cm.Init()
	for i := 0; i < cm.Iterate; i++ {
		cm.Operation()
		time.Sleep(1 * time.Second) // Adjust as needed
	}
}

• func (cm *ChainMaker) Main() { ... }: ChainMaker 구조체의 Main 메서드는 체인 생성을 관리하는 주요 작업을 수행합니다.

  • defer func() { ... }: Main 함수가 종료될 때 실행될 코드를 정의합니다. 여기서는 프로세스가 현재 PID와 일치하면 프로세스를 삭제합니다.

  • cm.Init(): 체인 메이커 프로세스를 초기화합니다.

  • for i := 0; i < cm.Iterate; i++ { ... }: 반복 횟수만큼 Operation 메서드를 호출합니다.

    • cm.Operation(): 체인 생성 작업을 수행합니다.

    • time.Sleep(1 * time.Second): 1초 동안 대기합니다.

Init 함수

func (cm *ChainMaker) Init() {
	log.Println("The chain maker process has started.")
}

• func (cm *ChainMaker) Init() { ... }: ChainMaker 구조체의 Init 메서드는 체인 메이커 프로세스가 시작되었음을 로그로 출력합니다.

Operation 함수

func (cm *ChainMaker) Operation() {
	lastBlock := mainchain.Instance().LastBlock()
	cm.Refresh(lastBlock)

	var errMsg string
	sync := cm.Sync(lastBlock, &errMsg)
	if !sync {
		cm.Consensus(lastBlock, &errMsg)
	}
}

• func (cm *ChainMaker) Operation() { ... }: ChainMaker 구조체의 Operation 메서드는 체인 생성 작업을 수행합니다.

  • lastBlock := mainchain.Instance().LastBlock(): 마지막 블록을 가져옵니다.

  • cm.Refresh(lastBlock): 마지막 블록을 기준으로 상태를 갱신합니다.

  • var errMsg string: 오류 메시지를 저장할 변수를 선언합니다.

  • sync := cm.Sync(lastBlock, &errMsg): 동기화를 시도합니다. 성공 여부에 따라 sync가 결정됩니다.

  • if !sync { cm.Consensus(lastBlock, &errMsg) }: 동기화가 실패하면 합의 작업을 수행합니다.

Refresh 함수

func (cm *ChainMaker) Refresh(lastBlock *model.MainBlock) {
	bunch.Clean(lastBlock)

	info := bunch.InfoTxs()
	count := info["count"].(int)
	size := info["size"].(int)

	countLimit := config.BLOCK_TX_COUNT_LIMIT * 2
	sizeLimit := config.BLOCK_TX_SIZE_LIMIT * 2

	if count > countLimit || size > sizeLimit {
		poolclient.Instance().FlushTxs()
	}
}

• func (cm *ChainMaker) Refresh(lastBlock *model.MainBlock) { ... }: ChainMaker 구조체의 Refresh 메서드는 마지막 블록을 기준으로 상태를 갱신합니다.

  • bunch.Clean(lastBlock): 마지막 블록을 기준으로 청소 작업을 수행합니다.

  • info := bunch.InfoTxs(): 트랜잭션 정보를 가져옵니다.

  • count := info["count"].(int): 트랜잭션 수를 가져옵니다.

  • size := info["size"].(int): 트랜잭션 크기를 가져옵니다.

  • countLimit := config.BLOCK_TX_COUNT_LIMIT * 2: 트랜잭션 수 제한을 설정합니다.

  • sizeLimit := config.BLOCK_TX_SIZE_LIMIT * 2: 트랜잭션 크기 제한을 설정합니다.

  • if count > countLimit || size > sizeLimit { poolclient.Instance().FlushTxs() }: 제한을 초과하면 트랜잭션을 플러시합니다.

Sync 함수

func (cm *ChainMaker) Sync(lastBlock *model.MainBlock, errMsg *string) bool {
	peers := tracker.GetPeers()
	hosts := cm.Hosts(peers)
	syncHosts := cm.SyncHosts(hosts)

	hosts = syncHosts["hosts"].([]string)
	longest := syncHosts["longest"].(map[string]interface{})

	decisions := observer.Instance().SeeBlocks(hosts, lastBlock.Height+1)

	var pull bool
	for _, decision := range decisions {
		if !pull {
			blocks := decision["blocks"].([]interface{})
			isLongest := decision["host"] == longest["host"]

			if cm.Pull(blocks, isLongest, errMsg) {
				pull = true
			}
		}
	}

	return pull
}

• func (cm *ChainMaker) Sync(lastBlock *model.MainBlock, errMsg *string) bool { ... }: ChainMaker 구조체의 Sync 메서드는 동기화를 시도합니다.

  • peers := tracker.GetPeers(): 피어 정보를 가져옵니다.

  • hosts := cm.Hosts(peers): 호스트 정보를 가져옵니다.

  • syncHosts := cm.SyncHosts(hosts): 동기화할 호스트를 가져옵니다.

  • hosts = syncHosts["hosts"].([]string): 동기화할 호스트 목록을 가져옵니다.

  • longest := syncHosts["longest"].(map[string]interface{}): 가장 긴 호스트 정보를 가져옵니다.

  • decisions := observer.Instance().SeeBlocks(hosts, lastBlock.Height+1): 블록을 확인합니다.

  • var pull bool: 동기화 여부를 저장할 변수를 선언합니다.

  • for _, decision := range decisions { ... }: 결정 목록을 순회합니다.

    • if !pull { ... }: 아직 동기화되지 않은 경우.

      • blocks := decision["blocks"].([]interface{}): 블록 정보를 가져옵니다.

      • isLongest := decision["host"] == longest["host"]: 가장 긴 호스트인지 확인합니다.

      • if cm.Pull(blocks, isLongest, errMsg) { pull = true }: 블록을 가져오고 동기화 여부를 업데이트합니다.

  • return pull: 동기화 여부를 반환합니다.

Hosts 함수

func (cm *ChainMaker) Hosts(peers []map[string]interface{}) []string {
	hosts := make([]string, len(peers))
	for i, peer := range peers {
		hosts[i] = peer["host"].(string)
	}
	return hosts
}

• func (cm *ChainMaker) Hosts(peers []map[string]interface{}) []string { ... }: ChainMaker 구조체의 Hosts 메서드는 피어 목록에서 호스트 목록을 추출합니다.

  • hosts := make([]string, len(peers)): 호스트 목록을 저장할 슬라이스를 생성합니다.

  • for i, peer := range peers { ... }: 피어 목록을 순회합니다.

    • hosts[i] = peer["host"].(string): 호스트 정보를 추출하여 저장합니다.

  • return hosts: 호스트 목록을 반환합니다.

SyncHosts 함수

func (cm *ChainMaker) SyncHosts(hosts []string) map[string]interface{} {
	height := max(chain.FixedHeight(), 1)
	rounds := observer.Instance().SeeMiningRounds(hosts, height)

	var longest map[string]interface{}
	var maxSyncLimit int
	var maxHash string
	var syncHosts []string

	for hash, cases := range rounds {
		for _, round := range cases {
			syncLimit := round["sync_limit"].(int)
			if syncLimit > maxSyncLimit {
				longest = round
				maxSyncLimit = syncLimit
				maxHash = hash
			}
		}
	}

	if longestHost, ok := longest["host"]; ok {
		syncHosts = append(syncHosts, longestHost.(string))
	}

	for hash, cases := range rounds {
		sort.SliceStable(cases, func(i, j int) bool {
			if cases[i]["sync_limit"].(int) == cases[j]["sync_limit"].(int) {
				return cases[i]["exec_time"].(int) < cases[j]["exec_time"].(int)
			}
			return cases[i]["sync_limit"].(int) > cases[j]["sync_limit"].(int)
		})

		syncHosts = append(syncHosts, cases[0]["host"].(string))
		if len(cases) > 1 {
			if hash == maxHash {
				for i := 0; i < 3; i++ {
					j := randInt(1, len(cases)-1)
					syncHosts = append(syncHosts, cases[j]["host"].(string))
				}
			} else {
				j := randInt(1, len(cases)-1)
				syncHosts = append(syncHosts, cases[j]["host"].(string))
			}
		}
	}

	return map[string]interface{}{
		"longest": longest,
		"hosts":   uniqueStrings(syncHosts),
	}
}

• func (cm *ChainMaker) SyncHosts(hosts []string) map[string]interface{} { ... }: ChainMaker 구조체의 SyncHosts 메서드는 동기화할 호스트 정보를 결정합니다.

  • height := max(chain.FixedHeight(), 1): 현재 고정된 높이를 가져오고 최소 값을 1로 설정합니다.

  • rounds := observer.Instance().SeeMiningRounds(hosts, height): 호스트들의 마이닝 라운드 정보를 가져옵니다.

  • var longest map[string]interface{}; var maxSyncLimit int; var maxHash string; var syncHosts []string: 다양한 변수를 선언합니다.

  • for hash, cases := range rounds { ... }: 라운드 정보를 순회합니다.

    • for _, round := range cases { ... }: 각 라운드의 케이스를 순회합니다.

      • syncLimit := round["sync_limit"].(int): 동기화 제한을 가져옵니다.

      • if syncLimit > maxSyncLimit { ... }: 최대 동기화 제한을 업데이트합니다.

  • if longestHost, ok := longest["host"]; ok { syncHosts = append(syncHosts, longestHost.(string)) }: 가장 긴 호스트 정보를 추가합니다.

  • for hash, cases := range rounds { ... }: 라운드 정보를 다시 순회합니다.

    • sort.SliceStable(cases, func(i, j int) bool { ... }): 케이스를 정렬합니다.

    • syncHosts = append(syncHosts, cases[0]["host"].(string)): 동기화 호스트를 추가합니다.

    • if len(cases) > 1 { ... }: 케이스가 여러 개인 경우 추가로 동기화 호스트를 추가합니다.

  • return map[string]interface{}{ ... }: 동기화할 호스트 정보를 반환합니다.

Pull 함수

func (cm *ChainMaker) Pull(blocks []interface{}, isLongest bool, errMsg *string) bool {
	var result bool
	for _, blockData := range blocks {
		block := model.NewMainBlock(blockData.(map[string]interface{}))
		if !cm.Append(block, isLongest, errMsg) {
			break
		}
		result = true
	}
	return result
}

• func (cm *ChainMaker) Pull(blocks []interface{}, isLongest bool, errMsg *string) bool { ... }: ChainMaker 구조체의 Pull 메서드는 블록을 가져와서 추가합니다.

  • var result bool: 결과를 저장할 변수를 선언합니다.

  • for _, blockData := range blocks { ... }: 블록 데이터를 순회합니다.

    • block := model.NewMainBlock(blockData.(map[string]interface{})): 블록 데이터를 새로운 블록으로 변환합니다.

    • if !cm.Append(block, isLongest, errMsg) { break }: 블록을 추가하고 실패하면 중지합니다.

    • result = true: 결과를 업데이트합니다.

  • return result: 결과를 반환합니다.

Append 함수

func (cm *ChainMaker) Append(block *model.MainBlock, isLongest bool, errMsg *string) bool {
	machine := machine.Instance()
	lastBlock := mainchain.Instance().LastBlock()
	confirmedHeight := chain.ConfirmedHeight(block.STimestamp)
	confirmedHeight = hardfork.ConfirmedHeight(block, confirmedHeight)
	validators := chain.SelectValidators(confirmedHeight)

	if block.Height != lastBlock.Height+1 || len(validators) == 0 {
		*errMsg = "Waiting for resource blocks.. "
		poolclient.Instance().SetPolicy("main_chain_waiting", false)
		return true
	}

	block.Validators = validators
	machine.Init(lastBlock, block.STimestamp)
	machine.SetTransactions(block.Transactions)
	machine.PreLoad(block.UniversalUpdates, block.LocalUpdates)
	machine.PreCommit(confirmedHeight, errMsg)

	expectedBlock := machine.ExpectedBlock()

	validity := block.Validity() && (hardfork.MainCondition(block) || len(machine.Transactions) > 0) &&
		block.Blockhash == expectedBlock.Blockhash
	continuity := block.Height == lastBlock.Height+1 &&
		block.PreviousBlockhash == lastBlock.Blockhash &&
		block.STimestamp >= lastBlock.STimestamp+config.MAIN_CHAIN_INTERVAL

	if validity && continuity {
		poolclient.Instance().SetPolicy("main_chain_waiting", false)
		machine.Commit(block)
		return true
	} else if !continuity && isLongest {
		*errMsg = "Main chain fork."
		log.Println(*errMsg)
		poolclient.Instance().SetPolicy("main_chain_waiting", true)
		return false
	}

	*errMsg = "Blockhash is different."
	log.Println(*errMsg)
	return false
}

• func (cm *ChainMaker) Append(block *model.MainBlock, isLongest bool, errMsg *string) bool { ... }: ChainMaker 구조체의 Append 메서드는 블록을 추가합니다.

  • machine := machine.Instance(): 머신 인스턴스를 가져옵니다.

  • lastBlock := mainchain.Instance().LastBlock(): 마지막 블록을 가져옵니다.

  • confirmedHeight := chain.ConfirmedHeight(block.STimestamp): 확인된 높이를 가져옵니다.

  • confirmedHeight = hardfork.ConfirmedHeight(block, confirmedHeight): 하드포크된 높이를 가져옵니다.

  • validators := chain.SelectValidators(confirmedHeight): 검증자 목록을 가져옵니다.

  • if block.Height != lastBlock.Height+1 || len(validators) == 0 { ... }: 블록 높이 또는 검증자가 유효하지 않은 경우.

    • *errMsg = "Waiting for resource blocks.. ": 오류 메시지를 설정합니다.

    • poolclient.Instance().SetPolicy("main_chain_waiting", false): 정책을 설정합니다.

    • return true: true를 반환합니다.

  • block.Validators = validators: 블록에 검증자를 설정합니다.

  • machine.Init(lastBlock, block.STimestamp): 머신을 초기화합니다.

  • machine.SetTransactions(block.Transactions): 트랜잭션을 설정합니다.

  • machine.PreLoad(block.UniversalUpdates, block.LocalUpdates): 업데이트를 사전 로드합니다.

  • machine.PreCommit(confirmedHeight, errMsg): 사전 커밋을 수행합니다.

  • expectedBlock := machine.ExpectedBlock(): 예상 블록을 가져옵니다.

  • validity := block.Validity() && ...: 유효성을 확인합니다.

  • continuity := block.Height == lastBlock.Height+1 && ...: 연속성을 확인합니다.

  • if validity && continuity { ... }: 유효성과 연속성이 있는 경우.

    • poolclient.Instance().SetPolicy("main_chain_waiting", false): 정책을 설정합니다.

    • machine.Commit(block): 블록을 커밋합니다.

    • return true: true를 반환합니다.

  • else if !continuity && isLongest { ... }: 연속성이 없고 가장 긴 경우.

    • *errMsg = "Main chain fork.": 오류 메시지를 설정합니다.

    • log.Println(*errMsg): 오류 메시지를 로그로 출력합니다.

    • poolclient.Instance().SetPolicy("main_chain_waiting", true): 정책을 설정합니다.

    • return false: false를 반환합니다.

  • *errMsg = "Blockhash is different.": 오류 메시지를 설정합니다.

  • log.Println(*errMsg): 오류 메시지를 로그로 출력합니다.

  • return false: false를 반환합니다.

Consensus 함수

func (cm *ChainMaker) Consensus(lastBlock *model.MainBlock, errMsg *string) {
	roundKey := lastBlock.Blockhash
	chunks := bunch.ListChunk(roundKey)

	now := clock.UFloorTime()
	min := max(now-config.REFRESH_INTERVAL, lastBlock.STimestamp)
	roundTimestamp := now
	refresh := false

	if len(chunks) > 0 {
		roundTimestamp = maxInt(chunksTimes(chunks))
		if roundTimestamp < min {
			refresh = true
			roundTimestamp = now
		}
	}

	transactions := bunch.ListTx(roundTimestamp)
	if len(transactions) == 0 {
		return
	}

	confirmedHeight := chain.ConfirmedHeight(roundTimestamp)
	validators := chain.SelectValidators(confirmedHeight)
	main := validators[8]
	address := env.Node().Address()

	if !contains(validators, address) || lastBlock.STimestamp >= roundTimestamp {
		return
	}

	validChunks := filterChunks(chunks, validators)
	machine := machine.Instance()

	machine.Init(lastBlock, roundTimestamp)
	machine.SetTransactions(transactions)
	machine.PreCommit(confirmedHeight, errMsg)

	chunk := machine.Chunk()
	chunkHashes := getChunkHashes(validChunks)
	chunkHashes[address] = chunk.ChunkHash

	hypothesis := machine.Hypothesis(chunkHashes)
	expectedBlock := machine.ExpectedBlock()
	expectedBlock.Validators = validators

	if !hardfork.MainCondition(expectedBlock) && machine.TransactionCount() == 0 {
		return
	}

	if refresh || !chunkExists(validChunks, address) {
		bunch.AddChunk(chunk)
	}

	if address == main {
		bunch.AddHypothesis(hypothesis)
		hypotheses := bunch.ListHypothesis(lastBlock.Blockhash)
		cm.commitExpectedBlock(expectedBlock, hypotheses, lastBlock, validators)
	} else {
		if !cm.Votes(validators, getChunkKeys(validChunks)) {
			return
		}
		bunch.AddHypothesis(hypothesis)
		hypotheses := bunch.ListHypothesis(lastBlock.Blockhash)
		if !cm.Votes(validators, getHypothesisKeys(hypotheses)) {
			return
		}
	}
}

• func (cm *ChainMaker) Consensus(lastBlock *model.MainBlock, errMsg *string) { ... }: ChainMaker 구조체의 Consensus 메서드는 합의 작업을 수행합니다.

  • roundKey := lastBlock.Blockhash: 라운드 키를 설정합니다.

  • chunks := bunch.ListChunk(roundKey): 청크 목록을 가져옵니다.

  • now := clock.UFloorTime(): 현재 시간을 가져옵니다.

  • min := max(now-config.REFRESH_INTERVAL, lastBlock.STimestamp): 최소 시간을 설정합니다.

  • roundTimestamp := now: 라운드 타임스탬프를 설정합니다.

  • refresh := false: 리프레시 여부를 설정합니다.

  • if len(chunks) > 0 { ... }: 청크가 있는 경우.

    • roundTimestamp = maxInt(chunksTimes(chunks)): 최대 청크 타임스탬프를 가져옵니다.

    • if roundTimestamp < min { ... }: 라운드 타임스탬프가 최소 시간보다 작은 경우.

      • refresh = true: 리프레시 여부를 설정합니다.

      • roundTimestamp = now: 라운드 타임스탬프를 현재 시간으로 설정합니다.

  • transactions := bunch.ListTx(roundTimestamp): 트랜잭션 목록을 가져옵니다.

  • if len(transactions) == 0 { return }: 트랜잭션이 없는 경우 종료합니다.

  • confirmedHeight := chain.ConfirmedHeight(roundTimestamp): 확인된 높이를 가져옵니다.

  • validators := chain.SelectValidators(confirmedHeight): 검증자 목록을 가져옵니다.

  • main := validators[8]: 주 검증자를 설정합니다.

  • address := env.Node().Address(): 노드 주소를 가져옵니다.

  • if !contains(validators, address) || lastBlock.STimestamp >= roundTimestamp { return }: 검증자 목록에 없거나 라운드 타임스탬프보다 큰 경우 종료합니다.

  • validChunks := filterChunks(chunks, validators): 유효한 청크를 필터링합니다.

  • machine := machine.Instance(): 머신 인스턴스를 가져옵니다.

  • machine.Init(lastBlock, roundTimestamp): 머신을 초기화합니다.

  • machine.SetTransactions(transactions): 트랜잭션을 설정합니다.

  • machine.PreCommit(confirmedHeight, errMsg): 사전 커밋을 수행합니다.

  • chunk := machine.Chunk(): 청크를 가져옵니다.

  • chunkHashes := getChunkHashes(validChunks): 청크 해시를 가져옵니다.

  • chunkHashes[address] = chunk.ChunkHash: 청크 해시를 설정합니다.

  • hypothesis := machine.Hypothesis(chunkHashes): 가설을 설정합니다.

  • expectedBlock := machine.ExpectedBlock(): 예상 블록을 가져옵니다.

  • expectedBlock.Validators = validators: 예상 블록의 검증자를 설정합니다.

  • if !hardfork.MainCondition(expectedBlock) && machine.TransactionCount() == 0 { return }: 하드포크 조건이 없고 트랜잭션 수가 0인 경우 종료합니다.

  • if refresh || !chunkExists(validChunks, address) { bunch.AddChunk(chunk) }: 리프레시 또는 청크가 없는 경우 청크를 추가합니다.

  • if address == main { ... }: 주소가 주 검증자인 경우.

    • bunch.AddHypothesis(hypothesis): 가설을 추가합니다.

    • hypotheses := bunch.ListHypothesis(lastBlock.Blockhash): 가설 목록을 가져옵니다.

    • cm.commitExpectedBlock(expectedBlock, hypotheses, lastBlock, validators): 예상 블록을 커밋합니다.

  • else { ... }: 주소가 주 검증자가 아닌 경우.

    • if !cm.Votes(validators, getChunkKeys(validChunks)) { return }: 투표가 유효하지 않은 경우 종료합니다.

    • bunch.AddHypothesis(hypothesis): 가설을 추가합니다.

    • hypotheses := bunch.ListHypothesis(lastBlock.Blockhash): 가설 목록을 가져옵니다.

    • if !cm.Votes(validators, getHypothesisKeys(hypotheses)) { return }: 투표가 유효하지 않은 경우 종료합니다.

부가 함수들

• commitExpectedBlock, Seal, Votes, contains, uniqueStrings, max, maxInt, randInt, chunksTimes, getChunkHashes, getChunkKeys, chunkExists, filterChunks, hypothesesTimes, getHypothesisKeys, sealHypotheses, countVotes 등의 함수는 각기 다양한 역할을 수행하며, 그 구체적인 내용은 생략합니다.

main 함수

func main() {
	cm := NewChainMaker()
	cm.Main()
}

• func main() { ... }: 메인 함수는 ChainMaker의 인스턴스를 생성하고 Main 메서드를 호출하여 체인 생성 작업을 시작합니다.

이 코드는 블록체인 네트워크에서 체인 생성을 관리하는 복잡한 작업을 수행하며, 동기화, 합의, 블록 추가 등의 기능을 포함하고 있습니다.