Method processBlocks

sqlchain/chain.go:752–849

(ctx context.Context)

}

func (c *Chain) processBlocks(ctx context.Context) {
	var (
		cld, ccl = context.WithCancel(ctx)
		wg       = &sync.WaitGroup{}
	)

	returnStash := func(stash []*types.Block) {
		defer wg.Done()
		for i, block := range stash {
			select {
			case c.blocks <- block:
			case <-cld.Done():
				c.logEntry().WithFields(log.Fields{
					"remaining": len(stash) - i,
				}).WithError(cld.Err()).Debug("abort stash returning")
				return
			}
		}
	}

	defer func() {
		ccl()
		wg.Wait()
	}()

	var stash []*types.Block
	for {
		le := c.logEntryWithHeadState()
		select {
		case h := <-c.heights:
			// Trigger billing
			index, total := c.rt.getIndexTotal()
			period := int32(c.updatePeriod)
			isBillingPeriod := (h%period == 0)
			isMyTurnBilling := (h/period%total == index)
			if isBillingPeriod && isMyTurnBilling {
				ub, err := c.billing(h, c.rt.getHead().node)
				if err != nil {
					le.WithError(err).Error("billing failed")
				}
				// allocate nonce
				nonceReq := &types.NextAccountNonceReq{}
				nonceResp := &types.NextAccountNonceResp{}
				nonceReq.Addr = *c.addr
				if err = rpc.RequestBP(route.MCCNextAccountNonce.String(), nonceReq, nonceResp); err != nil {
					// allocate nonce failed
					le.WithError(err).Warning("allocate nonce for transaction failed")
				}
				ub.Nonce = nonceResp.Nonce
				if err = ub.Sign(c.pk); err != nil {
					le.WithError(err).Warning("sign tx failed")
				}

				addTxReq := &types.AddTxReq{TTL: 1}
				addTxResp := &types.AddTxResp{}
				addTxReq.Tx = ub
				le.Debugf("nonce in processBlocks: %d, addr: %s",
					addTxReq.Tx.GetAccountNonce(), addTxReq.Tx.GetAccountAddress())