Feat/pubkeyconverter_refactor

cmd/keygenerator/converter/errors.go

@@ -2,4 +2,5 @@ package converter
 
 import "errors"
 
+// ErrNotImplemented is returned when a method is not implemented
 var errNotImplemented = errors.New("not implemented")

cmd/keygenerator/converter/pidPubkeyConverter.go

@@ -1,9 +1,6 @@
 package converter
 
 import (
-	"encoding/hex"
-	"runtime/debug"
-
 	crypto "github.com/multiversx/mx-chain-crypto-go"
 	"github.com/multiversx/mx-chain-crypto-go/signing"
 	"github.com/multiversx/mx-chain-crypto-go/signing/secp256k1"
@@ -33,19 +30,13 @@ func (converter *pidPubkeyConverter) Decode(_ string) ([]byte, error) {
 }
 
 // Encode encodes a byte array in its string representation
-func (converter *pidPubkeyConverter) Encode(pkBytes []byte) string {
+func (converter *pidPubkeyConverter) Encode(pkBytes []byte) (string, error) {
 	pidString, err := converter.encode(pkBytes)
 	if err != nil {
-		log.Warn("pidPubkeyConverter.Encode encode",
-			"hex buff", hex.EncodeToString(pkBytes),
-			"error", err,
-			"stack trace", string(debug.Stack()),
-		)
-
-		return ""
+		return "", err
 	}
 
-	return pidString
+	return pidString, nil
 }
 
 func (converter *pidPubkeyConverter) encode(pkBytes []byte) (string, error) {

cmd/keygenerator/converter/pidPubkeyConverter_test.go

@@ -30,7 +30,8 @@ func TestPidPubkeyConverter_Encode(t *testing.T) {
 			}
 		}()
 
-		encoded := converter.Encode([]byte("not a valid PK"))
+		encoded, err := converter.Encode([]byte("not a valid PK"))
+		assert.Contains(t, err.Error(), "parameter is invalid")
 		assert.Empty(t, encoded)
 	})
 	t.Run("valid public key should work", func(t *testing.T) {
@@ -40,7 +41,8 @@ func TestPidPubkeyConverter_Encode(t *testing.T) {
 		pkBytes, err := hex.DecodeString(pkHex)
 		assert.Nil(t, err)
 
-		encoded := converter.Encode(pkBytes)
+		encoded, err := converter.Encode(pkBytes)
+		assert.Nil(t, err)
 		assert.Equal(t, "16Uiu2HAmSHgyTYyawhsZv9opxTHX77vKjoPeGkyCYS5fYVMssHjN", encoded)
 	})
 }

cmd/keygenerator/main.go

@@ -41,6 +41,7 @@ const minedWalletPrefixKeys = "mined-wallet"
 const nopattern = "nopattern"
 const desiredpattern = "[0-f]+"
 const noshard = -1
+const pubkeyHrp = "erd"
 
 type key struct {
 	skBytes []byte
@@ -49,7 +50,7 @@ type key struct {
 
 type pubKeyConverter interface {
 	Decode(humanReadable string) ([]byte, error)
-	Encode(pkBytes []byte) string
+	Encode(pkBytes []byte) (string, error)
 	IsInterfaceNil() bool
 }
 
@@ -132,7 +133,7 @@ VERSION:
 
 	validatorPubKeyConverter, _ = pubkeyConverter.NewHexPubkeyConverter(blsPubkeyLen)
 	pidPubKeyConverter          = converter.NewPidPubkeyConverter()
-	walletPubKeyConverter, _    = pubkeyConverter.NewBech32PubkeyConverter(txSignPubkeyLen, log)
+	walletPubKeyConverter, _    = pubkeyConverter.NewBech32PubkeyConverter(txSignPubkeyLen, pubkeyHrp)
 )
 
 func main() {
@@ -365,7 +366,10 @@ func writeKeyToStream(writer io.Writer, key key, converter pubKeyConverter) erro
 		return fmt.Errorf("nil writer")
 	}
 
-	pkString := converter.Encode(key.pkBytes)
+	pkString, err := converter.Encode(key.pkBytes)
+	if err != nil {
+		return err
+	}
 
 	blk := pem.Block{
 		Type:  "PRIVATE KEY for " + pkString,

cmd/node/config/config.toml

@@ -601,6 +601,7 @@
     Length = 32
     Type = "bech32"
     SignatureLength = 64
+    Hrp = "erd"
 
 [ValidatorPubkeyConverter]
     Length = 96

common/factory/pubkeyConverterFactory.go

@@ -7,11 +7,8 @@ import (
 	"github.com/multiversx/mx-chain-core-go/core/pubkeyConverter"
 	"github.com/multiversx/mx-chain-go/config"
 	"github.com/multiversx/mx-chain-go/state"
-	logger "github.com/multiversx/mx-chain-logger-go"
 )
 
-var log = logger.GetOrCreate("state/factory")
-
 // HexFormat defines the hex format for the pubkey converter
 const HexFormat = "hex"
 
@@ -24,7 +21,7 @@ func NewPubkeyConverter(config config.PubkeyConfig) (core.PubkeyConverter, error
 	case HexFormat:
 		return pubkeyConverter.NewHexPubkeyConverter(config.Length)
 	case Bech32Format:
-		return pubkeyConverter.NewBech32PubkeyConverter(config.Length, log)
+		return pubkeyConverter.NewBech32PubkeyConverter(config.Length, config.Hrp)
 	default:
 		return nil, fmt.Errorf("%w unrecognized type %s", state.ErrInvalidPubkeyConverterType, config.Type)
 	}

common/factory/pubkeyConverterFactory_test.go

@@ -32,11 +32,13 @@ func TestNewPubkeyConverter_Bech32ShouldWork(t *testing.T) {
 		config.PubkeyConfig{
 			Length: 32,
 			Type:   "bech32",
+			Hrp:    "erd",
 		},
 	)
 
 	assert.Nil(t, err)
-	expected, _ := pubkeyConverter.NewBech32PubkeyConverter(32, log)
+	expected, err := pubkeyConverter.NewBech32PubkeyConverter(32, "erd")
+	assert.Nil(t, err)
 	assert.IsType(t, expected, pc)
 }
 

config/config.go

@@ -48,6 +48,7 @@ type PubkeyConfig struct {
 	Length          int
 	Type            string
 	SignatureLength int
+	Hrp             string
 }
 
 // TypeConfig will map the string type configuration

config/tomlConfig_test.go

@@ -611,7 +611,7 @@ func TestEnableEpochConfig(t *testing.T) {
 
     # ESDTNFTCreateOnMultiShardEnableEpoch represents the epoch when esdt nft creation on multiple shards is enabled
     ESDTNFTCreateOnMultiShardEnableEpoch = 39
-
+	
     # MetaESDTSetEnableEpoch represents the epoch when the backward compatibility for save key value error is enabled
     MetaESDTSetEnableEpoch = 40
 
@@ -694,7 +694,7 @@ func TestEnableEpochConfig(t *testing.T) {
         {EnableEpoch = 0, Type = "no-KOSK"},
         {EnableEpoch = 3, Type = "KOSK"}
     ]
-
+	
 [GasSchedule]
     GasScheduleByEpochs = [
         { StartEpoch = 46, FileName = "gasScheduleV1.toml" },

dataRetriever/factory/dataPoolFactory_test.go

@@ -86,15 +86,15 @@ func TestNewDataPoolFromConfig_BadConfigShouldErr(t *testing.T) {
 	require.Nil(t, holder)
 	fmt.Println(err)
 	require.NotNil(t, err)
-	require.True(t, strings.Contains(err.Error(), "Must provide a positive size while creating the cache for the miniblocks"))
+	require.True(t, strings.Contains(err.Error(), "must provide a positive size while creating the cache for the miniblocks"))
 
 	args = getGoodArgs()
 	args.Config.PeerBlockBodyDataPool.Capacity = 0
 	holder, err = NewDataPoolFromConfig(args)
 	require.Nil(t, holder)
 	fmt.Println(err)
 	require.NotNil(t, err)
-	require.True(t, strings.Contains(err.Error(), "Must provide a positive size while creating the cache for the peer mini block body"))
+	require.True(t, strings.Contains(err.Error(), "must provide a positive size while creating the cache for the peer mini block body"))
 
 	args = getGoodArgs()
 	args.Config.TrieSyncStorage.Capacity = 0

epochStart/bootstrap/process_test.go

@@ -70,7 +70,7 @@ func createComponentsForEpochStart() (*mock.CoreComponentsMock, *mock.CryptoComp
 			Hash:                         &hashingMocks.HasherMock{},
 			TxSignHasherField:            &hashingMocks.HasherMock{},
 			UInt64ByteSliceConv:          &mock.Uint64ByteSliceConverterMock{},
-			AddrPubKeyConv:               &mock.PubkeyConverterMock{},
+			AddrPubKeyConv:               &testscommon.PubkeyConverterMock{},
 			PathHdl:                      &testscommon.PathManagerStub{},
 			EpochNotifierField:           &epochNotifier.EpochNotifierStub{},
 			TxVersionCheckField:          versioning.NewTxVersionChecker(1),

epochStart/bootstrap/syncEpochStartMeta_test.go

@@ -137,7 +137,7 @@ func getEpochStartSyncerArgs() ArgsNewEpochStartMetaSyncer {
 			Marsh:               &mock.MarshalizerMock{},
 			Hash:                &hashingMocks.HasherMock{},
 			UInt64ByteSliceConv: &mock.Uint64ByteSliceConverterMock{},
-			AddrPubKeyConv:      mock.NewPubkeyConverterMock(32),
+			AddrPubKeyConv:      testscommon.NewPubkeyConverterMock(32),
 			PathHdl:             &testscommon.PathManagerStub{},
 			ChainIdCalled: func() string {
 				return "chain-ID"

epochStart/metachain/baseRewards_test.go

@@ -1150,7 +1150,7 @@ func getBaseRewardsArguments() BaseRewardsCreatorArgs {
 
 	return BaseRewardsCreatorArgs{
 		ShardCoordinator:              shardCoordinator,
-		PubkeyConverter:               mock.NewPubkeyConverterMock(32),
+		PubkeyConverter:               testscommon.NewPubkeyConverterMock(32),
 		RewardsStorage:                mock.NewStorerMock(),
 		MiniBlockStorage:              mock.NewStorerMock(),
 		Hasher:                        &hashingMocks.HasherMock{},

epochStart/metachain/systemSCs_test.go

@@ -930,7 +930,7 @@ func createFullArgumentsForSystemSCProcessing(enableEpochsConfig config.EnableEp
 		ShardCoordinator:                     &mock.ShardCoordinatorStub{},
 		DataPool:                             &dataRetrieverMock.PoolsHolderStub{},
 		StorageService:                       &storageStubs.ChainStorerStub{},
-		PubkeyConv:                           &mock.PubkeyConverterMock{},
+		PubkeyConv:                           &testscommon.PubkeyConverterMock{},
 		PeerAdapter:                          peerAccountsDB,
 		Rater:                                &mock.RaterStub{},
 		RewardsHandler:                       &mock.RewardsHandlerStub{},
@@ -954,7 +954,7 @@ func createFullArgumentsForSystemSCProcessing(enableEpochsConfig config.EnableEp
 
 	argsHook := hooks.ArgBlockChainHook{
 		Accounts:              userAccountsDB,
-		PubkeyConv:            &mock.PubkeyConverterMock{},
+		PubkeyConv:            &testscommon.PubkeyConverterMock{},
 		StorageService:        &storageStubs.ChainStorerStub{},
 		BlockChain:            blockChain,
 		ShardCoordinator:      &mock.ShardCoordinatorStub{},

examples/address_test.go

@@ -21,7 +21,8 @@ func TestHexAddressToBech32Address(t *testing.T) {
 	hexEncodedAddressBytes, err := hex.DecodeString(hexEncodedAddress)
 	require.NoError(t, err)
 
-	bech32Address := addressEncoder.Encode(hexEncodedAddressBytes)
+	bech32Address, err := addressEncoder.Encode(hexEncodedAddressBytes)
+	require.NoError(t, err)
 	require.Equal(t, "erd14uqxan5rgucsf6537ll4vpwyc96z7us5586xhc5euv8w96rsw95sfl6a49", bech32Address)
 }
 
@@ -61,20 +62,31 @@ func computeShardID(t *testing.T, addressBech32 string, shardCoordinator shardin
 }
 
 func TestSystemSCsAddressesAndSpecialAddresses(t *testing.T) {
-	contractDeployScAdress := addressEncoder.Encode(make([]byte, addressEncoder.Len()))
-	stakingScAddress := addressEncoder.Encode(vm.StakingSCAddress)
-	validatorScAddress := addressEncoder.Encode(vm.ValidatorSCAddress)
-	esdtScAddress := addressEncoder.Encode(vm.ESDTSCAddress)
-	governanceScAddress := addressEncoder.Encode(vm.GovernanceSCAddress)
-	jailingAddress := addressEncoder.Encode(vm.JailingAddress)
-	endOfEpochAddress := addressEncoder.Encode(vm.EndOfEpochAddress)
-	delegationManagerScAddress := addressEncoder.Encode(vm.DelegationManagerSCAddress)
-	firstDelegationScAddress := addressEncoder.Encode(vm.FirstDelegationSCAddress)
+	contractDeployScAdress, err := addressEncoder.Encode(make([]byte, addressEncoder.Len()))
+	require.NoError(t, err)
+	stakingScAddress, err := addressEncoder.Encode(vm.StakingSCAddress)
+	require.NoError(t, err)
+	validatorScAddress, err := addressEncoder.Encode(vm.ValidatorSCAddress)
+	require.NoError(t, err)
+	esdtScAddress, err := addressEncoder.Encode(vm.ESDTSCAddress)
+	require.NoError(t, err)
+	governanceScAddress, err := addressEncoder.Encode(vm.GovernanceSCAddress)
+	require.NoError(t, err)
+	jailingAddress, err := addressEncoder.Encode(vm.JailingAddress)
+	require.NoError(t, err)
+	endOfEpochAddress, err := addressEncoder.Encode(vm.EndOfEpochAddress)
+	require.NoError(t, err)
+	delegationManagerScAddress, err := addressEncoder.Encode(vm.DelegationManagerSCAddress)
+	require.NoError(t, err)
+	firstDelegationScAddress, err := addressEncoder.Encode(vm.FirstDelegationSCAddress)
+	require.NoError(t, err)
 
 	genesisMintingAddressBytes, err := hex.DecodeString("f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0")
 	require.NoError(t, err)
-	genesisMintingAddress := addressEncoder.Encode(genesisMintingAddressBytes)
-	systemAccountAddress := addressEncoder.Encode(core.SystemAccountAddress)
+	genesisMintingAddress, err := addressEncoder.Encode(genesisMintingAddressBytes)
+	require.NoError(t, err)
+	systemAccountAddress, err := addressEncoder.Encode(core.SystemAccountAddress)
+	require.NoError(t, err)
 
 	esdtGlobalSettingsAddresses := getGlobalSettingsAddresses()
 
@@ -116,19 +128,21 @@ func TestSystemSCsAddressesAndSpecialAddresses(t *testing.T) {
 }
 
 func getGlobalSettingsAddresses() map[uint32]string {
-	computeAddress := func(shardID uint32) string {
-		baseSystemAccountAddress := core.SystemAccountAddress
-		globalSettingsAddress := baseSystemAccountAddress
-		globalSettingsAddress[len(globalSettingsAddress)-1] = uint8(shardID)
-
-		return addressEncoder.Encode(globalSettingsAddress)
-	}
-
 	numShards := uint32(3)
 	addressesMap := make(map[uint32]string, numShards)
 	for i := uint32(0); i < numShards; i++ {
-		addressesMap[i] = computeAddress(i)
+		addressesMap[i] = computeGlobalSettingsAddr(i)
 	}
 
 	return addressesMap
 }
+
+func computeGlobalSettingsAddr(shardID uint32) string {
+	baseSystemAccountAddress := core.SystemAccountAddress
+	globalSettingsAddress := baseSystemAccountAddress
+	globalSettingsAddress[len(globalSettingsAddress)-1] = uint8(shardID)
+
+	computedAddress, _ := addressEncoder.Encode(globalSettingsAddress)
+
+	return computedAddress
+}

examples/construction_test.go

@@ -7,7 +7,6 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/multiversx/mx-chain-core-go/core/mock"
 	"github.com/multiversx/mx-chain-core-go/core/pubkeyConverter"
 	"github.com/multiversx/mx-chain-core-go/data/block"
 	"github.com/multiversx/mx-chain-core-go/data/transaction"
@@ -20,7 +19,7 @@ import (
 )
 
 var (
-	addressEncoder, _  = pubkeyConverter.NewBech32PubkeyConverter(32, &mock.LoggerMock{})
+	addressEncoder, _  = pubkeyConverter.NewBech32PubkeyConverter(32, "erd")
 	signingMarshalizer = &marshal.JsonMarshalizer{}
 	signer             = &singlesig.Ed25519Signer{}
 	signingCryptoSuite = ed25519.NewEd25519()

examples/messageSign_test.go

@@ -92,7 +92,10 @@ func signMessage(t *testing.T, senderSeedHex string, message string) (string, st
 	publicKeyBytes, err := publicKey.ToByteArray()
 	require.NoError(t, err)
 
-	return addressEncoder.Encode(publicKeyBytes), hex.EncodeToString(hash), hex.EncodeToString(signature)
+	address, err := addressEncoder.Encode(publicKeyBytes)
+	require.NoError(t, err)
+
+	return address, hex.EncodeToString(hash), hex.EncodeToString(signature)
 }
 
 func computeHashForMessage(message string) []byte {

facade/nodeFacade.go

@@ -680,6 +680,7 @@ func (nf *nodeFacade) convertVmOutputToApiResponse(input *vmcommon.VMOutput) *vm
 // GetGenesisNodesPubKeys will return genesis nodes public keys by shard
 func (nf *nodeFacade) GetGenesisNodesPubKeys() (map[uint32][]string, map[uint32][]string, error) {
 	eligible, waiting := nf.apiResolver.GetGenesisNodesPubKeys()
+
 	if eligible == nil && waiting == nil {
 		return nil, nil, ErrNilGenesisNodes
 	}