Rc/v1.6.0

.github/workflows/golangci-lint.yml

@@ -0,0 +1,37 @@
+name: golangci-lint
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches: [ main, feat/*, rc/* ]
+
+permissions:
+  contents: read
+
+jobs:
+  golangci:
+    name: golangci linter
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-go@v3
+        with:
+          go-version: 1.20.7
+      - uses: actions/checkout@v3
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v3
+        with:
+          # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
+          version: v1.53.2
+
+          # Optional: working directory, useful for monorepos
+          # working-directory: somedir
+
+          # Optional: golangci-lint command line arguments.
+          args: --timeout 10m0s --max-issues-per-linter 0 --max-same-issues 0 --print-issued-lines
+
+          # Optional: show only new issues if it's a pull request. The default value is `false`.
+          only-new-issues: true
+
+          # Optional: if set to true then the action will use pre-installed Go
+          # skip-go-installation: true

.github/workflows/pr-tests.yml

@@ -1,20 +1,21 @@
 name: Tests
 
 on:
-  push:
-    branches: [ main, development, feat/*, rc/* ]
   pull_request:
-    branches: [ main, development, feat/*, rc/* ]
+    branches: [ main, rc/*, feat/* ]
+    types: [ opened, ready_for_review ]
+  push:
+  workflow_dispatch:
 
 jobs:
   test:
     name: Unit
     runs-on: ubuntu-latest
     steps:
-      - name: Set up Go 1.17.6
+      - name: Set up Go 1.20.7
         uses: actions/setup-go@v3
         with:
-          go-version: 1.17.6
+          go-version: 1.20.7
         id: go
 
       - name: Check out code

.gitignore

@@ -14,5 +14,10 @@
 # Dependency directories
 /vendor
 
+# IDE files
+.idea/
+
 # Go workspace file
 go.work
+
+.idea

Makefile

@@ -1,3 +1,15 @@
 test:
 	@echo "  >  Running unit tests"
 	go test -cover -race -coverprofile=coverage.txt -covermode=atomic -v ./...
+
+lint-install:
+ifeq (,$(wildcard test -f bin/golangci-lint))
+	@echo "Installing golint"
+	curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s
+endif
+
+run-lint:
+	@echo "Running golint"
+	bin/golangci-lint run --max-issues-per-linter 0 --max-same-issues 0 --timeout=2m
+
+lint: lint-install run-lint

core/check/ifHrp.go

@@ -0,0 +1,15 @@
+package check
+
+// IfHrp tests if the provided string is human readable - does contain only alphabetic characters
+func IfHrp(s string) bool {
+	if s == "" {
+		return false
+	}
+
+	for _, r := range s {
+		if (r < 'a' || r > 'z') && (r < 'A' || r > 'Z') {
+			return false
+		}
+	}
+	return true
+}

core/check/ifHrp_test.go

@@ -0,0 +1,25 @@
+package check_test
+
+import (
+	"testing"
+
+	"github.com/multiversx/mx-chain-core-go/core/check"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCheckIfHRP_ShouldWork(t *testing.T) {
+	t.Parallel()
+
+	assert.True(t, check.IfHrp("abc"))
+	assert.True(t, check.IfHrp("Abc"))
+	assert.False(t, check.IfHrp("abc1"))
+	assert.False(t, check.IfHrp("abc/"))
+	assert.False(t, check.IfHrp("/t"))
+	assert.False(t, check.IfHrp("!t"))
+	assert.False(t, check.IfHrp(".t"))
+	assert.False(t, check.IfHrp("`t"))
+	assert.False(t, check.IfHrp(""))
+	assert.False(t, check.IfHrp("123()"))
+	assert.False(t, check.IfHrp(" "))
+	assert.False(t, check.IfHrp("  "))
+}

core/constants.go

@@ -40,6 +40,9 @@ const AllShardId = uint32(0xFFFFFFF0)
 // MegabyteSize represents the size in bytes of a megabyte
 const MegabyteSize = 1024 * 1024
 
+// MaxMachineIDLen is the maximum machine ID length
+const MaxMachineIDLen = 10
+
 // BuiltInFunctionClaimDeveloperRewards is the key for the claim developer rewards built-in function
 const BuiltInFunctionClaimDeveloperRewards = "ClaimDeveloperRewards"
 
@@ -126,6 +129,9 @@ const BuiltInFunctionGuardAccount = "GuardAccount"
 // BuiltInFunctionUnGuardAccount is the built-in function key for un-guarding an account
 const BuiltInFunctionUnGuardAccount = "UnGuardAccount"
 
+// BuiltInFunctionMigrateDataTrie is the built-in function key for migrating the data trie
+const BuiltInFunctionMigrateDataTrie = "MigrateDataTrie"
+
 // ESDTRoleLocalMint is the constant string for the local role of mint for ESDT tokens
 const ESDTRoleLocalMint = "ESDTRoleLocalMint"
 
@@ -252,8 +258,17 @@ const SignalErrorOperation = "signalError"
 // CompletedTxEventIdentifier is the identifier for the log that is generated when the execution of a smart contract call is done
 const CompletedTxEventIdentifier = "completedTxEvent"
 
+// InternalVMErrorsOperation is the identifier for the log that is generated when the execution of a smart contract generates an interval vm error
+const InternalVMErrorsOperation = "internalVMErrors"
+
 // GasRefundForRelayerMessage is the return message for to the smart contract result with refund for the relayer
 const GasRefundForRelayerMessage = "gas refund for relayer"
 
 // InitialVersionOfTransaction defines the initial version for a transaction
 const InitialVersionOfTransaction = uint32(1)
+
+// DefaultAddressPrefix is the default hrp of MultiversX/Elrond
+const DefaultAddressPrefix = "erd"
+
+// TopicRequestSuffix represents the topic name suffix for requests
+const TopicRequestSuffix = "_REQUEST"

core/errorHandling.go

@@ -0,0 +1,46 @@
+package core
+
+import (
+	"errors"
+	"strings"
+)
+
+// IsGetNodeFromDBError returns true if the provided error is of type getNodeFromDB
+func IsGetNodeFromDBError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	if IsClosingError(err) {
+		return false
+	}
+
+	return strings.Contains(err.Error(), GetNodeFromDBErrorString)
+}
+
+// IsClosingError returns true if the provided error is used whenever the node is in the closing process
+func IsClosingError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	errString := err.Error()
+	return strings.Contains(errString, ErrDBIsClosed.Error()) ||
+		strings.Contains(errString, ErrContextClosing.Error())
+}
+
+// UnwrapGetNodeFromDBErr unwraps the provided error until it finds a GetNodeFromDbErrHandler
+func UnwrapGetNodeFromDBErr(wrappedErr error) GetNodeFromDbErrHandler {
+	errWithKeyHandler, ok := wrappedErr.(GetNodeFromDbErrHandler)
+	for !ok {
+		if wrappedErr == nil {
+			return nil
+		}
+
+		err := errors.Unwrap(wrappedErr)
+		errWithKeyHandler, ok = err.(GetNodeFromDbErrHandler)
+		wrappedErr = err
+	}
+
+	return errWithKeyHandler
+}

core/errorHandling_test.go

@@ -0,0 +1,80 @@
+package core
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsGetNodeFromDBError(t *testing.T) {
+	t.Parallel()
+
+	t.Run("nil error", func(t *testing.T) {
+		t.Parallel()
+
+		assert.False(t, IsGetNodeFromDBError(nil))
+	})
+
+	t.Run("closing error", func(t *testing.T) {
+		t.Parallel()
+
+		assert.False(t, IsGetNodeFromDBError(ErrContextClosing))
+		assert.False(t, IsGetNodeFromDBError(ErrDBIsClosed))
+	})
+
+	t.Run("get node from db error", func(t *testing.T) {
+		t.Parallel()
+
+		assert.True(t, IsGetNodeFromDBError(fmt.Errorf("trie error: %s", GetNodeFromDBErrorString)))
+	})
+
+	t.Run("other error", func(t *testing.T) {
+		t.Parallel()
+
+		assert.False(t, IsGetNodeFromDBError(fmt.Errorf("trie error: %s", "other error")))
+	})
+}
+
+func TestIsClosingError(t *testing.T) {
+	t.Parallel()
+
+	t.Run("nil error", func(t *testing.T) {
+		t.Parallel()
+
+		assert.False(t, IsClosingError(nil))
+	})
+
+	t.Run("closing error", func(t *testing.T) {
+		t.Parallel()
+
+		assert.True(t, IsClosingError(ErrContextClosing))
+		assert.True(t, IsClosingError(ErrDBIsClosed))
+	})
+
+	t.Run("other error", func(t *testing.T) {
+		t.Parallel()
+
+		assert.False(t, IsClosingError(fmt.Errorf("trie error: %s", "other error")))
+	})
+}
+
+func TestUnwrapGetNodeFromDBErr(t *testing.T) {
+	t.Parallel()
+
+	key := []byte("key")
+	identifier := "identifier"
+	err := fmt.Errorf("key not found")
+
+	getNodeFromDbErr := NewGetNodeFromDBErrWithKey(key, err, identifier)
+	wrappedErr1 := fmt.Errorf("wrapped error 1: %w", getNodeFromDbErr)
+	wrappedErr2 := fmt.Errorf("wrapped error 2: %w", wrappedErr1)
+	wrappedErr3 := fmt.Errorf("wrapped error 3: %w", wrappedErr2)
+
+	assert.Nil(t, UnwrapGetNodeFromDBErr(nil))
+	assert.Nil(t, UnwrapGetNodeFromDBErr(err))
+	assert.Equal(t, getNodeFromDbErr, UnwrapGetNodeFromDBErr(getNodeFromDbErr))
+	assert.Equal(t, getNodeFromDbErr, UnwrapGetNodeFromDBErr(wrappedErr1))
+	assert.Equal(t, getNodeFromDbErr, UnwrapGetNodeFromDBErr(wrappedErr2))
+	assert.Equal(t, getNodeFromDbErr, UnwrapGetNodeFromDBErr(wrappedErr3))
+}

core/errors.go

@@ -109,3 +109,12 @@ var ErrNilGoRoutineProcessor = errors.New("nil go routine processor")
 
 // ErrNilPubkeyConverter signals that a nil public key converter has been provided
 var ErrNilPubkeyConverter = errors.New("nil pubkey converter")
+
+// ErrContextClosing signals that the parent context requested the closing of its children
+var ErrContextClosing = errors.New("context closing")
+
+// ErrDBIsClosed is raised when the DB is closed
+var ErrDBIsClosed = errors.New("DB is closed")
+
+// ErrNilEnableEpochsHandler signals that a nil enable epochs handler has been provided
+var ErrNilEnableEpochsHandler = errors.New("nil enable epochs handler")