lib/babe: always use 2/3 of slot to produce block, re-add potentially valid txs to queue

lib/babe/build.go

@@ -244,11 +244,6 @@ func (b *BlockBuilder) buildBlockExtrinsics(slot Slot) []*transaction.ValidTrans
 		txn := b.transactionState.Pop()
 		// Transaction queue is empty.
 		if txn == nil {
-			return included
-		}
-
-		// Move to next extrinsic.
-		if txn.Extrinsic == nil {
 			continue
 		}
 
@@ -270,6 +265,18 @@ func (b *BlockBuilder) buildBlockExtrinsics(slot Slot) []*transaction.ValidTrans
 			if _, ok := err.(*DispatchOutcomeError); !ok {
 				continue
 			}
+
+			// don't drop transactions that may be valid in a later block ie.
+			// run out of gas for this block or have a nonce that may be valid in a later block
+			if tvErr, ok := err.(*TransactionValidityError); ok {
+				switch tvErr.msg {
+				case exhaustsResourcesMsg, invalidTransactionMsg:
+					hash, err := b.transactionState.Push(txn)
+					if err != nil {
+						logger.Debug("failed to re-add transaction to queue", "tx", hash, "error", err)
+					}
+				}
+			}
 		}
 
 		logger.Debug("build block applied extrinsic", "extrinsic", extrinsic)

lib/babe/errors.go

@@ -86,13 +86,33 @@ func (e DispatchOutcomeError) Error() string {
 
 // A TransactionValidityError is possible errors while checking the validity of a transaction
 type TransactionValidityError struct {
-	msg string // description of error
+	msg transactionValidityErrorMsg // description of error
 }
 
 func (e TransactionValidityError) Error() string {
 	return fmt.Sprintf("transaction validity error: %s", e.msg)
 }
 
+type transactionValidityErrorMsg string
+
+var (
+	unexpectedTxCallMsg         transactionValidityErrorMsg = "call of the transaction is not expected"
+	invalidPaymentMsg           transactionValidityErrorMsg = "invalid payment"
+	invalidTransactionMsg       transactionValidityErrorMsg = "invalid transaction"
+	outdatedTransactionMsg      transactionValidityErrorMsg = "outdated transaction"
+	badProofMsg                 transactionValidityErrorMsg = "bad proof"
+	ancientBirthBlockMsg        transactionValidityErrorMsg = "ancient birth block"
+	exhaustsResourcesMsg        transactionValidityErrorMsg = "exhausts resources"
+	mandatoryDispatchErrorMsg   transactionValidityErrorMsg = "mandatory dispatch error"
+	invalidMandatoryDispatchMsg transactionValidityErrorMsg = "invalid mandatory dispatch"
+	lookupFailedMsg             transactionValidityErrorMsg = "lookup failed"
+	validatorNotFoundMsg        transactionValidityErrorMsg = "validator not found"
+)
+
+func newUnknownErrorMsg(data scale.VaryingDataTypeValue) transactionValidityErrorMsg {
+	return transactionValidityErrorMsg(fmt.Sprintf("unknown error: %d", data))
+}
+
 // UnmarshalError occurs when unmarshalling fails
 type UnmarshalError struct {
 	msg string
@@ -223,31 +243,31 @@ func determineErrType(vdt scale.VaryingDataType) error {
 	case Module:
 		return &DispatchOutcomeError{fmt.Sprintf("custom module error: %s", val.string())}
 	case Call:
-		return &TransactionValidityError{"call of the transaction is not expected"}
+		return &TransactionValidityError{unexpectedTxCallMsg}
 	case Payment:
-		return &TransactionValidityError{"invalid payment"}
+		return &TransactionValidityError{invalidPaymentMsg}
 	case Future:
-		return &TransactionValidityError{"invalid transaction"}
+		return &TransactionValidityError{invalidTransactionMsg}
 	case Stale:
-		return &TransactionValidityError{"outdated transaction"}
+		return &TransactionValidityError{outdatedTransactionMsg}
 	case BadProof:
-		return &TransactionValidityError{"bad proof"}
+		return &TransactionValidityError{badProofMsg}
 	case AncientBirthBlock:
-		return &TransactionValidityError{"ancient birth block"}
+		return &TransactionValidityError{ancientBirthBlockMsg}
 	case ExhaustsResources:
-		return &TransactionValidityError{"exhausts resources"}
+		return &TransactionValidityError{exhaustsResourcesMsg}
 	case InvalidCustom:
-		return &TransactionValidityError{fmt.Sprintf("unknown error: %d", val)}
+		return &TransactionValidityError{newUnknownErrorMsg(val)}
 	case BadMandatory:
-		return &TransactionValidityError{"mandatory dispatch error"}
+		return &TransactionValidityError{mandatoryDispatchErrorMsg}
 	case MandatoryDispatch:
-		return &TransactionValidityError{"invalid mandatory dispatch"}
+		return &TransactionValidityError{invalidMandatoryDispatchMsg}
 	case ValidityCannotLookup:
-		return &TransactionValidityError{"lookup failed"}
+		return &TransactionValidityError{lookupFailedMsg}
 	case NoUnsignedValidator:
-		return &TransactionValidityError{"validator not found"}
+		return &TransactionValidityError{validatorNotFoundMsg}
 	case UnknownCustom:
-		return &TransactionValidityError{fmt.Sprintf("unknown error: %d", val)}
+		return &TransactionValidityError{newUnknownErrorMsg(val)}
 	}
 
 	return errInvalidResult

lib/babe/errors_test.go

@@ -79,7 +79,7 @@ func TestApplyExtrinsicErrors(t *testing.T) {
 				_, ok := err.(*TransactionValidityError)
 				require.True(t, ok)
 			}
-			require.Equal(t, err.Error(), c.expected)
+			require.Equal(t, c.expected, err.Error())
 		})
 	}
 }