비트코인 전 노드 고 언어가 BTCD의 블록과 노드를 실현하는 몇 가지 문제

각 노드마다 연결해야 하는 노드(node) 수는 최소 5이지만 코드를 보면 최소 8개이며 코드는 다음과 같다.
4

func (cm *ConnManager) Start() {
   // Already started?
   if atomic.AddInt32(&cm.start, 1) != 1 {
      return
   }

   log.Trace("Connection manager started")
   cm.wg.Add(1)
   go cm.connHandler()

   // Start all the listeners so long as the caller requested them and
   // provided a callback to be invoked when connections are accepted.
   if cm.cfg.OnAccept != nil {
      for _, listner := range cm.cfg.Listeners {
         cm.wg.Add(1)
         go cm.listenHandler(listner)
      }
   }

   for i := atomic.LoadUint64(&cm.connReqCount); i < uint64(cm.cfg.TargetOutbound); i++ {
      go cm.NewConnReq()
   }
}

그 중에서 target OutBound는 요구된 수량이다.

// TargetOutbound is the number of outbound network connections to
// maintain. Defaults to 8.
TargetOutbound uint32

중위수와 로컬 시스템의 시간 차이는 70분을 넘지 않습니다. 그렇지 않으면 이 컴퓨터를 업데이트하는 시간을 알려 줍니다.코드:

func (m *medianTime) AddTimeSample(sourceID string, timeVal time.Time) {
   m.mtx.Lock()
   defer m.mtx.Unlock()

   now := time.Unix(time.Now().Unix(), 0)
   offsetSecs := int64(timeVal.Sub(now).Seconds())
   numOffsets := len(m.offsets)
   if numOffsets == maxMedianTimeEntries && maxMedianTimeEntries > 0 {
      m.offsets = m.offsets[1:]
      numOffsets--
   }
   m.offsets = append(m.offsets, offsetSecs)
   numOffsets++

   // Sort the offsets so the median can be obtained as needed later.
   sortedOffsets := make([]int64, numOffsets)
   copy(sortedOffsets, m.offsets)
   sort.Sort(int64Sorter(sortedOffsets))

   offsetDuration := time.Duration(offsetSecs) * time.Second
   log.Debugf("Added time sample of %v (total: %v)", offsetDuration,
      numOffsets)

   if math.Abs(float64(median)) < maxAllowedOffsetSecs {
      m.offsetSecs = median
   } else {
      // The median offset of all added time data is larger than the
      // maximum allowed offset, so don't use an offset.  This
      // effectively limits how far the local clock can be skewed.
      m.offsetSecs = 0

      if !m.invalidTimeChecked {
         m.invalidTimeChecked = true

         // Find if any time samples have a time that is close
         // to the local time.
         var remoteHasCloseTime bool
         for _, offset := range sortedOffsets {
            if math.Abs(float64(offset)) < similarTimeSecs {
               remoteHasCloseTime = true
               break
            }
         }

         // Warn if none of the time samples are close.
         if !remoteHasCloseTime {
            log.Warnf("Please check your date and time " +
               "are correct!  btcd will not work " +
               "properly with an invalid time")
         }
      }
   }

   medianDuration := time.Duration(m.offsetSecs) * time.Second
   log.Debugf("New time offset: %v", medianDuration)
}

if math.Abs(float64(median)) < maxAllowedOffsetSecs {

즉 판단 시간,

const (
   maxAllowedOffsetSecs = 70 * 60 // 1 hour 10 minutes

또한 새로운 Block을 받을 때 자신과의 격차 +2시간과-(전 11개 Block 시간 중위수)의 Block을 거부합니다
이 논리는 btcd에서 아직 실현되지 않았다
A chain of blocks with each block referencing the block that preceded it. The most-difficult-to-recreate chain is the best block chain.
블록은 모두 이전 블록을 인용하고 가장 어려운 체인을 다시 만드는 것이 가장 좋은 체인이다.코드 간략화:

func (b *BlockChain) connectBestChain(node *blockNode, block *btcutil.Block, flags BehaviorFlags) (bool, error) {
   ...
   if node.workSum.Cmp(b.bestChain.Tip().workSum) <= 0 {
      // Log information about how the block is forking the chain.
      fork := b.bestChain.FindFork(node)
      if fork.hash.IsEqual(parentHash) {
         log.Infof("FORK: Block %v forks the chain at height %d"+
            "/block %v, but does not cause a reorganize",
            node.hash, fork.height, fork.hash)
      } else {
         log.Infof("EXTEND FORK: Block %v extends a side chain "+
            "which forks the chain at height %d/block %v",
            node.hash, fork.height, fork.hash)
      }

      return false, nil
   }

   detachNodes, attachNodes := b.getReorganizeNodes(node)

   // Reorganize the chain.
   log.Infof("REORGANIZE: Block %v is causing a reorganize.", node.hash)
   err := b.reorganizeChain(detachNodes, attachNodes)

   if writeErr := b.index.flushToDB(); writeErr != nil {
      log.Warnf("Error flushing block index changes to disk: %v", writeErr)
   }

   return err == nil, err
}

if node.workSum.Cmp(b.bestChain.Tip().workSum) <= 0 {

이것이 바로 작업량을 비교하는 것입니다. 이 노드의worksum는 어떻게 계산합니까?다음과 같습니다.

func CalcWork(bits uint32) *big.Int {

   difficultyNum := CompactToBig(bits)
   if difficultyNum.Sign() <= 0 {
      return big.NewInt(0)
   }

   // (1 << 256) / (difficultyNum + 1)
   denominator := new(big.Int).Add(difficultyNum, bigOne)
   return new(big.Int).Div(oneLsh256, denominator)
}

The block chain provides Bitcoin’s public ledger, an ordered and timestamped record of transactions. This system is used to protect against double spending and modification of previous transaction records.
비트코인의 블록체인은 시간 스탬프가 찍힌 거래 기록을 질서 있게 포함하는 공개 장부를 제공한다.모든 블록의 포장은 블록의 거래에 쌍꽃이 존재하는지 검사한다. 각 블록은 작업량이 있고 이전의 거래 기록을 수정하려면 원래의 블록보다 많은 작업량, 즉 51%의 문제가 필요하다.