CovenantSQL · leventeliu · Mar 28, 2019 · Feb 26, 2019 · Feb 28, 2019 · Mar 4, 2019
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
@@ -69,6 +69,9 @@ old-client-compatibility:
     - set -o errexit
     - set -o pipefail
     - set -x
+    - commit=$(git rev-parse --short HEAD)
+    - branch=$(git branch -rv |grep $commit | awk '{print $1}')
+    - if [[ $branch =~ "/beta_" ]]; then exit 0; fi
     - make clean
     - cp ${BIN_CACHE}/* bin/
     - ./test/compatibility/specific_old.sh client
@@ -79,6 +82,9 @@ old-bp-compatibility:
     - set -o errexit
     - set -o pipefail
     - set -x
+    - commit=$(git rev-parse --short HEAD)
+    - branch=$(git branch -rv |grep $commit | awk '{print $1}')
+    - if [[ $branch =~ "/beta_" ]]; then exit 0; fi
     - make clean
     - cp ${BIN_CACHE}/* bin/
     - ./test/compatibility/specific_old.sh bp
@@ -89,6 +95,9 @@ old-miner-compatibility:
     - set -o errexit
     - set -o pipefail
     - set -x
+    - commit=$(git rev-parse --short HEAD)
+    - branch=$(git branch -rv |grep $commit | awk '{print $1}')
+    - if [[ $branch =~ "/beta_" ]]; then exit 0; fi
     - make clean
     - cp ${BIN_CACHE}/* bin/
     - ./test/compatibility/specific_old.sh miner

diff --git a/alltest.sh b/alltest.sh
@@ -5,17 +5,17 @@ set -o pipefail
 set -o nounset
 
 main() {
-  go test -tags "$UNITTESTTAGS" -race -failfast -parallel 16 -cpu 16 -coverprofile main.cover.out $(go list ./... | grep -v CovenantSQL/api)
-  go test -tags "$UNITTESTTAGS" -race -failfast -parallel 16 -cpu 16 -coverpkg ./api/...,./rpc/jsonrpc -coverprofile api.cover.out ./api/...
+  go test -tags "${UNITTESTTAGS:-}" -race -failfast -parallel 16 -cpu 16 -coverprofile main.cover.out $(go list ./... | grep -v CovenantSQL/api)
+  go test -tags "${UNITTESTTAGS:-}" -race -failfast -parallel 16 -cpu 16 -coverpkg ./api/...,./rpc/jsonrpc -coverprofile api.cover.out ./api/...
 
   set -x
   gocovmerge main.cover.out api.cover.out $(find cmd -name "*.cover.out") | grep -F -v '_gen.go' > coverage.txt && rm -f *.cover.out
   bash <(curl -s https://codecov.io/bash)
 
   # some benchmarks
-  go test -tags "$UNITTESTTAGS" -bench=^BenchmarkPersistentCaller_Call$ -run ^$ ./rpc/
+  go test -tags "${UNITTESTTAGS:-}" -bench=^BenchmarkPersistentCaller_Call$ -run ^$ ./rpc/
   bash cleanupDB.sh || true
-  go test -tags "$UNITTESTTAGS" -bench=^BenchmarkMiner$ -benchtime=5s -run ^$ ./cmd/cql-minerd/ -bench-miner-count=2
+  go test -tags "${UNITTESTTAGS:-}" -bench=^BenchmarkMiner$ -benchtime=5s -run ^$ ./cmd/cql-minerd/ -bench-miner-count=2
   bash cleanupDB.sh || true
 }
 

diff --git a/blockproducer/errors.go b/blockproducer/errors.go
@@ -54,6 +54,8 @@ var (
 	ErrUnknownTransactionType = errors.New("unknown transaction type")
 	// ErrInvalidSender indicates that tx.Signee != tx.Sender.
 	ErrInvalidSender = errors.New("invalid sender")
+	// ErrInvalidRange indicates that the billing range is invalid.
+	ErrInvalidRange = errors.New("invalid billing range")
 	// ErrNoSuchMiner indicates that this miner does not exist or register.
 	ErrNoSuchMiner = errors.New("no such miner")
 	// ErrNoEnoughMiner indicates that there is not enough miners

diff --git a/blockproducer/interfaces/transaction.go b/blockproducer/interfaces/transaction.go
@@ -46,8 +46,8 @@ func FromBytes(b []byte) TransactionType {
 }
 
 const (
-	// TransactionTypeBilling defines billing transaction type.
-	TransactionTypeBilling TransactionType = iota
+	// TransactionTypeDeprecated is a deprecated transaction type, do NOT use it.
+	TransactionTypeDeprecated TransactionType = iota
 	// TransactionTypeTransfer defines transfer transaction type.
 	TransactionTypeTransfer
 	// TransactionTypeCreateAccount defines account creation transaction type.
@@ -78,8 +78,6 @@ const (
 
 func (t TransactionType) String() string {
 	switch t {
-	case TransactionTypeBilling:
-		return "Billing"
 	case TransactionTypeTransfer:
 		return "Transfer"
 	case TransactionTypeCreateAccount:

diff --git a/blockproducer/interfaces/transaction_test.go b/blockproducer/interfaces/transaction_test.go
@@ -55,7 +55,7 @@ func TestTypes(t *testing.T) {
 		}
 	})
 	Convey("test string", t, func() {
-		for i := TransactionTypeBilling; i != TransactionTypeNumber+1; i++ {
+		for i := TransactionTypeTransfer; i != TransactionTypeNumber+1; i++ {
 			So(i.String(), ShouldNotBeEmpty)
 		}
 	})

diff --git a/blockproducer/interfaces/transaction_wrapper_test.go b/blockproducer/interfaces/transaction_wrapper_test.go
@@ -63,7 +63,7 @@ func (e *TestTransactionEncode) Msgsize() int {
 }
 
 func init() {
-	pi.RegisterTransaction(pi.TransactionTypeBilling, (*TestTransactionEncode)(nil))
+	pi.RegisterTransaction(pi.TransactionTypeTransfer, (*TestTransactionEncode)(nil))
 }
 
 func TestTransactionWrapper(t *testing.T) {
@@ -81,13 +81,13 @@ func TestTransactionWrapper(t *testing.T) {
 
 		// encode test
 		e := &TestTransactionEncode{}
-		e.SetTransactionType(pi.TransactionTypeBilling)
+		e.SetTransactionType(pi.TransactionTypeTransfer)
 		buf, err = utils.EncodeMsgPack(e)
 		So(err, ShouldBeNil)
 		var v2 pi.Transaction
 		err = utils.DecodeMsgPack(buf.Bytes(), &v2)
 		So(err, ShouldBeNil)
-		So(v2.GetTransactionType(), ShouldEqual, pi.TransactionTypeBilling)
+		So(v2.GetTransactionType(), ShouldEqual, pi.TransactionTypeTransfer)
 
 		// encode with wrapper test
 		e2 := pi.WrapTransaction(e)
@@ -96,14 +96,14 @@ func TestTransactionWrapper(t *testing.T) {
 		var v3 pi.Transaction
 		err = utils.DecodeMsgPack(buf.Bytes(), &v3)
 		So(err, ShouldBeNil)
-		So(v3.GetTransactionType(), ShouldEqual, pi.TransactionTypeBilling)
+		So(v3.GetTransactionType(), ShouldEqual, pi.TransactionTypeTransfer)
 		tw, ok := v3.(*pi.TransactionWrapper)
 		So(ok, ShouldBeTrue)
-		So(tw.Unwrap().GetTransactionType(), ShouldEqual, pi.TransactionTypeBilling)
+		So(tw.Unwrap().GetTransactionType(), ShouldEqual, pi.TransactionTypeTransfer)
 
 		// test encode non-existence type
 		e3 := &TestTransactionEncode{}
-		e3.SetTransactionType(pi.TransactionTypeTransfer)
+		e3.SetTransactionType(pi.TransactionTypeCreateAccount)
 		buf, err = utils.EncodeMsgPack(e3)
 		So(err, ShouldBeNil)
 		var v4 pi.Transaction
@@ -132,21 +132,21 @@ func TestTransactionWrapper(t *testing.T) {
 		So(err, ShouldNotBeNil)
 
 		// test invalid decode, nil payload
-		buf, err = utils.EncodeMsgPack([]interface{}{pi.TransactionTypeBilling, nil})
+		buf, err = utils.EncodeMsgPack([]interface{}{pi.TransactionTypeTransfer, nil})
 		So(err, ShouldBeNil)
 		var v8 pi.Transaction
 		err = utils.DecodeMsgPack(buf.Bytes(), &v8)
 		So(err, ShouldNotBeNil)
 
 		// test invalid decode, invalid payload container type
-		buf, err = utils.EncodeMsgPack([]interface{}{pi.TransactionTypeBilling, []uint64{}})
+		buf, err = utils.EncodeMsgPack([]interface{}{pi.TransactionTypeTransfer, []uint64{}})
 		So(err, ShouldBeNil)
 		var v9 pi.Transaction
 		err = utils.DecodeMsgPack(buf.Bytes(), &v9)
 		So(err, ShouldNotBeNil)
 
 		// extra payload
-		buf, err = utils.EncodeMsgPack([]interface{}{pi.TransactionTypeBilling, e, 1, 2})
+		buf, err = utils.EncodeMsgPack([]interface{}{pi.TransactionTypeTransfer, e, 1, 2})
 		So(err, ShouldBeNil)
 		var v10 pi.Transaction
 		err = utils.DecodeMsgPack(buf.Bytes(), &v10)
@@ -174,22 +174,22 @@ func TestTransactionWrapper(t *testing.T) {
 		So(err, ShouldNotBeNil)
 
 		// test tx data
-		buf, err = utils.EncodeMsgPack(map[string]interface{}{"TxType": pi.TransactionTypeBilling, "TestField": 1})
+		buf, err = utils.EncodeMsgPack(map[string]interface{}{"TxType": pi.TransactionTypeTransfer, "TestField": 1})
 		So(err, ShouldBeNil)
 		var v14 pi.Transaction
 		err = utils.DecodeMsgPack(buf.Bytes(), &v14)
 		So(err, ShouldBeNil)
 
 		// test invalid tx data
-		buf, err = utils.EncodeMsgPack(map[string]interface{}{"TxType": pi.TransactionTypeBilling, "TestField": "happy"})
+		buf, err = utils.EncodeMsgPack(map[string]interface{}{"TxType": pi.TransactionTypeTransfer, "TestField": "happy"})
 		So(err, ShouldBeNil)
 		var v15 pi.Transaction
 		err = utils.DecodeMsgPack(buf.Bytes(), &v15)
 		So(err, ShouldNotBeNil)
 
 		// test json marshal and unmarshal
 		v16 := &TestTransactionEncode{TestField: 10}
-		v16.SetTransactionType(pi.TransactionTypeBilling)
+		v16.SetTransactionType(pi.TransactionTypeTransfer)
 		var v17 pi.Transaction = v16
 		var jsonData []byte
 		jsonData, err = json.Marshal(v17)
@@ -200,17 +200,17 @@ func TestTransactionWrapper(t *testing.T) {
 		err = json.Unmarshal(jsonData, &v18)
 		So(err, ShouldBeNil)
 		So(v18.(*pi.TransactionWrapper).Unwrap(), ShouldNotBeNil)
-		So(v18.GetTransactionType(), ShouldEqual, pi.TransactionTypeBilling)
+		So(v18.GetTransactionType(), ShouldEqual, pi.TransactionTypeTransfer)
 		So(v18.(*pi.TransactionWrapper).Unwrap().(*TestTransactionEncode).TestField, ShouldEqual, 10)
 
 		jsonData, err = json.Marshal(v18)
 		So(string(jsonData), ShouldContainSubstring, "TestField")
 
 		v18.(*pi.TransactionWrapper).Transaction = nil
-		jsonData = []byte(`{"TxType": 0, "TestField": 11}`)
+		jsonData = []byte(`{"TxType": 1, "TestField": 11}`)
 		err = json.Unmarshal(jsonData, &v18)
 		So(err, ShouldBeNil)
-		So(v18.GetTransactionType(), ShouldEqual, pi.TransactionTypeBilling)
+		So(v18.GetTransactionType(), ShouldEqual, pi.TransactionTypeTransfer)
 		So(v18.(*pi.TransactionWrapper).Unwrap().(*TestTransactionEncode).TestField, ShouldEqual, 11)
 
 		// unmarshal fail cases
@@ -225,7 +225,7 @@ func TestTransactionWrapper(t *testing.T) {
 		So(err, ShouldNotBeNil)
 
 		v18.(*pi.TransactionWrapper).Transaction = nil
-		jsonData = []byte(fmt.Sprintf(`{"TxType": %d, "TestField": 11}`, pi.TransactionTypeTransfer))
+		jsonData = []byte(fmt.Sprintf(`{"TxType": %d, "TestField": 11}`, pi.TransactionTypeCreateAccount))
 		err = json.Unmarshal(jsonData, &v18)
 		So(err, ShouldNotBeNil)
 	})

diff --git a/blockproducer/metastate.go b/blockproducer/metastate.go
@@ -509,21 +509,6 @@ func (s *metaState) increaseNonce(addr proto.AccountAddress) (err error) {
 	return
 }
 
-func (s *metaState) applyBilling(tx *types.Billing) (err error) {
-	for i, v := range tx.Receivers {
-		// Create empty receiver account if not found
-		s.loadOrStoreAccountObject(*v, &types.Account{Address: *v})
-
-		if err = s.increaseAccountCovenantBalance(*v, tx.Fees[i]); err != nil {
-			return
-		}
-		if err = s.increaseAccountStableBalance(*v, tx.Rewards[i]); err != nil {
-			return
-		}
-	}
-	return
-}
-
 func (s *metaState) updateProviderList(tx *types.ProvideService) (err error) {
 	sender, err := crypto.PubKeyHash(tx.Signee)
 	if err != nil {
@@ -915,6 +900,13 @@ func (s *metaState) updateBilling(tx *types.UpdateBilling) (err error) {
 		err = errors.Wrap(ErrDatabaseNotFound, "update billing failed")
 		return
 	}
+
+	if tx.Version > 0 && (tx.Range.From >= tx.Range.To || newProfile.LastUpdatedHeight != tx.Range.From) {
+		err = errors.Wrapf(ErrInvalidRange,
+			"update billing within range %d:(%d, %d]",
+			newProfile.LastUpdatedHeight, tx.Range.From, tx.Range.To)
+		return
+	}
 	log.Debugf("update billing addr: %s, user: %d, tx: %v", tx.GetAccountAddress(), len(tx.Users), tx)
 
 	if newProfile.GasPrice == 0 {
@@ -988,6 +980,7 @@ func (s *metaState) updateBilling(tx *types.UpdateBilling) (err error) {
 			}
 		}
 	}
+	newProfile.LastUpdatedHeight = tx.Range.To
 	s.dirty.databases[tx.Receiver.DatabaseID()] = newProfile
 	return
 }
@@ -1128,8 +1121,6 @@ func (s *metaState) applyTransaction(tx pi.Transaction) (err error) {
 			err = s.transferAccountToken(t)
 		}
 		return
-	case *types.Billing:
-		err = s.applyBilling(t)
 	case *types.BaseAccount:
 		err = s.storeBaseAccount(t.Address, &t.Account)
 	case *types.ProvideService: