Merge branch 'master' into release_v2.13.0

KarlChristomer · KarlChristomer · commit ce640ae6bc63 · 2022-12-19T18:29:40.000+08:00
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
@@ -53,10 +53,18 @@ jobs:
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Set up Docker QEMU
+        uses: docker/setup-qemu-action@v2
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Available Docker platforms
+        run: echo ${{ steps.buildx.outputs.platforms }}
       - name: Push to Docker Hub
         uses: docker/build-push-action@v2
         with:
           push: true
           context: .
           file: docker/Dockerfile
+          platforms: linux/amd64, linux/arm64
           tags: vitelabs/gvite:${{ github.event.inputs.tag }},vitelabs/gvite:latest
diff --git a/node/config/config.go b/node/config/config.go
@@ -4,6 +4,7 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
+	"github.com/vitelabs/go-vite/v2/common"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -76,6 +77,7 @@ type Config struct {
 	HttpVirtualHosts []string `json:"HttpVirtualHosts"`
 	WSHost           string   `json:"WSHost"`
 	WSPort           int      `json:"WSPort"`
+	PrivateHttpPort  int      `json:"PrivateHttpPort"`
 
 	HTTPCors            []string `json:"HTTPCors"`
 	WSOrigins           []string `json:"WSOrigins"`
@@ -242,6 +244,13 @@ func (c *Config) WSEndpoint() string {
 	return fmt.Sprintf("%s:%d", c.WSHost, c.WSPort)
 }
 
+func (c *Config) PrivateHTTPEndpoint() string {
+	if c.PrivateHttpPort == 0 {
+		return ""
+	}
+	return fmt.Sprintf("%s:%d", common.DefaultHTTPHost, c.PrivateHttpPort)
+}
+
 func (c *Config) SetPrivateKey(privateKey string) {
 	c.PeerKey = privateKey
 }
diff --git a/node/config/defaults.go b/node/config/defaults.go
@@ -20,8 +20,8 @@ var DefaultNodeConfig = Config{
 	LogLevel:      "info",
 	HTTPCors:      []string{"*"},
 	WSOrigins:     []string{"*"},
-	WSExposeAll:   true,
-	HttpExposeAll: true,
+	WSExposeAll:   false,
+	HttpExposeAll: false,
 
 	Single:          config.DefaultSingle,
 	Identity:        config.DefaultNodeName,
diff --git a/node/node.go b/node/node.go
@@ -54,6 +54,9 @@ type Node struct {
 	httpWhitelist []string
 	httpListener  net.Listener
 	httpHandler   *rpc.Server
+	privateHttpEndpoint  string
+	privateHttpListener  net.Listener
+	privateHttpHandler   *rpc.Server
 
 	wsEndpoint string
 	wsListener net.Listener
@@ -75,6 +78,7 @@ func New(conf *nodeconfig.Config) (*Node, error) {
 		ipcEndpoint:  conf.IPCEndpoint(),
 		httpEndpoint: conf.HTTPEndpoint(),
 		wsEndpoint:   conf.WSEndpoint(),
+		privateHttpEndpoint: conf.PrivateHTTPEndpoint(),
 		stop:         make(chan struct{}),
 	}, nil
 }
@@ -312,7 +316,7 @@ func (node *Node) startRPC() (e error) {
 	}
 
 	if node.config.RPCEnabled {
-		if err := node.startHTTP(node.httpEndpoint, apis, nil, node.config.HTTPCors, node.config.HttpVirtualHosts, rpc.HTTPTimeouts{}, node.config.HttpExposeAll); err != nil {
+		if err := node.startHTTP(node.httpEndpoint, node.privateHttpEndpoint, apis, nil, node.config.HTTPCors, node.config.HttpVirtualHosts, rpc.HTTPTimeouts{}, node.config.HttpExposeAll); err != nil {
 			return err
 		}
 		defer func() {
diff --git a/node/rpc.go b/node/rpc.go
@@ -37,12 +37,12 @@ func (node *Node) stopIPC() {
 }
 
 // startHTTP initializes and starts the HTTP RPC endpoint.
-func (node *Node) startHTTP(endpoint string, apis []rpc.API, modules []string, cors []string, vhosts []string, timeouts rpc.HTTPTimeouts, exposeAll bool) error {
+func (node *Node) startHTTP(endpoint string, privateEndpoint string, apis []rpc.API, modules []string, cors []string, vhosts []string, timeouts rpc.HTTPTimeouts, exposeAll bool) error {
 	// Short circuit if the HTTP endpoint isn't being exposed
 	if endpoint == "" {
 		return nil
 	}
-	listener, handler, err := rpc.StartHTTPEndpoint(endpoint, apis, modules, cors, vhosts, timeouts, exposeAll)
+	listener, handler, privateListener, privateHandler, err := rpc.StartHTTPEndpoint(endpoint, privateEndpoint, apis, modules, cors, vhosts, timeouts, exposeAll)
 	if err != nil {
 		return err
 	}
@@ -51,6 +51,8 @@ func (node *Node) startHTTP(endpoint string, apis []rpc.API, modules []string, c
 	node.httpEndpoint = endpoint
 	node.httpListener = listener
 	node.httpHandler = handler
+	node.privateHttpListener = privateListener
+	node.privateHttpHandler = privateHandler
 
 	return nil
 }
@@ -67,6 +69,15 @@ func (node *Node) stopHTTP() {
 		node.httpHandler.Stop()
 		node.httpHandler = nil
 	}
+
+	if node.privateHttpListener != nil {
+		node.privateHttpListener.Close()
+		node.privateHttpListener = nil
+	}
+	if node.privateHttpHandler != nil {
+		node.privateHttpHandler.Stop()
+		node.privateHttpHandler = nil
+	}
 }
 
 // startWS initializes and starts the websocket RPC endpoint.
diff --git a/rpc/endpoints.go b/rpc/endpoints.go
@@ -27,34 +27,50 @@ import (
 )
 
 // StartHTTPEndpoint starts the HTTP RPC endpoint, configured with cors/vhosts/modules
-func StartHTTPEndpoint(endpoint string, apis []API, modules []string, cors []string, vhosts []string, timeouts HTTPTimeouts, exposeAll bool) (net.Listener, *Server, error) {
+func StartHTTPEndpoint(endpoint string, privateEndpoint string, apis []API, modules []string, cors []string, vhosts []string, timeouts HTTPTimeouts, exposeAll bool) (net.Listener, *Server, net.Listener, *Server, error) {
 	// Generate the whitelist based on the allowed modules
 	whitelist := make(map[string]bool)
 	for _, module := range modules {
 		whitelist[module] = true
 	}
 	// Register all the APIs exposed by the services
 	handler := NewServer()
+	privateHandler := NewServer()
+	privateBind := false
 	for _, api := range apis {
 		if exposeAll || whitelist[api.Namespace] || (len(whitelist) == 0 && api.Public) {
 			if err := handler.RegisterName(api.Namespace, api.Service); err != nil {
-				return nil, nil, err
+				return nil, nil, nil, nil, err
 			}
 			log.Debug("HTTP registered", "namespace", api.Namespace)
+		} else if !api.Public {
+			if err := privateHandler.RegisterName(api.Namespace, api.Service); err != nil {
+				return nil, nil, nil, nil, err
+			}
+			privateBind = true
+			log.Debug("Private HTTP API registered", "namespace", api.Namespace)
 		}
 	}
 	// All APIs registered, start the HTTP listener
 	var (
 		listener net.Listener
+		privateListener net.Listener
 		err      error
 	)
 	if listener, err = net.Listen("tcp", endpoint); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, nil, err
 	}
 
 	go NewHTTPServer(cors, vhosts, timeouts, handler).Serve(listener)
 
-	return listener, handler, err
+	if privateBind && len(privateEndpoint) > 0 {
+		if privateListener, err = net.Listen("tcp", privateEndpoint); err != nil {
+			return nil, nil, nil, nil, err
+		}
+		go NewHTTPServer(cors, vhosts, timeouts, privateHandler).Serve(privateListener)
+	}
+
+	return listener, handler, privateListener, privateHandler, err
 }
 
 // StartWSEndpoint starts chain websocket endpoint
diff --git a/rpcapi/api/common_error.go b/rpcapi/api/common_error.go
@@ -5,4 +5,5 @@ import "errors"
 var (
 	ErrStrToBigInt                    = errors.New("convert to big.Int failed")
 	ErrPoWNotSupportedUnderCongestion = errors.New("PoW service not supported")
+	ErrDifficultyTooLarge             = errors.New("difficulty is too large")
 )
diff --git a/rpcapi/api/contract_v2.go b/rpcapi/api/contract_v2.go
@@ -438,7 +438,7 @@ func (r *ContractApi) GetSBPRewardPendingWithdrawal(name string) (*SBPReward, er
 		return nil, err
 	}
 	if info == nil {
-		return nil, nil
+		return nil, util.ErrSBPNotExists
 	}
 	sb, err := db.LatestSnapshotBlock()
 	if err != nil {
@@ -507,6 +507,9 @@ func (r *ContractApi) GetSBP(name string) (*SBPInfo, error) {
 	if err != nil {
 		return nil, err
 	}
+	if info == nil {
+		return nil, util.ErrSBPNotExists
+	}
 	sb, err := db.LatestSnapshotBlock()
 	if err != nil {
 		return nil, err
diff --git a/rpcapi/api/util.go b/rpcapi/api/util.go
@@ -39,6 +39,12 @@ func (p UtilApi) GetPoWNonce(difficulty string, data types.Hash) ([]byte, error)
 		return nil, ErrStrToBigInt
 	}
 
+	difficultyCap := big.NewInt(8034995932)
+	difficultyCap.Mul(difficultyCap, big.NewInt(50))
+	if realDifficulty.Cmp(difficultyCap) > 0 {
+		return nil, ErrDifficultyTooLarge
+	}
+
 	if _, _, isCongestion := quota.CalcQc(p.vite.Chain(), p.vite.Chain().GetLatestSnapshotBlock().Height); isCongestion {
 		return nil, ErrPoWNotSupportedUnderCongestion
 	}
diff --git a/version/buildversion b/version/buildversion
@@ -1 +1 @@
-v2.12.0
+v2.12.1
diff --git a/version/buildversion.go b/version/buildversion.go
@@ -1,3 +1,3 @@
 package version
-const VITE_COMMIT_VERSION = "7aa7e8570af0df4b46e1dc06db930e64606e904e"
-const VITE_BUILD_VERSION = "v2.12.0"
+const VITE_COMMIT_VERSION = "25b479e7f29ab2e0171d132f269a0275ddcb0836"
+const VITE_BUILD_VERSION = "v2.12.1"
diff --git a/vm/util/errors.go b/vm/util/errors.go
@@ -18,6 +18,7 @@ var (
 	ErrDataNotExist              = errors.New("data not exist")
 	ErrContractNotExists         = errors.New("contract not exists")
 	ErrNoReliableStatus          = errors.New("no reliable status")
+	ErrSBPNotExists        		 = errors.New("sbp name does not exists")
 
 	ErrAddressCollision = errors.New("contract address collision")
 	ErrIDCollision      = errors.New("id collision")
diff --git a/wallet/entropystore/utils.go b/wallet/entropystore/utils.go
@@ -23,6 +23,10 @@ func IsMayValidEntropystoreFile(path string) (bool, *types.Address, error) {
 		return false, nil, err
 	}
 
+	if !fi.Mode().IsRegular() {
+		return false, nil, nil
+	}
+
 	// out keystore file size is about 500 so if chain file is very large it must not be chain keystore file
 	if fi.Size() > 2*1024 {
 		return false, nil, nil

Original file line number	Diff line number	Diff line change
`@@ -5,4 +5,5 @@ import "errors"`
`5`	`5`	`var (`
`6`	`6`	`ErrStrToBigInt = errors.New("convert to big.Int failed")`
`7`	`7`	`ErrPoWNotSupportedUnderCongestion = errors.New("PoW service not supported")`
	`8`	`+ ErrDifficultyTooLarge = errors.New("difficulty is too large")`
`8`	`9`	`)`
Original file line number	Diff line number	Diff line change
`@@ -438,7 +438,7 @@ func (r ContractApi) GetSBPRewardPendingWithdrawal(name string) (SBPReward, er`
`438`	`438`	`return nil, err`
`439`	`439`	`}`
`440`	`440`	`if info == nil {`
`441`		`- return nil, nil`
	`441`	`+ return nil, util.ErrSBPNotExists`
`442`	`442`	`}`
`443`	`443`	`sb, err := db.LatestSnapshotBlock()`
`444`	`444`	`if err != nil {`
`@@ -507,6 +507,9 @@ func (r ContractApi) GetSBP(name string) (SBPInfo, error) {`
`507`	`507`	`if err != nil {`
`508`	`508`	`return nil, err`
`509`	`509`	`}`
	`510`	`+ if info == nil {`
	`511`	`+ return nil, util.ErrSBPNotExists`
	`512`	`+ }`
`510`	`513`	`sb, err := db.LatestSnapshotBlock()`
`511`	`514`	`if err != nil {`
`512`	`515`	`return nil, err`
Original file line number	Diff line number	Diff line change
`@@ -39,6 +39,12 @@ func (p UtilApi) GetPoWNonce(difficulty string, data types.Hash) ([]byte, error)`
`39`	`39`	`return nil, ErrStrToBigInt`
`40`	`40`	`}`
`41`	`41`
	`42`	`+ difficultyCap := big.NewInt(8034995932)`
	`43`	`+ difficultyCap.Mul(difficultyCap, big.NewInt(50))`
	`44`	`+ if realDifficulty.Cmp(difficultyCap) > 0 {`
	`45`	`+ return nil, ErrDifficultyTooLarge`
	`46`	`+ }`
	`47`	`+`
`42`	`48`	`if _, _, isCongestion := quota.CalcQc(p.vite.Chain(), p.vite.Chain().GetLatestSnapshotBlock().Height); isCongestion {`
`43`	`49`	`return nil, ErrPoWNotSupportedUnderCongestion`
`44`	`50`	`}`