v0.1.5

.github/workflows/golangci-lint.yml

@@ -0,0 +1,37 @@
+name: golangci-lint
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches: [ master, 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,10 +1,11 @@
 name: Tests
 
 on:
-  push:
-    branches: [ master, feat/*, rc/* ]
   pull_request:
-    branches: [ master, feat/*, rc/* ]
+    branches: [ master, rc/*, feat/* ]
+    types: [ opened, ready_for_review ]
+  push:
+  workflow_dispatch:
 
 jobs:
   test:
@@ -14,7 +15,7 @@ jobs:
       - name: Set up Go 1.x
         uses: actions/setup-go@v2
         with:
-          go-version: ^1.15.6
+          go-version: 1.20.7
         id: go
 
       - name: Check out code

address.go

@@ -98,3 +98,15 @@ func IsAllowedToSaveUnderKey(key []byte) bool {
 	trimmedKey := key[:prefixLen]
 	return !bytes.Equal(trimmedKey, []byte(core.ProtectedKeyPrefix))
 }
+
+// ParseVMTypeFromContractAddress obtains the VMType from the contract address
+// TODO maybe move to elgond-go-core
+func ParseVMTypeFromContractAddress(contractAddress []byte) ([]byte, error) {
+	if len(contractAddress) < NumInitCharactersForScAddress {
+		return nil, ErrInvalidVMType
+	}
+
+	startIndex := NumInitCharactersForScAddress - VMTypeLen
+	endIndex := NumInitCharactersForScAddress
+	return contractAddress[startIndex:endIndex], nil
+}

address_test.go

@@ -75,3 +75,21 @@ func TestIsSmartContractOnMetachain_ShouldReturnTrue(t *testing.T) {
 	scAddress, _ := hex.DecodeString("000000000000000000000000000000000000000000000000000000b51e0eb3a1")
 	assert.True(t, IsSmartContractOnMetachain(identifier, scAddress))
 }
+
+func Test_ParseVMTypeFromContractAddress_Ok(t *testing.T) {
+	t.Parallel()
+
+	identifier, _ := hex.DecodeString("0a0b")
+	scAddress, _ := hex.DecodeString("00000000000000000a0b5fed9c659422cd8429ce92f8973bba2a9fb51e0eb3a1")
+	vmType, _ := ParseVMTypeFromContractAddress(scAddress)
+	assert.Equal(t, identifier, vmType)
+}
+
+func Test_ParseVMTypeFromContractAddress_Invalid(t *testing.T) {
+	t.Parallel()
+
+	scAddress, _ := hex.DecodeString("12345")
+	vmType, err := ParseVMTypeFromContractAddress(scAddress)
+	assert.Nil(t, vmType)
+	assert.Equal(t, ErrInvalidVMType, err)
+}

builtInFunctions/claimDeveloperRewards.go

@@ -66,6 +66,7 @@ func (c *claimDeveloperRewards) ProcessBuiltinFunction(
 
 	vmOutput := &vmcommon.VMOutput{GasRemaining: gasRemaining, ReturnCode: vmcommon.Ok}
 	outTransfer := vmcommon.OutputTransfer{
+		Index:         1,
 		Value:         big.NewInt(0).Set(value),
 		GasLimit:      0,
 		Data:          nil,
@@ -80,7 +81,7 @@ func (c *claimDeveloperRewards) ProcessBuiltinFunction(
 	}
 	outputAcc := &vmcommon.OutputAccount{
 		Address:         vmInput.CallerAddr,
-		BalanceDelta:    big.NewInt(0).Set(value),
+		BalanceDelta:    big.NewInt(0),
 		OutputTransfers: []vmcommon.OutputTransfer{outTransfer},
 	}
 

builtInFunctions/claimDeveloperRewards_test.go

@@ -41,7 +41,8 @@ func TestClaimDeveloperRewards_ProcessBuiltinFunction(t *testing.T) {
 	acc.AddToDeveloperReward(value)
 	vmOutput, err = cdr.ProcessBuiltinFunction(nil, acc, vmInput)
 	require.Nil(t, err)
-	require.Equal(t, value, vmOutput.OutputAccounts[string(vmInput.CallerAddr)].BalanceDelta)
+	require.Equal(t, 1, len(vmOutput.OutputAccounts[string(vmInput.CallerAddr)].OutputTransfers))
+	require.Equal(t, value, vmOutput.OutputAccounts[string(vmInput.CallerAddr)].OutputTransfers[0].Value)
 	require.Equal(t, uint64(0), vmOutput.GasRemaining)
 
 	acc.OwnerAddress = sender

builtInFunctions/creator.go

@@ -12,10 +12,13 @@ var _ vmcommon.BuiltInFunctionFactory = (*builtInFuncCreator)(nil)
 var trueHandler = func() bool { return true }
 var falseHandler = func() bool { return false }
 
+const deleteUserNameFuncName = "DeleteUserName" // all builtInFunction names are upper case
+
 // ArgsCreateBuiltInFunctionContainer defines the input arguments to create built in functions container
 type ArgsCreateBuiltInFunctionContainer struct {
 	GasMap                           map[string]map[string]uint64
 	MapDNSAddresses                  map[string]struct{}
+	MapDNSV2Addresses                map[string]struct{}
 	EnableUserNameChange             bool
 	Marshalizer                      vmcommon.Marshalizer
 	Accounts                         vmcommon.AccountsAdapter
@@ -28,6 +31,7 @@ type ArgsCreateBuiltInFunctionContainer struct {
 
 type builtInFuncCreator struct {
 	mapDNSAddresses                  map[string]struct{}
+	mapDNSV2Addresses                map[string]struct{}
 	enableUserNameChange             bool
 	marshaller                       vmcommon.Marshalizer
 	accounts                         vmcommon.AccountsAdapter
@@ -53,6 +57,9 @@ func NewBuiltInFunctionsCreator(args ArgsCreateBuiltInFunctionContainer) (*built
 	if args.MapDNSAddresses == nil {
 		return nil, ErrNilDnsAddresses
 	}
+	if args.MapDNSV2Addresses == nil {
+		return nil, ErrNilDnsAddresses
+	}
 	if check.IfNil(args.ShardCoordinator) {
 		return nil, ErrNilShardCoordinator
 	}
@@ -65,6 +72,7 @@ func NewBuiltInFunctionsCreator(args ArgsCreateBuiltInFunctionContainer) (*built
 
 	b := &builtInFuncCreator{
 		mapDNSAddresses:                  args.MapDNSAddresses,
+		mapDNSV2Addresses:                args.MapDNSV2Addresses,
 		enableUserNameChange:             args.EnableUserNameChange,
 		marshaller:                       args.Marshalizer,
 		accounts:                         args.Accounts,
@@ -135,7 +143,7 @@ func (b *builtInFuncCreator) CreateBuiltInFunctionContainer() error {
 		return err
 	}
 
-	newFunc, err = NewSaveUserNameFunc(b.gasConfig.BuiltInCost.SaveUserName, b.mapDNSAddresses, b.enableUserNameChange)
+	newFunc, err = NewSaveUserNameFunc(b.gasConfig.BuiltInCost.SaveUserName, b.mapDNSAddresses, b.mapDNSV2Addresses, b.enableEpochsHandler)
 	if err != nil {
 		return err
 	}
@@ -144,6 +152,15 @@ func (b *builtInFuncCreator) CreateBuiltInFunctionContainer() error {
 		return err
 	}
 
+	newFunc, err = NewDeleteUserNameFunc(b.gasConfig.BuiltInCost.SaveUserName, b.mapDNSV2Addresses, b.enableEpochsHandler)
+	if err != nil {
+		return err
+	}
+	err = b.builtInFunctions.Add(deleteUserNameFuncName, newFunc)
+	if err != nil {
+		return err
+	}
+
 	newFunc, err = NewSaveKeyValueStorageFunc(b.gasConfig.BaseOperationCost, b.gasConfig.BuiltInCost.SaveKeyValue)
 	if err != nil {
 		return err
@@ -214,7 +231,7 @@ func (b *builtInFuncCreator) CreateBuiltInFunctionContainer() error {
 		return err
 	}
 
-	newFunc, err = NewDCTLocalBurnFunc(b.gasConfig.BuiltInCost.DCTLocalBurn, b.marshaller, globalSettingsFunc, setRoleFunc)
+	newFunc, err = NewDCTLocalBurnFunc(b.gasConfig.BuiltInCost.DCTLocalBurn, b.marshaller, globalSettingsFunc, setRoleFunc, b.enableEpochsHandler)
 	if err != nil {
 		return err
 	}
@@ -223,7 +240,7 @@ func (b *builtInFuncCreator) CreateBuiltInFunctionContainer() error {
 		return err
 	}
 
-	newFunc, err = NewDCTLocalMintFunc(b.gasConfig.BuiltInCost.DCTLocalMint, b.marshaller, globalSettingsFunc, setRoleFunc)
+	newFunc, err = NewDCTLocalMintFunc(b.gasConfig.BuiltInCost.DCTLocalMint, b.marshaller, globalSettingsFunc, setRoleFunc, b.enableEpochsHandler)
 	if err != nil {
 		return err
 	}
@@ -471,6 +488,15 @@ func (b *builtInFuncCreator) CreateBuiltInFunctionContainer() error {
 		return err
 	}
 
+	newFunc, err = NewMigrateDataTrieFunc(b.gasConfig.BuiltInCost, b.enableEpochsHandler, b.accounts)
+	if err != nil {
+		return err
+	}
+	err = b.builtInFunctions.Add(core.BuiltInFunctionMigrateDataTrie, newFunc)
+	if err != nil {
+		return err
+	}
+
 	return nil
 }
 

builtInFunctions/creator_test.go

@@ -16,6 +16,7 @@ func createMockArguments() ArgsCreateBuiltInFunctionContainer {
 	args := ArgsCreateBuiltInFunctionContainer{
 		GasMap:                           gasMap,
 		MapDNSAddresses:                  make(map[string]struct{}),
+		MapDNSV2Addresses:                make(map[string]struct{}),
 		EnableUserNameChange:             false,
 		Marshalizer:                      &mock.MarshalizerMock{},
 		Accounts:                         &mock.AccountsStub{},
@@ -74,6 +75,8 @@ func fillGasMapBuiltInCosts(value uint64) map[string]uint64 {
 	gasMap["SetGuardian"] = value
 	gasMap["GuardAccount"] = value
 	gasMap["UnGuardAccount"] = value
+	gasMap["TrieLoadPerNode"] = value
+	gasMap["TrieStorePerNode"] = value
 
 	return gasMap
 }
@@ -137,7 +140,7 @@ func TestCreateBuiltInContainer_Create(t *testing.T) {
 
 	err := f.CreateBuiltInFunctionContainer()
 	assert.Nil(t, err)
-	assert.Equal(t, 34, f.BuiltInFunctionContainer().Len())
+	assert.Equal(t, 36, f.BuiltInFunctionContainer().Len())
 
 	err = f.SetPayableHandler(nil)
 	assert.NotNil(t, err)

builtInFunctions/dctBurn.go

@@ -100,6 +100,7 @@ func (e *dctBurn) ProcessBuiltinFunction(
 	vmOutput := &vmcommon.VMOutput{GasRemaining: gasRemaining, ReturnCode: vmcommon.Ok}
 	if vmcommon.IsSmartContractAddress(vmInput.CallerAddr) {
 		addOutputTransferToVMOutput(
+			1,
 			vmInput.CallerAddr,
 			core.BuiltInFunctionDCTBurn,
 			vmInput.Arguments,

builtInFunctions/dctDataStorage.go

@@ -131,6 +131,9 @@ func (e *dctDataStorage) getDCTNFTTokenOnDestinationWithAccountsAdapterOptions(
 		Type:  uint32(core.Fungible),
 	}
 	marshaledData, _, err := accnt.AccountDataHandler().RetrieveValue(dctNFTTokenKey)
+	if core.IsGetNodeFromDBError(err) {
+		return nil, false, err
+	}
 	if err != nil || len(marshaledData) == 0 {
 		return dctData, true, nil
 	}
@@ -165,6 +168,9 @@ func (e *dctDataStorage) getDCTDigitalTokenDataFromSystemAccount(
 	}
 
 	marshaledData, _, err := systemAcc.AccountDataHandler().RetrieveValue(tokenKey)
+	if core.IsGetNodeFromDBError(err) {
+		return nil, systemAcc, err
+	}
 	if err != nil || len(marshaledData) == 0 {
 		return nil, systemAcc, nil
 	}
@@ -212,6 +218,9 @@ func (e *dctDataStorage) checkCollectionIsFrozenForAccount(
 		Type:  uint32(core.Fungible),
 	}
 	marshaledData, _, err := accnt.AccountDataHandler().RetrieveValue(dctTokenKey)
+	if core.IsGetNodeFromDBError(err) {
+		return err
+	}
 	if err != nil || len(marshaledData) == 0 {
 		return nil
 	}
@@ -382,7 +391,10 @@ func (e *dctDataStorage) saveDCTMetaDataToSystemAccount(
 		return err
 	}
 
-	currentSaveData, _, _ := systemAcc.AccountDataHandler().RetrieveValue(dctNFTTokenKey)
+	currentSaveData, _, err := systemAcc.AccountDataHandler().RetrieveValue(dctNFTTokenKey)
+	if core.IsGetNodeFromDBError(err) {
+		return err
+	}
 	err = e.saveMetadataIfRequired(dctNFTTokenKey, systemAcc, currentSaveData, dctData)
 	if err != nil {
 		return err
@@ -466,6 +478,9 @@ func (e *dctDataStorage) setReservedToNilForOldToken(
 		return ErrNilUserAccount
 	}
 	dataOnUserAcc, _, errNotCritical := userAcc.AccountDataHandler().RetrieveValue(dctNFTTokenKey)
+	if core.IsGetNodeFromDBError(errNotCritical) {
+		return errNotCritical
+	}
 	shouldIgnoreToken := errNotCritical != nil || len(dataOnUserAcc) == 0
 	if shouldIgnoreToken {
 		return nil