Merge pull request #26 from Dharitri-org/raj

v0.2.0
Dharitri-org · Mar 22, 2024 · 2299552 · 2299552
2 parents 49c8aa9 + c514588
commit 2299552
Show file tree

Hide file tree

Showing 13 changed files with 2,291 additions and 38 deletions.
diff --git a/builtInFunctions/creator_test.go b/builtInFunctions/creator_test.go
@@ -7,6 +7,7 @@ import (
 	"github.com/Dharitri-org/drtg-core/core/check"
 	"github.com/Dharitri-org/drtg-vm-common/mock"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func createMockArguments() ArgsCreateBuiltInFunctionContainer {
@@ -111,13 +112,23 @@ func TestCreateBuiltInFunctionContainer_Errors(t *testing.T) {
 
 	args = createMockArguments()
 	args.GuardedAccountHandler = nil
-	f, err = NewBuiltInFunctionsCreator(args)
+	_, err = NewBuiltInFunctionsCreator(args)
 	assert.Equal(t, err, ErrNilGuardedAccountHandler)
 
 	args = createMockArguments()
 	f, err = NewBuiltInFunctionsCreator(args)
 	assert.Nil(t, err)
-	assert.False(t, f.IsInterfaceNil())
+	assert.NotNil(t, f)
+}
+
+func TestBuiltInFuncCreator_IsInterfaceNil(t *testing.T) {
+	t.Parallel()
+
+	var instance *builtInFuncCreator
+	require.True(t, instance.IsInterfaceNil())
+
+	instance, _ = NewBuiltInFunctionsCreator(createMockArguments())
+	require.False(t, instance.IsInterfaceNil())
 }
 
 func TestCreateBuiltInContainer_GasScheduleChange(t *testing.T) {

diff --git a/builtInFunctions/dctDataStorage.go b/builtInFunctions/dctDataStorage.go
@@ -582,9 +582,7 @@ func (e *dctDataStorage) WasAlreadySentToDestinationShardAndUpdateState(
 
 	if uint32(len(dctData.Properties)) < e.shardCoordinator.NumberOfShards() {
 		newSlice := make([]byte, e.shardCoordinator.NumberOfShards())
-		for i, val := range dctData.Properties {
-			newSlice[i] = val
-		}
+		copy(newSlice, dctData.Properties)
 		dctData.Properties = newSlice
 	}
 

diff --git a/builtInFunctions/dctDeleteMetadata_test.go b/builtInFunctions/dctDeleteMetadata_test.go
@@ -72,31 +72,31 @@ func TestDctDeleteMetaData_ProcessBuiltinFunctionErrors(t *testing.T) {
 
 	vmOutput, err := e.ProcessBuiltinFunction(nil, nil, nil)
 	assert.Nil(t, vmOutput)
-	assert.Equal(t, err, ErrNilVmInput)
+	assert.Equal(t, ErrNilVmInput, err)
 
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, &vmcommon.ContractCallInput{VMInput: vmcommon.VMInput{CallValue: big.NewInt(10)}})
 	assert.Nil(t, vmOutput)
-	assert.Equal(t, err, ErrBuiltInFunctionCalledWithValue)
+	assert.Equal(t, ErrBuiltInFunctionCalledWithValue, err)
 
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, &vmcommon.ContractCallInput{VMInput: vmcommon.VMInput{CallValue: big.NewInt(0)}})
 	assert.Nil(t, vmOutput)
-	assert.Equal(t, err, ErrAddressIsNotAllowed)
+	assert.Equal(t, ErrAddressIsNotAllowed, err)
 
 	vmInput := &vmcommon.ContractCallInput{VMInput: vmcommon.VMInput{CallValue: big.NewInt(0)}}
 	vmInput.CallerAddr = e.allowedAddress
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
 	assert.Nil(t, vmOutput)
-	assert.Equal(t, err, ErrInvalidRcvAddr)
+	assert.Equal(t, ErrInvalidRcvAddr, err)
 
 	vmInput.RecipientAddr = e.allowedAddress
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
 	assert.Nil(t, vmOutput)
-	assert.Equal(t, err, ErrInvalidNumOfArgs)
+	assert.Equal(t, ErrInvalidNumOfArgs, err)
 
 	e.delete = false
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
 	assert.Nil(t, vmOutput)
-	assert.Equal(t, err, ErrInvalidNumOfArgs)
+	assert.Equal(t, ErrInvalidNumOfArgs, err)
 
 	vmInput.Arguments = [][]byte{{1}, {0}, {1}}
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
@@ -106,7 +106,7 @@ func TestDctDeleteMetaData_ProcessBuiltinFunctionErrors(t *testing.T) {
 	e.delete = true
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
 	assert.Nil(t, vmOutput)
-	assert.Equal(t, err, ErrInvalidNumOfArgs)
+	assert.Equal(t, ErrInvalidNumOfArgs, err)
 
 	vmInput.Arguments = [][]byte{{1}, {0}, {1}, {1}}
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
@@ -124,13 +124,13 @@ func TestDctDeleteMetaData_ProcessBuiltinFunctionErrors(t *testing.T) {
 	vmInput.Arguments = [][]byte{{1}, {0}, {1}}
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
 	assert.Nil(t, vmOutput)
-	assert.Equal(t, err, ErrInvalidNonce)
+	assert.Equal(t, ErrInvalidNonce, err)
 
 	vmInput.Arguments[0] = []byte("TOKEN-ABABAB")
 	vmInput.Arguments[1] = []byte{1}
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
 	assert.Nil(t, vmOutput)
-	assert.Equal(t, err, ErrInvalidTokenID)
+	assert.Equal(t, ErrInvalidTokenID, err)
 
 	vmInput.Arguments[0] = []byte("TOKEN-ababab")
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
@@ -158,7 +158,7 @@ func TestDctDeleteMetaData_ProcessBuiltinFunctionErrors(t *testing.T) {
 
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
 	assert.Nil(t, vmOutput)
-	assert.NotNil(t, ErrTokenHasValidMetadata)
+	assert.Equal(t, ErrTokenHasValidMetadata, err)
 
 	_ = acnt.SaveKeyValue(dctNftTokenKey, nil)
 	testErr := errors.New("testError")
@@ -169,12 +169,12 @@ func TestDctDeleteMetaData_ProcessBuiltinFunctionErrors(t *testing.T) {
 	vmInput.Arguments[1] = []byte{2}
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
 	assert.Nil(t, vmOutput)
-	assert.Equal(t, err, ErrInvalidMetadata)
+	assert.Equal(t, ErrInvalidMetadata, err)
 
 	vmInput.Arguments[1] = []byte{1}
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
 	assert.Nil(t, vmOutput)
-	assert.Equal(t, err, testErr)
+	assert.Equal(t, testErr, err)
 }
 
 func TestDctDeleteMetaData_ProcessBuiltinFunctionGetNodeFromDbErr(t *testing.T) {
@@ -265,7 +265,7 @@ func TestDctDeleteMetaData_ProcessBuiltinFunctionDelete(t *testing.T) {
 	vmInput.Arguments[0] = []byte("TOKEN-ababab")
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
 	assert.Nil(t, vmOutput)
-	assert.Equal(t, err, ErrInvalidNumOfArgs)
+	assert.Equal(t, ErrInvalidNumOfArgs, err)
 
 	vmInput.Arguments[2] = []byte{0}
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
@@ -283,9 +283,10 @@ func TestDctDeleteMetaData_ProcessBuiltinFunctionDelete(t *testing.T) {
 	vmInput.Arguments = append(vmInput.Arguments, []byte("TOKEN-ababab"), []byte{2})
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
 	assert.Nil(t, vmOutput)
-	assert.Equal(t, err, ErrInvalidNumOfArgs)
+	assert.Equal(t, ErrInvalidNumOfArgs, err)
 
 	vmInput.Arguments = append(vmInput.Arguments, []byte{1}, []byte{2}, []byte{4}, []byte{10})
 	vmOutput, err = e.ProcessBuiltinFunction(nil, nil, vmInput)
 	assert.NotNil(t, vmOutput)
+	assert.Nil(t, err)
 }
diff --git a/builtInFunctions/dctGlobalSettings.go b/builtInFunctions/dctGlobalSettings.go
@@ -113,13 +113,10 @@ func (e *dctGlobalSettings) toggleSetting(dctTokenKey []byte) error {
 	switch e.function {
 	case core.BuiltInFunctionDCTSetLimitedTransfer, core.BuiltInFunctionDCTUnSetLimitedTransfer:
 		dctMetaData.LimitedTransfer = e.set
-		break
 	case core.BuiltInFunctionDCTPause, core.BuiltInFunctionDCTUnPause:
 		dctMetaData.Paused = e.set
-		break
 	case vmcommon.BuiltInFunctionDCTUnSetBurnRoleForAll, vmcommon.BuiltInFunctionDCTSetBurnRoleForAll:
 		dctMetaData.BurnRoleForAll = e.set
-		break
 	}
 
 	err = systemSCAccount.AccountDataHandler().SaveKeyValue(dctTokenKey, dctMetaData.ToBytes())

diff --git a/builtInFunctions/dctNFTCreate_test.go b/builtInFunctions/dctNFTCreate_test.go
@@ -435,14 +435,14 @@ func TestDctNFTCreate_ProcessBuiltinFunctionWithExecByCaller(t *testing.T) {
 
 func readNFTData(t *testing.T, account vmcommon.UserAccountHandler, marshaller vmcommon.Marshalizer, tokenID []byte, nonce uint64, _ []byte) (*dct.DCToken, uint64) {
 	nonceKey := getNonceKey(tokenID)
-	latestNonceBytes, _, err := account.(vmcommon.UserAccountHandler).AccountDataHandler().RetrieveValue(nonceKey)
+	latestNonceBytes, _, err := account.AccountDataHandler().RetrieveValue(nonceKey)
 	require.Nil(t, err)
 	latestNonce := big.NewInt(0).SetBytes(latestNonceBytes).Uint64()
 
 	createdTokenID := []byte(baseDCTKeyPrefix)
 	createdTokenID = append(createdTokenID, tokenID...)
 	tokenKey := computeDCTNFTTokenKey(createdTokenID, nonce)
-	data, _, err := account.(vmcommon.UserAccountHandler).AccountDataHandler().RetrieveValue(tokenKey)
+	data, _, err := account.AccountDataHandler().RetrieveValue(tokenKey)
 	require.Nil(t, err)
 
 	dctData := &dct.DCToken{}

diff --git a/builtInFunctions/dctNFTTransfer_test.go b/builtInFunctions/dctNFTTransfer_test.go
@@ -651,7 +651,7 @@ func TestDctNFTTransfer_ProcessBuiltinFunctionOnCrossShardsDestinationDoesNotHol
 
 	testNFTTokenShouldExist(t, nftTransferSenderShard.marshaller, sender, tokenName, tokenNonce, big.NewInt(2)) // 3 initial - 1 transferred
 
-	funcName, args := extractScResultsFromVmOutput(t, vmOutput)
+	_, args := extractScResultsFromVmOutput(t, vmOutput)
 
 	destination, err := nftTransferDestinationShard.accounts.LoadAccount(destinationAddress)
 	require.Nil(t, err)
@@ -675,7 +675,7 @@ func TestDctNFTTransfer_ProcessBuiltinFunctionOnCrossShardsDestinationDoesNotHol
 	require.Nil(t, err)
 
 	testNFTTokenShouldExist(t, nftTransferDestinationShard.marshaller, destination, tokenName, tokenNonce, big.NewInt(1))
-	funcName, args = extractScResultsFromVmOutput(t, vmOutput)
+	funcName, args := extractScResultsFromVmOutput(t, vmOutput)
 	assert.Equal(t, scCallFunctionAsHex, funcName)
 	require.Equal(t, 1, len(args))
 	require.Equal(t, []byte(scCallArg), args[0])

diff --git a/builtInFunctions/dctTransfer.go b/builtInFunctions/dctTransfer.go
@@ -147,7 +147,7 @@ func (e *dctTransfer) ProcessBuiltinFunction(
 		}
 
 		if isSCCallAfter {
-			vmOutput.GasRemaining, err = vmcommon.SafeSubUint64(vmInput.GasProvided, e.funcGasCost)
+			vmOutput.GasRemaining, _ = vmcommon.SafeSubUint64(vmInput.GasProvided, e.funcGasCost)
 			var callArgs [][]byte
 			if len(vmInput.Arguments) > core.MinLenArgumentsDCTTransfer+1 {
 				callArgs = vmInput.Arguments[core.MinLenArgumentsDCTTransfer+1:]

diff --git a/builtInFunctions/deleteUserName_test.go b/builtInFunctions/deleteUserName_test.go
@@ -12,22 +12,38 @@ import (
 func TestNewDeleteUserNameFunc(t *testing.T) {
 	d, err := NewDeleteUserNameFunc(0, nil, nil)
 	require.Equal(t, err, ErrNilDnsAddresses)
+	require.Nil(t, d)
 
 	d, err = NewDeleteUserNameFunc(0, make(map[string]struct{}), nil)
 	require.Equal(t, err, ErrNilEnableEpochsHandler)
+	require.Nil(t, d)
 
 	dnsAddr := []byte("DNS")
 	mapDnsAddresses := make(map[string]struct{})
 	mapDnsAddresses[string(dnsAddr)] = struct{}{}
 	d, err = NewDeleteUserNameFunc(0, mapDnsAddresses, &mock.EnableEpochsHandlerStub{})
 	require.Nil(t, err)
+	require.NotNil(t, d)
 	require.False(t, d.IsInterfaceNil())
 
 	d.SetNewGasConfig(nil)
 	d.SetNewGasConfig(&vmcommon.GasCost{BuiltInCost: vmcommon.BuiltInCost{SaveUserName: 10}})
 	require.Equal(t, d.gasCost, uint64(10))
 }
 
+func TestDeleteUserName_IsInterfaceNil(t *testing.T) {
+	t.Parallel()
+
+	var d *deleteUserName
+	require.True(t, d.IsInterfaceNil())
+
+	dnsAddr := []byte("DNS")
+	mapDnsAddresses := make(map[string]struct{})
+	mapDnsAddresses[string(dnsAddr)] = struct{}{}
+	d, _ = NewDeleteUserNameFunc(0, mapDnsAddresses, &mock.EnableEpochsHandlerStub{})
+	require.False(t, d.IsInterfaceNil())
+}
+
 func TestDeleteUserName_ProcessBuiltinFunction(t *testing.T) {
 	t.Parallel()
 

diff --git a/builtInFunctions/multiDCTNFTTransfer_test.go b/builtInFunctions/multiDCTNFTTransfer_test.go
@@ -531,7 +531,7 @@ func TestDCTNFTMultiTransfer_ProcessBuiltinFunctionOnCrossShardsDestinationDoesN
 
 	testNFTTokenShouldExist(t, multiTransferSenderShard.marshaller, sender, token1, tokenNonce, big.NewInt(2)) // 3 initial - 1 transferred
 
-	funcName, args := extractScResultsFromVmOutput(t, vmOutput)
+	_, args := extractScResultsFromVmOutput(t, vmOutput)
 
 	destination, err := multiTransferDestinationShard.accounts.LoadAccount(destinationAddress)
 	require.Nil(t, err)
@@ -556,7 +556,7 @@ func TestDCTNFTMultiTransfer_ProcessBuiltinFunctionOnCrossShardsDestinationDoesN
 
 	testNFTTokenShouldExist(t, multiTransferDestinationShard.marshaller, destination, token1, tokenNonce, big.NewInt(1))
 	testNFTTokenShouldExist(t, multiTransferDestinationShard.marshaller, destination, token2, 0, big.NewInt(1))
-	funcName, args = extractScResultsFromVmOutput(t, vmOutput)
+	funcName, args := extractScResultsFromVmOutput(t, vmOutput)
 	assert.Equal(t, scCallFunctionAsHex, funcName)
 	require.Equal(t, 1, len(args))
 	require.Equal(t, []byte(scCallArg), args[0])
@@ -644,16 +644,13 @@ func TestDCTNFTMultiTransfer_ProcessBuiltinFunctionOnCrossShardsDestinationAddTo
 		IsPausedCalled: func(tokenKey []byte) bool {
 			dctTokenKey := []byte(baseDCTKeyPrefix)
 			dctTokenKey = append(dctTokenKey, token2...)
-			if bytes.Equal(tokenKey, dctTokenKey) {
-				return true
-			}
-
-			return false
+			return bytes.Equal(tokenKey, dctTokenKey)
 		},
 	}
 	vmOutput, err = multiTransferDestinationShard.ProcessBuiltinFunction(nil, destination.(vmcommon.UserAccountHandler), vmInput)
 	require.Error(t, err)
 	require.Equal(t, "dct token is paused for token token2", err.Error())
+	require.Nil(t, vmOutput)
 }
 
 func TestDCTNFTMultiTransfer_ProcessBuiltinFunctionOnCrossShardsOneTransfer(t *testing.T) {
@@ -941,12 +938,14 @@ func TestDCTNFTMultiTransfer_ProcessBuiltinFunctionOnCrossShardsShouldErr(t *tes
 	vmOutput, err = multiTransferDestinationShard.ProcessBuiltinFunction(nil, destination.(vmcommon.UserAccountHandler), vmInput)
 	require.Error(t, err)
 	require.Equal(t, "sending value to non payable contract", err.Error())
+	require.Nil(t, vmOutput)
 
 	// check the multi transfer for fungible DCT transfers as well
 	vmInput.Arguments = [][]byte{big.NewInt(2).Bytes(), token1, big.NewInt(0).Bytes(), quantityBytes, token2, big.NewInt(0).Bytes(), quantityBytes}
 	vmOutput, err = multiTransferDestinationShard.ProcessBuiltinFunction(nil, destination.(vmcommon.UserAccountHandler), vmInput)
 	require.Error(t, err)
 	require.Equal(t, "sending value to non payable contract", err.Error())
+	require.Nil(t, vmOutput)
 }
 
 func TestDCTNFTMultiTransfer_SndDstFrozen(t *testing.T) {

diff --git a/builtInFunctions/saveUserName_test.go b/builtInFunctions/saveUserName_test.go
@@ -12,19 +12,22 @@ import (
 func TestNewSaveUserNameFunc(t *testing.T) {
 	m, err := NewSaveUserNameFunc(0, nil, nil, nil)
 	require.Equal(t, err, ErrNilDnsAddresses)
+	require.Nil(t, m)
 
 	m, err = NewSaveUserNameFunc(0, make(map[string]struct{}), nil, nil)
 	require.Equal(t, err, ErrNilDnsAddresses)
+	require.Nil(t, m)
 
 	m, err = NewSaveUserNameFunc(0, make(map[string]struct{}), make(map[string]struct{}), nil)
 	require.Equal(t, err, ErrNilEnableEpochsHandler)
+	require.Nil(t, m)
 
 	dnsAddr := []byte("DNS")
 	mapDnsAddresses := make(map[string]struct{})
 	mapDnsAddresses[string(dnsAddr)] = struct{}{}
 	m, err = NewSaveUserNameFunc(0, mapDnsAddresses, make(map[string]struct{}), &mock.EnableEpochsHandlerStub{})
 	require.Nil(t, err)
-	require.False(t, m.IsInterfaceNil())
+	require.NotNil(t, m)
 	require.Equal(t, len(m.mapDnsAddresses), 1)
 	require.Equal(t, len(m.mapDnsV2Addresses), 0)
 
@@ -33,6 +36,19 @@ func TestNewSaveUserNameFunc(t *testing.T) {
 	require.Equal(t, m.gasCost, uint64(10))
 }
 
+func TestSaveUserName_IsInterfaceNil(t *testing.T) {
+	t.Parallel()
+
+	var m *saveUserName
+	require.True(t, m.IsInterfaceNil())
+
+	dnsAddr := []byte("DNS")
+	mapDnsAddresses := make(map[string]struct{})
+	mapDnsAddresses[string(dnsAddr)] = struct{}{}
+	m, _ = NewSaveUserNameFunc(0, mapDnsAddresses, make(map[string]struct{}), &mock.EnableEpochsHandlerStub{})
+	require.False(t, m.IsInterfaceNil())
+}
+
 func TestSaveUserName_ProcessBuiltinFunction(t *testing.T) {
 	t.Parallel()
 

diff --git a/builtInFunctions/setGuardian_test.go b/builtInFunctions/setGuardian_test.go
@@ -1,10 +1,10 @@
 package builtInFunctions
 
 import (
+	"crypto/rand"
 	"errors"
 	"fmt"
 	"math/big"
-	"math/rand"
 	"strings"
 	"testing"