Merge acd391d into 418fd81

Author: zjg555543

libs/cosmos-sdk/baseapp/gasuseddb.go

@@ -76,11 +76,13 @@ func (h *HistoryGasUsedRecordDB) FlushHgu() {
 		return
 	}
 	latestGasKeys := make([]gasKey, len(h.latestGu))
+	index := 0
 	for key, gas := range h.latestGu {
-		latestGasKeys = append(latestGasKeys, gasKey{
+		latestGasKeys[index] = gasKey{
 			gas: gas,
 			key: key,
-		})
+		}
+		index++
 		delete(h.latestGu, key)
 	}
 	h.jobQueue <- func() { h.flushHgu(latestGasKeys...) } // closure
@@ -103,8 +105,8 @@ func (h *HistoryGasUsedRecordDB) getHgu(key []byte) (hgu int64, fromCache bool)
 func (h *HistoryGasUsedRecordDB) flushHgu(gks ...gasKey) {
 	for _, gk := range gks {
 		hgu, cacheHit := h.getHgu([]byte(gk.key))
-		// avgGas = 0.4 * newGas + 0.6 * oldGas
-		avgGas := int64(GasUsedFactor*float64(gk.gas) + (1.0-GasUsedFactor)*float64(hgu))
+		// avgGas = 0.4 * newGas + 0.6 * oldGas.The value of wasm store contract is too small and need to be rounded up.
+		avgGas := int64(GasUsedFactor*float64(gk.gas) + (1.0-GasUsedFactor)*float64(hgu) + 0.6)
 		// add to cache if hit
 		if cacheHit {
 			h.cache.Add(gk.key, avgGas)

libs/cosmos-sdk/x/auth/types/stdtx.go

@@ -268,8 +268,33 @@ func (tx *StdTx) GetGasPrice() *big.Int {
 	return tx.Fee.GasPrices()[0].Amount.BigInt()
 }
 
+type WasmMsgChecker interface {
+	FnSignatureInfo() (string, int, error)
+}
+
 func (tx *StdTx) GetTxFnSignatureInfo() ([]byte, int) {
-	return nil, 0
+	// hgu can't be right simulated with many Msgs.
+	if len(tx.Msgs) != 1 {
+		return nil, 0
+	}
+
+	fnSign := ""
+	deploySize := 0
+	for _, msg := range tx.Msgs {
+		v, ok := msg.(WasmMsgChecker)
+		if !ok {
+			break
+		}
+		fn, size, err := v.FnSignatureInfo()
+		if err != nil || len(fn) <= 0 {
+			break
+		}
+
+		deploySize = size
+		fnSign = fn
+		break
+	}
+	return []byte(fnSign), deploySize
 }
 
 func (tx *StdTx) GetFrom() string {

x/wasm/handler.go

@@ -4,8 +4,11 @@ import (
 	"fmt"
 
 	"github.com/gogo/protobuf/proto"
+	bam "github.com/okx/okbchain/libs/cosmos-sdk/baseapp"
 	sdk "github.com/okx/okbchain/libs/cosmos-sdk/types"
 	sdkerrors "github.com/okx/okbchain/libs/cosmos-sdk/types/errors"
+	sdktypes "github.com/okx/okbchain/libs/cosmos-sdk/x/auth/types"
+	cfg "github.com/okx/okbchain/libs/tendermint/config"
 	"github.com/okx/okbchain/libs/tendermint/libs/kv"
 	types2 "github.com/okx/okbchain/libs/tendermint/types"
 	"github.com/okx/okbchain/x/wasm/keeper"
@@ -35,6 +38,10 @@ func NewHandler(k types.ContractOpsKeeper) sdk.Handler {
 			if ctx.IsDeliver() || ctx.ParaMsg() != nil {
 				watcher.Save(err)
 			}
+
+			if err == nil && !ctx.IsCheckTx() {
+				updateHGU(ctx, msg)
+			}
 		}()
 
 		switch msg := msg.(type) {
@@ -60,6 +67,30 @@ func NewHandler(k types.ContractOpsKeeper) sdk.Handler {
 	}
 }
 
+func updateHGU(ctx sdk.Context, msg sdk.Msg) {
+	if cfg.DynamicConfig.GetMaxGasUsedPerBlock() <= 0 {
+		return
+	}
+
+	v, ok := msg.(sdktypes.WasmMsgChecker)
+	if !ok {
+		return
+	}
+
+	fnSign, deploySize, err := v.FnSignatureInfo()
+	if err != nil || len(fnSign) <= 0 {
+		return
+	}
+
+	gc := int64(ctx.GasMeter().GasConsumed())
+	if deploySize > 0 {
+		// calculate average gas consume for deploy contract case, The value is too small and need to +1
+		gc = gc/int64(deploySize) + 1
+	}
+
+	bam.InstanceOfHistoryGasUsedRecordDB().UpdateGasUsed([]byte(fnSign), gc)
+}
+
 // filterMessageEvents returns the same events with all of type == EventTypeMessage removed except
 // for wasm message types.
 // this is so only our top-level message event comes through

x/wasm/types/tx.go

@@ -3,6 +3,7 @@ package types
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"strings"
 
 	sdk "github.com/okx/okbchain/libs/cosmos-sdk/types"
@@ -78,6 +79,16 @@ func (msg MsgStoreCode) GetSigners() []sdk.AccAddress {
 	return []sdk.AccAddress{sdk.WasmToAccAddress(senderAddr)}
 }
 
+func (msg MsgStoreCode) FnSignatureInfo() (string, int, error) {
+	codeLen := len(msg.WASMByteCode)
+	var err error
+	if codeLen <= 0 {
+		err = fmt.Errorf("wasm byte code length is 0")
+	}
+
+	return msg.Type(), codeLen, err
+}
+
 func (msg MsgInstantiateContract) Route() string {
 	return RouterKey
 }
@@ -163,6 +174,35 @@ func (msg MsgExecuteContract) GetSigners() []sdk.AccAddress {
 	return []sdk.AccAddress{sdk.WasmToAccAddress(senderAddr)}
 }
 
+func (msg MsgExecuteContract) FnSignatureInfo() (string, int, error) {
+	if err := msg.Msg.ValidateBasic(); err != nil {
+		return "", 0, fmt.Errorf("failed to validate msg:%v", err)
+	}
+
+	var v interface{}
+	json.Unmarshal(msg.Msg, &v)
+	data := v.(map[string]interface{})
+	if len(data) != 1 {
+		return "", 0, fmt.Errorf("failed to check msg method:%s", string(msg.Msg.Bytes()))
+	}
+
+	method := ""
+	for k, _ := range data {
+		method = k
+		break
+	}
+
+	if len(method) <= 0 {
+		return "", 0, fmt.Errorf("msg has not method:%s", string(msg.Msg.Bytes()))
+	}
+
+	var builder strings.Builder
+	builder.WriteString(msg.Contract)
+	builder.WriteString(method)
+
+	return builder.String(), 0, nil
+}
+
 func (msg MsgMigrateContract) Route() string {
 	return RouterKey
 }

x/wasm/types/tx_test.go

@@ -545,3 +545,100 @@ func TestMsgJsonSignBytes(t *testing.T) {
 		})
 	}
 }
+
+func TestMsgStoreCodeFnSignatureInfo(t *testing.T) {
+	cases := map[string]struct {
+		msg MsgStoreCode
+		len int
+		err error
+	}{
+		"normal": {
+			msg: MsgStoreCode{
+				Sender:       sdk.WasmAddress(make([]byte, 20)).String(),
+				WASMByteCode: []byte("foo"),
+			},
+			len: 3,
+			err: nil,
+		},
+		"empty": {
+			msg: MsgStoreCode{
+				Sender:       sdk.WasmAddress(make([]byte, 20)).String(),
+				WASMByteCode: []byte(""),
+			},
+			len: 0,
+			err: fmt.Errorf("wasm byte code length is 0"),
+		},
+	}
+
+	for name, tc := range cases {
+		t.Run(name, func(t *testing.T) {
+			name, lenFn, err := tc.msg.FnSignatureInfo()
+			require.Equal(t, name, "store-code")
+			require.Equal(t, lenFn, tc.len)
+			require.Equal(t, err, tc.err)
+		})
+	}
+}
+
+func TestMsgExecuteContractFnSignatureInfo(t *testing.T) {
+	cases := map[string]struct {
+		msg  MsgExecuteContract
+		name string
+		err  error
+	}{
+		"normal": {
+			msg: MsgExecuteContract{
+				Sender:   sdk.WasmAddress(make([]byte, 20)).String(),
+				Contract: sdk.WasmAddress(make([]byte, 20)).String(),
+				Msg:      []byte("{\"press\":{\"ascending\":true}}"),
+			},
+			name: "0x0000000000000000000000000000000000000000press",
+			err:  nil,
+		},
+		"empty msg name": {
+			msg: MsgExecuteContract{
+				Sender:   sdk.WasmAddress(make([]byte, 20)).String(),
+				Contract: sdk.WasmAddress(make([]byte, 20)).String(),
+				Msg:      []byte("{\"\":{\"ascending\":true}}"),
+			},
+			name: "",
+			err:  fmt.Errorf("msg has not method:{\"\":{\"ascending\":true}}"),
+		},
+		"validate msg": {
+			msg: MsgExecuteContract{
+				Sender:   sdk.WasmAddress(make([]byte, 20)).String(),
+				Contract: sdk.WasmAddress(make([]byte, 20)).String(),
+				Msg:      []byte("sdfasdf"),
+			},
+			name: "",
+			err:  fmt.Errorf("failed to validate msg:invalid"),
+		},
+		"check msg method, 0": {
+			msg: MsgExecuteContract{
+				Sender:   sdk.WasmAddress(make([]byte, 20)).String(),
+				Contract: sdk.WasmAddress(make([]byte, 20)).String(),
+				Msg:      []byte("{}"),
+			},
+			name: "",
+			err:  fmt.Errorf("failed to check msg method:{}"),
+		},
+		"check msg method, 1": {
+			msg: MsgExecuteContract{
+				Sender:   sdk.WasmAddress(make([]byte, 20)).String(),
+				Contract: sdk.WasmAddress(make([]byte, 20)).String(),
+				Msg:      []byte("{\"press\":{\"ascending\":true},\"hello\":{\"ascending\":true}}"),
+			},
+			name: "",
+			err:  fmt.Errorf("failed to check msg method:{\"press\":{\"ascending\":true},\"hello\":{\"ascending\":true}}"),
+		},
+	}
+
+	for name, tc := range cases {
+		t.Run(name, func(t *testing.T) {
+			name, lenFn, err := tc.msg.FnSignatureInfo()
+			require.Equal(t, tc.name, name)
+			require.Equal(t, lenFn, 0)
+			require.Equal(t, tc.err, err)
+		})
+	}
+}