diff --git a/cmd/keygenerator/converter/errors.go b/cmd/keygenerator/converter/errors.go index 8d2df8c0bb2..0f87ead7846 100644 --- a/cmd/keygenerator/converter/errors.go +++ b/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") diff --git a/cmd/keygenerator/converter/pidPubkeyConverter.go b/cmd/keygenerator/converter/pidPubkeyConverter.go index eb2928c4087..1cff0dfa0d7 100644 --- a/cmd/keygenerator/converter/pidPubkeyConverter.go +++ b/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) { diff --git a/cmd/keygenerator/converter/pidPubkeyConverter_test.go b/cmd/keygenerator/converter/pidPubkeyConverter_test.go index edf6ae4f504..e3ba947f38c 100644 --- a/cmd/keygenerator/converter/pidPubkeyConverter_test.go +++ b/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) }) } diff --git a/cmd/keygenerator/main.go b/cmd/keygenerator/main.go index f80674cf40c..1e851594250 100644 --- a/cmd/keygenerator/main.go +++ b/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, diff --git a/cmd/node/config/config.toml b/cmd/node/config/config.toml index 3e6607b8696..6e2de028ba9 100644 --- a/cmd/node/config/config.toml +++ b/cmd/node/config/config.toml @@ -601,6 +601,7 @@ Length = 32 Type = "bech32" SignatureLength = 64 + Hrp = "erd" [ValidatorPubkeyConverter] Length = 96 diff --git a/common/factory/pubkeyConverterFactory.go b/common/factory/pubkeyConverterFactory.go index b92e3c95d21..298a240669a 100644 --- a/common/factory/pubkeyConverterFactory.go +++ b/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) } diff --git a/common/factory/pubkeyConverterFactory_test.go b/common/factory/pubkeyConverterFactory_test.go index 84217a4b0b9..f5554e21e2a 100644 --- a/common/factory/pubkeyConverterFactory_test.go +++ b/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) } diff --git a/config/config.go b/config/config.go index 0731bb465dd..e5b63a75426 100644 --- a/config/config.go +++ b/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 diff --git a/config/tomlConfig_test.go b/config/tomlConfig_test.go index a3cc8c949dc..2c2173c2ee1 100644 --- a/config/tomlConfig_test.go +++ b/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" }, diff --git a/dataRetriever/factory/dataPoolFactory_test.go b/dataRetriever/factory/dataPoolFactory_test.go index 225371526d4..c9ae8b60c43 100644 --- a/dataRetriever/factory/dataPoolFactory_test.go +++ b/dataRetriever/factory/dataPoolFactory_test.go @@ -86,7 +86,7 @@ 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 @@ -94,7 +94,7 @@ 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 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 diff --git a/epochStart/bootstrap/process_test.go b/epochStart/bootstrap/process_test.go index 72b06646d32..6ac7b8899ee 100644 --- a/epochStart/bootstrap/process_test.go +++ b/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), diff --git a/epochStart/bootstrap/syncEpochStartMeta_test.go b/epochStart/bootstrap/syncEpochStartMeta_test.go index 82c640dfc13..169b20a656e 100644 --- a/epochStart/bootstrap/syncEpochStartMeta_test.go +++ b/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" diff --git a/epochStart/metachain/baseRewards_test.go b/epochStart/metachain/baseRewards_test.go index be772665a8a..c84e6b1d246 100644 --- a/epochStart/metachain/baseRewards_test.go +++ b/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{}, diff --git a/epochStart/metachain/systemSCs_test.go b/epochStart/metachain/systemSCs_test.go index 922958d0c49..8ca727ee0cb 100644 --- a/epochStart/metachain/systemSCs_test.go +++ b/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{}, diff --git a/epochStart/mock/pubkeyConverterMock.go b/epochStart/mock/pubkeyConverterMock.go deleted file mode 100644 index 2495757f430..00000000000 --- a/epochStart/mock/pubkeyConverterMock.go +++ /dev/null @@ -1,37 +0,0 @@ -package mock - -import ( - "encoding/hex" -) - -// PubkeyConverterMock - -type PubkeyConverterMock struct { - len int -} - -// NewPubkeyConverterMock - -func NewPubkeyConverterMock(addressLen int) *PubkeyConverterMock { - return &PubkeyConverterMock{ - len: addressLen, - } -} - -// Decode - -func (pcm *PubkeyConverterMock) Decode(humanReadable string) ([]byte, error) { - return hex.DecodeString(humanReadable) -} - -// Encode - -func (pcm *PubkeyConverterMock) Encode(pkBytes []byte) string { - return hex.EncodeToString(pkBytes) -} - -// Len - -func (pcm *PubkeyConverterMock) Len() int { - return pcm.len -} - -// IsInterfaceNil - -func (pcm *PubkeyConverterMock) IsInterfaceNil() bool { - return pcm == nil -} diff --git a/examples/address_test.go b/examples/address_test.go index fb7539e738d..4e47368a2b7 100644 --- a/examples/address_test.go +++ b/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 +} diff --git a/examples/construction_test.go b/examples/construction_test.go index 1c7f7f6603b..771c266f494 100644 --- a/examples/construction_test.go +++ b/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() diff --git a/examples/messageSign_test.go b/examples/messageSign_test.go index 3f0597d954a..771dfe96156 100644 --- a/examples/messageSign_test.go +++ b/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 { diff --git a/facade/nodeFacade.go b/facade/nodeFacade.go index 0c7ee09d43d..e6c44601712 100644 --- a/facade/nodeFacade.go +++ b/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 } diff --git a/factory/addressDecoder_test.go b/factory/addressDecoder_test.go index 27388ba22d0..9eb00b9a89b 100644 --- a/factory/addressDecoder_test.go +++ b/factory/addressDecoder_test.go @@ -4,10 +4,9 @@ import ( "errors" "testing" - "github.com/multiversx/mx-chain-go/process/mock" - chainError "github.com/multiversx/mx-chain-go/errors" "github.com/multiversx/mx-chain-go/factory" + "github.com/multiversx/mx-chain-go/testscommon" "github.com/stretchr/testify/assert" ) @@ -24,7 +23,7 @@ func Test_DecodeAddressesError(t *testing.T) { t.Run("decode error", func(t *testing.T) { t.Parallel() pkError := errors.New("pkerror") - pkConverter := &mock.PubkeyConverterStub{ + pkConverter := &testscommon.PubkeyConverterStub{ DecodeCalled: func(humanReadable string) ([]byte, error) { return nil, pkError }} @@ -46,7 +45,7 @@ func Test_DecodeAddressesShouldWork(t *testing.T) { decodeMap["addr1"] = decodedAddr1 decodeMap["addr2"] = decodedAddr2 - pkConverter := &mock.PubkeyConverterStub{ + pkConverter := &testscommon.PubkeyConverterStub{ DecodeCalled: func(humanReadable string) ([]byte, error) { return decodeMap[humanReadable], nil }} diff --git a/factory/core/coreComponents.go b/factory/core/coreComponents.go index d9046fba8e8..46b5a50585b 100644 --- a/factory/core/coreComponents.go +++ b/factory/core/coreComponents.go @@ -323,6 +323,11 @@ func (ccf *coreComponentsFactory) Create() (*coreComponents, error) { return nil, err } + encodedAddressLen, err := computeEncodedAddressLen(addressPubkeyConverter) + if err != nil { + return nil, err + } + return &coreComponents{ hasher: hasher, txSignHasher: txSignHasher, @@ -351,7 +356,7 @@ func (ccf *coreComponentsFactory) Create() (*coreComponents, error) { enableRoundsHandler: enableRoundsHandler, epochStartNotifierWithConfirm: notifier.NewEpochStartSubscriptionHandler(), chanStopNodeProcess: ccf.chanStopNodeProcess, - encodedAddressLen: computeEncodedAddressLen(addressPubkeyConverter), + encodedAddressLen: encodedAddressLen, nodeTypeProvider: nodeTypeProvider, wasmVMChangeLocker: wasmVMChangeLocker, processStatusHandler: statusHandler.NewProcessStatusHandler(), @@ -374,8 +379,12 @@ func (cc *coreComponents) Close() error { return nil } -func computeEncodedAddressLen(converter core.PubkeyConverter) uint32 { +func computeEncodedAddressLen(converter core.PubkeyConverter) (uint32, error) { emptyAddress := bytes.Repeat([]byte{0}, converter.Len()) - encodedEmptyAddress := converter.Encode(emptyAddress) - return uint32(len(encodedEmptyAddress)) + encodedEmptyAddress, err := converter.Encode(emptyAddress) + if err != nil { + return 0, err + } + + return uint32(len(encodedEmptyAddress)), nil } diff --git a/factory/crypto/cryptoComponents.go b/factory/crypto/cryptoComponents.go index d2fe8c74b8c..6191ed2ab32 100644 --- a/factory/crypto/cryptoComponents.go +++ b/factory/crypto/cryptoComponents.go @@ -374,7 +374,10 @@ func (ccf *cryptoComponentsFactory) readCryptoParams(keygen crypto.KeyGenerator) } } - cp.publicKeyString = ccf.validatorPubKeyConverter.Encode(cp.publicKeyBytes) + cp.publicKeyString, err = ccf.validatorPubKeyConverter.Encode(cp.publicKeyBytes) + if err != nil { + return nil, err + } return cp, nil } @@ -399,7 +402,10 @@ func (ccf *cryptoComponentsFactory) generateCryptoParams( return nil, err } - cp.publicKeyString = ccf.validatorPubKeyConverter.Encode(cp.publicKeyBytes) + cp.publicKeyString, err = ccf.validatorPubKeyConverter.Encode(cp.publicKeyBytes) + if err != nil { + return nil, err + } cp.handledPrivateKeys = handledPrivateKeys return cp, nil @@ -519,7 +525,7 @@ func (ccf *cryptoComponentsFactory) processPrivatePublicKey(keygen crypto.KeyGen if !bytes.Equal(pkGeneratedBytes, pkBytes) { return nil, fmt.Errorf("public keys mismatch, read %s, generated %s, key index %d", pkString, - ccf.validatorPubKeyConverter.Encode(pkBytes), + ccf.validatorPubKeyConverter.SilentEncode(pkBytes, log), index, ) } diff --git a/factory/mock/pubKeyConverterStub.go b/factory/mock/pubKeyConverterStub.go deleted file mode 100644 index f8ef5507235..00000000000 --- a/factory/mock/pubKeyConverterStub.go +++ /dev/null @@ -1,40 +0,0 @@ -package mock - -// PubkeyConverterStub - -type PubkeyConverterStub struct { - LenCalled func() int - DecodeCalled func(humanReadable string) ([]byte, error) - EncodeCalled func(pkBytes []byte) string -} - -// Len - -func (pcs *PubkeyConverterStub) Len() int { - if pcs.LenCalled != nil { - return pcs.LenCalled() - } - - return 0 -} - -// Decode - -func (pcs *PubkeyConverterStub) Decode(humanReadable string) ([]byte, error) { - if pcs.DecodeCalled != nil { - return pcs.DecodeCalled(humanReadable) - } - - return make([]byte, 0), nil -} - -// Encode - -func (pcs *PubkeyConverterStub) Encode(pkBytes []byte) string { - if pcs.EncodeCalled != nil { - return pcs.EncodeCalled(pkBytes) - } - - return "" -} - -// IsInterfaceNil - -func (pcs *PubkeyConverterStub) IsInterfaceNil() bool { - return pcs == nil -} diff --git a/factory/processing/processComponents.go b/factory/processing/processComponents.go index ddd81c46aad..24d35bbd61a 100644 --- a/factory/processing/processComponents.go +++ b/factory/processing/processComponents.go @@ -911,7 +911,11 @@ func (pcf *processComponentsFactory) indexAndReturnGenesisAccounts() (map[string continue } - encodedAddress := pcf.coreData.AddressPubKeyConverter().Encode(userAccount.AddressBytes()) + encodedAddress, err := pcf.coreData.AddressPubKeyConverter().Encode(userAccount.AddressBytes()) + if err != nil { + return nil, err + } + genesisAccounts[encodedAddress] = &outport.AlteredAccount{ AdditionalData: &outport.AdditionalAccountData{ BalanceChanged: true, @@ -1122,6 +1126,7 @@ func (pcf *processComponentsFactory) indexGenesisBlocks( // manually add the genesis minting address as it is not exist in the trie genesisAddress := pcf.accountsParser.GenesisMintingAddress() + alteredAccounts[genesisAddress] = &outport.AlteredAccount{ Address: genesisAddress, Balance: "0", diff --git a/genesis/checking/nodesSetupChecker.go b/genesis/checking/nodesSetupChecker.go index a228e28daf9..3bf028c9773 100644 --- a/genesis/checking/nodesSetupChecker.go +++ b/genesis/checking/nodesSetupChecker.go @@ -10,12 +10,15 @@ import ( crypto "github.com/multiversx/mx-chain-crypto-go" "github.com/multiversx/mx-chain-go/genesis" "github.com/multiversx/mx-chain-go/sharding/nodesCoordinator" + logger "github.com/multiversx/mx-chain-logger-go" ) const minimumAcceptedNodePrice = 0 var zero = big.NewInt(0) +var log = logger.GetOrCreate("genesis/checking") + type nodeSetupChecker struct { accountsParser genesis.AccountsParser initialNodePrice *big.Int @@ -64,7 +67,7 @@ func NewNodesSetupChecker( // also, it checks that the amount staked (either directly or delegated) matches exactly the total // staked value defined in the genesis file func (nsc *nodeSetupChecker) Check(initialNodes []nodesCoordinator.GenesisNodeInfoHandler) error { - err := nsc.ckeckGenesisNodes(initialNodes) + err := nsc.checkGenesisNodes(initialNodes) if err != nil { return err } @@ -79,13 +82,15 @@ func (nsc *nodeSetupChecker) Check(initialNodes []nodesCoordinator.GenesisNodeIn return nsc.checkRemainderInitialAccounts(initialAccounts, delegated) } -func (nsc *nodeSetupChecker) ckeckGenesisNodes(initialNodes []nodesCoordinator.GenesisNodeInfoHandler) error { +func (nsc *nodeSetupChecker) checkGenesisNodes(initialNodes []nodesCoordinator.GenesisNodeInfoHandler) error { for _, node := range initialNodes { err := nsc.keyGenerator.CheckPublicKeyValid(node.PubKeyBytes()) if err != nil { + validatorPubkeyEncodedAddr := nsc.validatorPubkeyConverter.SilentEncode(node.PubKeyBytes(), log) + return fmt.Errorf("%w for node's public key `%s`, error: %s", genesis.ErrInvalidPubKey, - nsc.validatorPubkeyConverter.Encode(node.PubKeyBytes()), + validatorPubkeyEncodedAddr, err.Error(), ) } @@ -113,8 +118,10 @@ func (nsc *nodeSetupChecker) traverseInitialNodesSubtractingStakedValue( for _, initialNode := range initialNodes { err := nsc.subtractStakedValue(initialNode.AddressBytes(), initialAccounts, delegated) if err != nil { + validatorPubkeyEncoded := nsc.validatorPubkeyConverter.SilentEncode(initialNode.PubKeyBytes(), log) + return fmt.Errorf("'%w' while processing node pubkey %s", - err, nsc.validatorPubkeyConverter.Encode(initialNode.PubKeyBytes())) + err, validatorPubkeyEncoded) } } diff --git a/genesis/checking/nodesSetupChecker_test.go b/genesis/checking/nodesSetupChecker_test.go index 592f2138720..cf318e34e95 100644 --- a/genesis/checking/nodesSetupChecker_test.go +++ b/genesis/checking/nodesSetupChecker_test.go @@ -11,6 +11,7 @@ import ( "github.com/multiversx/mx-chain-go/genesis/data" "github.com/multiversx/mx-chain-go/genesis/mock" "github.com/multiversx/mx-chain-go/sharding/nodesCoordinator" + "github.com/multiversx/mx-chain-go/testscommon" "github.com/stretchr/testify/assert" ) @@ -35,7 +36,7 @@ func TestNewNodesSetupChecker_NilGenesisParserShouldErr(t *testing.T) { nsc, err := checking.NewNodesSetupChecker( nil, big.NewInt(0), - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), &mock.KeyGeneratorStub{}, ) @@ -49,7 +50,7 @@ func TestNewNodesSetupChecker_NilInitialNodePriceShouldErr(t *testing.T) { nsc, err := checking.NewNodesSetupChecker( &mock.AccountsParserStub{}, nil, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), &mock.KeyGeneratorStub{}, ) @@ -63,7 +64,7 @@ func TestNewNodesSetupChecker_InvalidInitialNodePriceShouldErr(t *testing.T) { nsc, err := checking.NewNodesSetupChecker( &mock.AccountsParserStub{}, big.NewInt(-1), - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), &mock.KeyGeneratorStub{}, ) @@ -91,7 +92,7 @@ func TestNewNodesSetupChecker_NilKeyGeneratorShouldErr(t *testing.T) { nsc, err := checking.NewNodesSetupChecker( &mock.AccountsParserStub{}, big.NewInt(0), - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), nil, ) @@ -105,7 +106,7 @@ func TestNewNodesSetupChecker_ShouldWork(t *testing.T) { nsc, err := checking.NewNodesSetupChecker( &mock.AccountsParserStub{}, big.NewInt(0), - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), &mock.KeyGeneratorStub{}, ) @@ -129,7 +130,7 @@ func TestNewNodesSetupChecker_CheckNotAValidPubkeyShouldErr(t *testing.T) { }, }, big.NewInt(0), - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), &mock.KeyGeneratorStub{ CheckPublicKeyValidCalled: func(b []byte) error { return expectedErr @@ -163,7 +164,7 @@ func TestNewNodeSetupChecker_CheckNotStakedShouldErr(t *testing.T) { }, }, big.NewInt(0), - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), &mock.KeyGeneratorStub{}, ) @@ -195,7 +196,7 @@ func TestNewNodeSetupChecker_CheckNotEnoughStakedShouldErr(t *testing.T) { }, }, big.NewInt(nodePrice.Int64()+1), - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), &mock.KeyGeneratorStub{}, ) @@ -227,7 +228,7 @@ func TestNewNodeSetupChecker_CheckTooMuchStakedShouldErr(t *testing.T) { }, }, big.NewInt(nodePrice.Int64()-1), - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), &mock.KeyGeneratorStub{}, ) @@ -259,7 +260,7 @@ func TestNewNodeSetupChecker_CheckNotEnoughDelegatedShouldErr(t *testing.T) { }, }, big.NewInt(nodePrice.Int64()+1), - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), &mock.KeyGeneratorStub{}, ) @@ -291,7 +292,7 @@ func TestNewNodeSetupChecker_CheckTooMuchDelegatedShouldErr(t *testing.T) { }, }, big.NewInt(nodePrice.Int64()-1), - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), &mock.KeyGeneratorStub{}, ) @@ -327,7 +328,7 @@ func TestNewNodeSetupChecker_CheckStakedAndDelegatedShouldWork(t *testing.T) { }, }, nodePrice, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), &mock.KeyGeneratorStub{}, ) diff --git a/genesis/mock/pubkeyConverterMock.go b/genesis/mock/pubkeyConverterMock.go deleted file mode 100644 index 2495757f430..00000000000 --- a/genesis/mock/pubkeyConverterMock.go +++ /dev/null @@ -1,37 +0,0 @@ -package mock - -import ( - "encoding/hex" -) - -// PubkeyConverterMock - -type PubkeyConverterMock struct { - len int -} - -// NewPubkeyConverterMock - -func NewPubkeyConverterMock(addressLen int) *PubkeyConverterMock { - return &PubkeyConverterMock{ - len: addressLen, - } -} - -// Decode - -func (pcm *PubkeyConverterMock) Decode(humanReadable string) ([]byte, error) { - return hex.DecodeString(humanReadable) -} - -// Encode - -func (pcm *PubkeyConverterMock) Encode(pkBytes []byte) string { - return hex.EncodeToString(pkBytes) -} - -// Len - -func (pcm *PubkeyConverterMock) Len() int { - return pcm.len -} - -// IsInterfaceNil - -func (pcm *PubkeyConverterMock) IsInterfaceNil() bool { - return pcm == nil -} diff --git a/genesis/mock/pubkeyConverterStub.go b/genesis/mock/pubkeyConverterStub.go deleted file mode 100644 index f8ef5507235..00000000000 --- a/genesis/mock/pubkeyConverterStub.go +++ /dev/null @@ -1,40 +0,0 @@ -package mock - -// PubkeyConverterStub - -type PubkeyConverterStub struct { - LenCalled func() int - DecodeCalled func(humanReadable string) ([]byte, error) - EncodeCalled func(pkBytes []byte) string -} - -// Len - -func (pcs *PubkeyConverterStub) Len() int { - if pcs.LenCalled != nil { - return pcs.LenCalled() - } - - return 0 -} - -// Decode - -func (pcs *PubkeyConverterStub) Decode(humanReadable string) ([]byte, error) { - if pcs.DecodeCalled != nil { - return pcs.DecodeCalled(humanReadable) - } - - return make([]byte, 0), nil -} - -// Encode - -func (pcs *PubkeyConverterStub) Encode(pkBytes []byte) string { - if pcs.EncodeCalled != nil { - return pcs.EncodeCalled(pkBytes) - } - - return "" -} - -// IsInterfaceNil - -func (pcs *PubkeyConverterStub) IsInterfaceNil() bool { - return pcs == nil -} diff --git a/genesis/parsing/accountsParser.go b/genesis/parsing/accountsParser.go index 0dd183b1088..1dd7f7b1966 100644 --- a/genesis/parsing/accountsParser.go +++ b/genesis/parsing/accountsParser.go @@ -19,8 +19,11 @@ import ( "github.com/multiversx/mx-chain-go/genesis" "github.com/multiversx/mx-chain-go/genesis/data" "github.com/multiversx/mx-chain-go/sharding" + logger "github.com/multiversx/mx-chain-logger-go" ) +var log = logger.GetOrCreate("genesis/parsing") + // accountsParser hold data for initial accounts decoded data from json file type accountsParser struct { initialAccounts []*data.InitialAccount @@ -252,7 +255,7 @@ func (ap *accountsParser) InitialAccounts() []genesis.InitialAccountHandler { // GenesisMintingAddress returns the encoded genesis minting address func (ap *accountsParser) GenesisMintingAddress() string { - return ap.pubkeyConverter.Encode(ap.minterAddressBytes) + return ap.pubkeyConverter.SilentEncode(ap.minterAddressBytes, log) } // InitialAccountsSplitOnAddressesShards gets the initial accounts of the nodes split on the addresses' shards diff --git a/genesis/parsing/accountsParser_test.go b/genesis/parsing/accountsParser_test.go index 3692f0413f4..ca45b0f3649 100644 --- a/genesis/parsing/accountsParser_test.go +++ b/genesis/parsing/accountsParser_test.go @@ -20,6 +20,7 @@ import ( "github.com/multiversx/mx-chain-go/genesis/data" "github.com/multiversx/mx-chain-go/genesis/mock" "github.com/multiversx/mx-chain-go/genesis/parsing" + "github.com/multiversx/mx-chain-go/testscommon" "github.com/multiversx/mx-chain-go/testscommon/hashingMocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -38,8 +39,8 @@ func createMockInitialAccount() *data.InitialAccount { } } -func createMockHexPubkeyConverter() *mock.PubkeyConverterStub { - return &mock.PubkeyConverterStub{ +func createMockHexPubkeyConverter() *testscommon.PubkeyConverterStub { + return &testscommon.PubkeyConverterStub{ DecodeCalled: func(humanReadable string) ([]byte, error) { return hex.DecodeString(humanReadable) }, diff --git a/genesis/process/genesisBlockCreator.go b/genesis/process/genesisBlockCreator.go index ba898b40414..bbd772e4c6c 100644 --- a/genesis/process/genesisBlockCreator.go +++ b/genesis/process/genesisBlockCreator.go @@ -464,7 +464,12 @@ func (gbc *genesisBlockCreator) computeDNSAddresses(enableEpochsConfig config.En } dnsSC.AddAddressBytes(scResultingAddress) - dnsSC.AddAddress(gbc.arg.Core.AddressPubKeyConverter().Encode(scResultingAddress)) + + encodedSCResultingAddress, err := gbc.arg.Core.AddressPubKeyConverter().Encode(scResultingAddress) + if err != nil { + return err + } + dnsSC.AddAddress(encodedSCResultingAddress) } return nil diff --git a/genesis/process/genesisBlockCreator_test.go b/genesis/process/genesisBlockCreator_test.go index 067412c9aad..25b07f55eca 100644 --- a/genesis/process/genesisBlockCreator_test.go +++ b/genesis/process/genesisBlockCreator_test.go @@ -63,7 +63,7 @@ func createMockArgument( TxMarsh: &mock.MarshalizerMock{}, Hash: &hashingMocks.HasherMock{}, UInt64ByteSliceConv: &mock.Uint64ByteSliceConverterMock{}, - AddrPubKeyConv: mock.NewPubkeyConverterMock(32), + AddrPubKeyConv: testscommon.NewPubkeyConverterMock(32), Chain: "chainID", MinTxVersion: 1, EnableEpochsHandlerField: &testscommon.EnableEpochsHandlerStub{}, diff --git a/genesis/process/intermediate/baseDeploy.go b/genesis/process/intermediate/baseDeploy.go index df09baaa9b6..79d03c408d8 100644 --- a/genesis/process/intermediate/baseDeploy.go +++ b/genesis/process/intermediate/baseDeploy.go @@ -23,17 +23,17 @@ type baseDeploy struct { func (dp *baseDeploy) deployForOneAddress( sc genesis.InitialSmartContractHandler, - ownerAddress []byte, + ownerAddressBytes []byte, code string, initParams string, ) ([]byte, error) { - nonce, err := dp.GetNonce(ownerAddress) + nonce, err := dp.GetNonce(ownerAddressBytes) if err != nil { return nil, err } scResultingAddressBytes, err := dp.blockchainHook.NewAddress( - ownerAddress, + ownerAddressBytes, nonce, sc.VmTypeBytes(), ) @@ -42,7 +42,12 @@ func (dp *baseDeploy) deployForOneAddress( } sc.AddAddressBytes(scResultingAddressBytes) - sc.AddAddress(dp.pubkeyConv.Encode(scResultingAddressBytes)) + + scResultingAddress, err := dp.pubkeyConv.Encode(scResultingAddressBytes) + if err != nil { + return nil, err + } + sc.AddAddress(scResultingAddress) vmType := sc.GetVmType() arguments := []string{code, vmType, codeMetadataHexForInitialSC} @@ -53,7 +58,7 @@ func (dp *baseDeploy) deployForOneAddress( log.Trace("deploying genesis SC", "SC owner", sc.GetOwner(), - "SC ownerAddress", dp.pubkeyConv.Encode(scResultingAddressBytes), + "SC ownerAddress", scResultingAddress, "type", sc.GetType(), "VM type", sc.GetVmType(), "init params", initParams, @@ -64,14 +69,14 @@ func (dp *baseDeploy) deployForOneAddress( return nil, fmt.Errorf("%w for SC ownerAddress %s, owner %s with nonce %d", genesis.ErrAccountAlreadyExists, scResultingAddressBytes, - ownerAddress, + ownerAddressBytes, nonce, ) } err = dp.ExecuteTransaction( nonce, - ownerAddress, + ownerAddressBytes, dp.emptyAddress, big.NewInt(0), []byte(deployTxData), @@ -80,12 +85,17 @@ func (dp *baseDeploy) deployForOneAddress( return nil, err } + ownerAddress, err := dp.pubkeyConv.Encode(ownerAddressBytes) + if err != nil { + return nil, err + } + _, accountExists = dp.GetAccount(scResultingAddressBytes) if !accountExists { return nil, fmt.Errorf("%w for SC ownerAddress %s, owner %s with nonce %d", genesis.ErrAccountNotCreated, - dp.pubkeyConv.Encode(scResultingAddressBytes), - dp.pubkeyConv.Encode(ownerAddress), + scResultingAddress, + ownerAddress, nonce, ) } diff --git a/genesis/process/intermediate/deployProcessor_test.go b/genesis/process/intermediate/deployProcessor_test.go index ae8237d0d7f..21b0e25d5d8 100644 --- a/genesis/process/intermediate/deployProcessor_test.go +++ b/genesis/process/intermediate/deployProcessor_test.go @@ -20,7 +20,7 @@ import ( func createMockDeployArg() ArgDeployProcessor { return ArgDeployProcessor{ Executor: &mock.TxExecutionProcessorStub{}, - PubkeyConv: mock.NewPubkeyConverterMock(32), + PubkeyConv: testscommon.NewPubkeyConverterMock(32), BlockchainHook: &testscommon.BlockChainHookStub{}, QueryService: &mock.QueryServiceStub{}, } diff --git a/go.mod b/go.mod index 1bfd5fb044f..9b517bd4136 100644 --- a/go.mod +++ b/go.mod @@ -13,13 +13,13 @@ require ( github.com/google/gops v0.3.18 github.com/gorilla/websocket v1.5.0 github.com/mitchellh/mapstructure v1.5.0 - github.com/multiversx/mx-chain-core-go v1.1.35 + github.com/multiversx/mx-chain-core-go v1.2.0 github.com/multiversx/mx-chain-crypto-go v1.2.5 - github.com/multiversx/mx-chain-es-indexer-go v1.3.13 + github.com/multiversx/mx-chain-es-indexer-go v1.4.0 github.com/multiversx/mx-chain-logger-go v1.0.11 github.com/multiversx/mx-chain-p2p-go v1.0.13 github.com/multiversx/mx-chain-storage-go v1.0.7 - github.com/multiversx/mx-chain-vm-common-go v1.3.37 + github.com/multiversx/mx-chain-vm-common-go v1.4.0 github.com/multiversx/mx-chain-vm-v1_2-go v1.2.50 github.com/multiversx/mx-chain-vm-v1_3-go v1.3.51 github.com/multiversx/mx-chain-vm-v1_4-go v1.4.77 @@ -69,7 +69,7 @@ require ( github.com/gorilla/mux v1.8.0 // indirect github.com/hashicorp/errwrap v1.0.0 // indirect github.com/hashicorp/go-multierror v1.1.1 // indirect - github.com/hashicorp/golang-lru v0.5.4 // indirect + github.com/hashicorp/golang-lru v0.6.0 // indirect github.com/herumi/bls-go-binary v1.0.0 // indirect github.com/huin/goupnp v1.0.3 // indirect github.com/ipfs/go-cid v0.2.0 // indirect diff --git a/go.sum b/go.sum index ce133741b45..04d06edd375 100644 --- a/go.sum +++ b/go.sum @@ -320,8 +320,9 @@ github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+l github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc= github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= +github.com/hashicorp/golang-lru v0.6.0 h1:uL2shRDx7RTrOrTCUZEGP/wJUFiUI8QT6E7z5o8jga4= +github.com/hashicorp/golang-lru v0.6.0/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= github.com/herumi/bls-go-binary v1.0.0 h1:PRPF6vPd35zyDy+tp86HwNnGdufCH2lZL0wZGxYvkRs= github.com/herumi/bls-go-binary v1.0.0/go.mod h1:O4Vp1AfR4raRGwFeQpr9X/PQtncEicMoOe6BQt1oX0Y= @@ -610,22 +611,22 @@ github.com/multiversx/concurrent-map v0.1.4 h1:hdnbM8VE4b0KYJaGY5yJS2aNIW9TFFsUY github.com/multiversx/concurrent-map v0.1.4/go.mod h1:8cWFRJDOrWHOTNSqgYCUvwT7c7eFQ4U2vKMOp4A/9+o= github.com/multiversx/mx-chain-core-go v1.1.30/go.mod h1:8gGEQv6BWuuJwhd25qqhCOZbBSv9mk+hLeKvinSaSMk= github.com/multiversx/mx-chain-core-go v1.1.31/go.mod h1:8gGEQv6BWuuJwhd25qqhCOZbBSv9mk+hLeKvinSaSMk= -github.com/multiversx/mx-chain-core-go v1.1.35 h1:pzYXfYgCXiPXszZiS7POevE1W4ZaToVD65hbJMRiui4= -github.com/multiversx/mx-chain-core-go v1.1.35/go.mod h1:8gGEQv6BWuuJwhd25qqhCOZbBSv9mk+hLeKvinSaSMk= +github.com/multiversx/mx-chain-core-go v1.2.0 h1:K539hKZKcHjBiFQpowFbA3BUd95Fe5+FLC+rKBOFZF0= +github.com/multiversx/mx-chain-core-go v1.2.0/go.mod h1:8gGEQv6BWuuJwhd25qqhCOZbBSv9mk+hLeKvinSaSMk= github.com/multiversx/mx-chain-crypto-go v1.2.5 h1:tuq3BUNMhKud5DQbZi9DiVAAHUXypizy8zPH0NpTGZk= github.com/multiversx/mx-chain-crypto-go v1.2.5/go.mod h1:teqhNyWEqfMPgNn8sgWXlgtJ1a36jGCnhs/tRpXW6r4= -github.com/multiversx/mx-chain-es-indexer-go v1.3.13 h1:n32q0Xe6YfUIjfK3ryKe70WnsBQseaDrwb2tGDpTTAk= -github.com/multiversx/mx-chain-es-indexer-go v1.3.13/go.mod h1:IV42GfhkqQ5vVO0OzGaF/ejp8TQrLkNo4LSB3TPnVhg= +github.com/multiversx/mx-chain-es-indexer-go v1.4.0 h1:t2UCfbLRbFPBWK1IC1/qOVg+2D6y189xZZ1BoV83gq8= +github.com/multiversx/mx-chain-es-indexer-go v1.4.0/go.mod h1:3glMXvE42VvLlUdiMMtQoDr6uKYS6RGb0icRgyAGXIY= github.com/multiversx/mx-chain-logger-go v1.0.11 h1:DFsHa+sc5fKwhDR50I8uBM99RTDTEW68ESyr5ALRDwE= github.com/multiversx/mx-chain-logger-go v1.0.11/go.mod h1:1srDkP0DQucWQ+rYfaq0BX2qLnULsUdRPADpYUTM6dA= github.com/multiversx/mx-chain-p2p-go v1.0.13 h1:woIlYkDFCKYyJQ5urDcOzz8HUFGsSEhTfUXDDxNI2zM= github.com/multiversx/mx-chain-p2p-go v1.0.13/go.mod h1:j9Ueo2ptCnL7TQvQg6KS/KWAoJEJpjkPgE5ZTaqEAn4= github.com/multiversx/mx-chain-storage-go v1.0.7 h1:UqLo/OLTD3IHiE/TB/SEdNRV1GG2f1R6vIP5ehHwCNw= github.com/multiversx/mx-chain-storage-go v1.0.7/go.mod h1:gtKoV32Cg2Uy8deHzF8Ud0qAl0zv92FvWgPSYIP0Zmg= -github.com/multiversx/mx-chain-vm-common-go v1.3.34/go.mod h1:sZ2COLCxvf2GxAAJHGmGqWybObLtFuk2tZUyGqnMXE8= github.com/multiversx/mx-chain-vm-common-go v1.3.36/go.mod h1:sZ2COLCxvf2GxAAJHGmGqWybObLtFuk2tZUyGqnMXE8= -github.com/multiversx/mx-chain-vm-common-go v1.3.37 h1:KeK6JCjeNUOHC5Z12/CTQIa8Z1at0dnnL9hY1LNrHS8= github.com/multiversx/mx-chain-vm-common-go v1.3.37/go.mod h1:sZ2COLCxvf2GxAAJHGmGqWybObLtFuk2tZUyGqnMXE8= +github.com/multiversx/mx-chain-vm-common-go v1.4.0 h1:0i0cJZJOXGzqYzwtKFHSr2yGmnFAdizOuISK8HgsnYo= +github.com/multiversx/mx-chain-vm-common-go v1.4.0/go.mod h1:odBJC92ANA8zLtPh/wwajUUGJOaS88F5QYGf0t8Wgzw= github.com/multiversx/mx-chain-vm-v1_2-go v1.2.50 h1:ScUq7/wq78vthMTQ6v5Ux1DvSMQMHxQ2Sl7aPP26q1w= github.com/multiversx/mx-chain-vm-v1_2-go v1.2.50/go.mod h1:e3uYdgoKzs3puaznbmSjDcRisJc5Do4tpg7VqyYwoek= github.com/multiversx/mx-chain-vm-v1_3-go v1.3.51 h1:axtp5/mpA+xYJ1cu4KtAGETV4t6v6/tNfQh0HCclBYY= @@ -810,7 +811,6 @@ github.com/ugorji/go/codec v1.2.9 h1:rmenucSohSTiyL09Y+l2OCk+FrMxGMzho2+tjr5ticU github.com/ugorji/go/codec v1.2.9/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= github.com/urfave/cli v1.22.5/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= -github.com/urfave/cli v1.22.9/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= github.com/urfave/cli v1.22.10 h1:p8Fspmz3iTctJstry1PYS3HVdllxnEzTEsgIgtxTrCk= github.com/urfave/cli v1.22.10/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= github.com/viant/assertly v0.4.8/go.mod h1:aGifi++jvCrUaklKEKT0BU95igDNaqkvz+49uaYMPRU= diff --git a/heartbeat/mock/pubkeyConverterMock.go b/heartbeat/mock/pubkeyConverterMock.go deleted file mode 100644 index 2495757f430..00000000000 --- a/heartbeat/mock/pubkeyConverterMock.go +++ /dev/null @@ -1,37 +0,0 @@ -package mock - -import ( - "encoding/hex" -) - -// PubkeyConverterMock - -type PubkeyConverterMock struct { - len int -} - -// NewPubkeyConverterMock - -func NewPubkeyConverterMock(addressLen int) *PubkeyConverterMock { - return &PubkeyConverterMock{ - len: addressLen, - } -} - -// Decode - -func (pcm *PubkeyConverterMock) Decode(humanReadable string) ([]byte, error) { - return hex.DecodeString(humanReadable) -} - -// Encode - -func (pcm *PubkeyConverterMock) Encode(pkBytes []byte) string { - return hex.EncodeToString(pkBytes) -} - -// Len - -func (pcm *PubkeyConverterMock) Len() int { - return pcm.len -} - -// IsInterfaceNil - -func (pcm *PubkeyConverterMock) IsInterfaceNil() bool { - return pcm == nil -} diff --git a/heartbeat/monitor/monitor.go b/heartbeat/monitor/monitor.go index 671b594d295..94c4ad91800 100644 --- a/heartbeat/monitor/monitor.go +++ b/heartbeat/monitor/monitor.go @@ -169,10 +169,13 @@ func (monitor *heartbeatV2Monitor) parseMessage(pid core.PeerID, message interfa return nil, fmt.Errorf("%w, messageAge %v", heartbeat.ErrShouldSkipValidator, messageAge) } - pkHexString := monitor.pubKeyConverter.Encode(heartbeatV2.GetPubkey()) + encodedPubKey, err := monitor.pubKeyConverter.Encode(heartbeatV2.GetPubkey()) + if err != nil { + return nil, err + } pubKeyHeartbeat := &data.PubKeyHeartbeat{ - PublicKey: pkHexString, + PublicKey: encodedPubKey, TimeStamp: messageTime, IsActive: monitor.isActive(messageAge), ReceivedShardID: monitor.shardId, diff --git a/integrationTests/consensus/consensus_test.go b/integrationTests/consensus/consensus_test.go index c3c72cb3c2e..f2530e562a7 100644 --- a/integrationTests/consensus/consensus_test.go +++ b/integrationTests/consensus/consensus_test.go @@ -336,10 +336,12 @@ func displayAndStartNodes(shardID uint32, nodes []*integrationTests.TestConsensu skBuff, _ := n.NodeKeys.Sk.ToByteArray() pkBuff, _ := n.NodeKeys.Pk.ToByteArray() + encodedNodePkBuff := testPubkeyConverter.SilentEncode(pkBuff, log) + fmt.Printf("Shard ID: %v, sk: %s, pk: %s\n", shardID, hex.EncodeToString(skBuff), - testPubkeyConverter.Encode(pkBuff), + encodedNodePkBuff, ) } } diff --git a/integrationTests/constants.go b/integrationTests/constants.go index 73b2f7f29cb..69cf3ce77d9 100644 --- a/integrationTests/constants.go +++ b/integrationTests/constants.go @@ -6,3 +6,6 @@ const ShardTopic = "shard" // GlobalTopic is a global testing that all nodes will bind an interceptor const GlobalTopic = "global" + +// AddressPrefix is a global testing const +const AddressHrp = "erd" diff --git a/integrationTests/frontend/wallet/dataField_test.go b/integrationTests/frontend/wallet/dataField_test.go index e0565cb5a2c..1745db15d17 100644 --- a/integrationTests/frontend/wallet/dataField_test.go +++ b/integrationTests/frontend/wallet/dataField_test.go @@ -7,11 +7,10 @@ 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/transaction" "github.com/multiversx/mx-chain-core-go/marshal" - "github.com/multiversx/mx-chain-crypto-go" + crypto "github.com/multiversx/mx-chain-crypto-go" "github.com/multiversx/mx-chain-crypto-go/signing" "github.com/multiversx/mx-chain-crypto-go/signing/ed25519" "github.com/multiversx/mx-chain-go/integrationTests" @@ -60,6 +59,7 @@ func TestTxDataFieldContainingUTF8Characters(t *testing.T) { } sig1 := sign(tx1, singleSigner, sk) + sig2 := sign(tx2, singleSigner, sk) fmt.Println("sig1: " + hex.EncodeToString(sig1)) @@ -70,13 +70,17 @@ func TestTxDataFieldContainingUTF8Characters(t *testing.T) { func sign(tx *transaction.Transaction, signer crypto.SingleSigner, sk crypto.PrivateKey) []byte { marshalizer := &marshal.JsonMarshalizer{} - converter, _ := pubkeyConverter.NewBech32PubkeyConverter(32, &mock.LoggerMock{}) + converter, _ := pubkeyConverter.NewBech32PubkeyConverter(32, "erd") + + receiverAddress, _ := converter.Encode(tx.RcvAddr) + + senderAddress, _ := converter.Encode(tx.SndAddr) ftx := &transaction.FrontendTransaction{ Nonce: tx.Nonce, Value: tx.Value.String(), - Receiver: converter.Encode(tx.RcvAddr), - Sender: converter.Encode(tx.RcvAddr), + Receiver: receiverAddress, + Sender: senderAddress, SenderUsername: nil, ReceiverUsername: nil, GasPrice: tx.GasPrice, diff --git a/integrationTests/multiShard/smartContract/dns/dns_test.go b/integrationTests/multiShard/smartContract/dns/dns_test.go index 33e4a07bb3b..63d7ce13a60 100644 --- a/integrationTests/multiShard/smartContract/dns/dns_test.go +++ b/integrationTests/multiShard/smartContract/dns/dns_test.go @@ -252,7 +252,9 @@ func checkUserNamesAreSetCorrectly( assert.Equal(t, userNames[i], string(userAcc.GetUserName())) bech32c := integrationTests.TestAddressPubkeyConverter - usernameReportedByNode, _, err := node.Node.GetUsername(bech32c.Encode(player.Address), api.AccountQueryOptions{}) + playerAddress, err := bech32c.Encode(player.Address) + require.NoError(t, err) + usernameReportedByNode, _, err := node.Node.GetUsername(playerAddress, api.AccountQueryOptions{}) require.NoError(t, err) require.Equal(t, userNames[i], usernameReportedByNode) } diff --git a/integrationTests/multiShard/softfork/scDeploy_test.go b/integrationTests/multiShard/softfork/scDeploy_test.go index 2f719ae9658..12aca01e166 100644 --- a/integrationTests/multiShard/softfork/scDeploy_test.go +++ b/integrationTests/multiShard/softfork/scDeploy_test.go @@ -96,7 +96,9 @@ func TestScDeploy(t *testing.T) { time.Sleep(integrationTests.StepDelay) } - log.Info("resulted sc address (failed)", "address", integrationTests.TestAddressPubkeyConverter.Encode(deployedFailedAddress)) + encodedDeployFailedAddr, err := integrationTests.TestAddressPubkeyConverter.Encode(deployedFailedAddress) + assert.Nil(t, err) + log.Info("resulted sc address (failed)", "address", encodedDeployFailedAddr) assert.False(t, scAccountExists(shardNode, deployedFailedAddress)) deploySucceeded := deploySc(t, nodes) @@ -109,7 +111,9 @@ func TestScDeploy(t *testing.T) { time.Sleep(integrationTests.StepDelay) } - log.Info("resulted sc address (success)", "address", integrationTests.TestAddressPubkeyConverter.Encode(deploySucceeded)) + encodedDeploySucceededAddr, err := integrationTests.TestAddressPubkeyConverter.Encode(deploySucceeded) + assert.Nil(t, err) + log.Info("resulted sc address (success)", "address", encodedDeploySucceededAddr) assert.True(t, scAccountExists(shardNode, deploySucceeded)) } diff --git a/integrationTests/multiShard/transaction/interceptedResolvedBulkTx/interceptedResolvedBulkTx_test.go b/integrationTests/multiShard/transaction/interceptedResolvedBulkTx/interceptedResolvedBulkTx_test.go index 339fe461278..1ceb0d6cdaf 100644 --- a/integrationTests/multiShard/transaction/interceptedResolvedBulkTx/interceptedResolvedBulkTx_test.go +++ b/integrationTests/multiShard/transaction/interceptedResolvedBulkTx/interceptedResolvedBulkTx_test.go @@ -51,7 +51,8 @@ func TestNode_InterceptorBulkTxsSentFromSameShardShouldRemainInSenderShard(t *te fmt.Println("Generating and broadcasting transactions...") _, pkInShardFive, _ := integrationTests.GenerateSkAndPkInShard(generateCoordinator, shardId) pkBytes, _ := pkInShardFive.ToByteArray() - addrInShardFive := integrationTests.TestAddressPubkeyConverter.Encode(pkBytes) + addrInShardFive, err := integrationTests.TestAddressPubkeyConverter.Encode(pkBytes) + assert.Nil(t, err) idxSender := 0 shardId = nodes[idxSender].ShardCoordinator.SelfId() @@ -136,7 +137,8 @@ func TestNode_InterceptorBulkTxsSentFromOtherShardShouldBeRoutedInSenderShard(t _, pkInShardFive, _ := integrationTests.GenerateSkAndPkInShard(generateCoordinator, shardId) pkBytes, _ := pkInShardFive.ToByteArray() - addrInShardFive := integrationTests.TestAddressPubkeyConverter.Encode(pkBytes) + addrInShardFive, err := integrationTests.TestAddressPubkeyConverter.Encode(pkBytes) + assert.Nil(t, err) idxSender := 0 shardId = uint32(4) @@ -241,7 +243,8 @@ func TestNode_InterceptorBulkTxsSentFromOtherShardShouldBeRoutedInSenderShardAnd _, pkInShardFive, _ := integrationTests.GenerateSkAndPkInShard(generateCoordinator, 5) pkBytes, _ := pkInShardFive.ToByteArray() - addrInShardFive := integrationTests.TestAddressPubkeyConverter.Encode(pkBytes) + addrInShardFive, err := integrationTests.TestAddressPubkeyConverter.Encode(pkBytes) + assert.Nil(t, err) mutGeneratedTxHashes := sync.Mutex{} generatedTxHashes := make([][]byte, 0) diff --git a/integrationTests/multiShard/txScenarios/moveBalance_test.go b/integrationTests/multiShard/txScenarios/moveBalance_test.go index 7cd81d0e017..5df383f7ebb 100644 --- a/integrationTests/multiShard/txScenarios/moveBalance_test.go +++ b/integrationTests/multiShard/txScenarios/moveBalance_test.go @@ -5,7 +5,6 @@ import ( "testing" "time" - "github.com/multiversx/mx-chain-core-go/core/mock" "github.com/multiversx/mx-chain-core-go/core/pubkeyConverter" "github.com/multiversx/mx-chain-go/integrationTests" "github.com/multiversx/mx-chain-go/vm" @@ -33,7 +32,8 @@ func TestTransaction_TransactionMoveBalanceScenarios(t *testing.T) { // shard 1 bechAddrShard1 := "erd1qhmhf5grwtep3n6ynkpz5u5lxw8n2s38yuq9ge8950lc0zqlwkfs3cus7a" - bech32, _ := pubkeyConverter.NewBech32PubkeyConverter(32, &mock.LoggerMock{}) + bech32, err := pubkeyConverter.NewBech32PubkeyConverter(32, integrationTests.AddressHrp) + assert.Nil(t, err) receiverAddress, _ := bech32.Decode(bechAddrShard1) senderShardID := nodes[0].ShardCoordinator.ComputeId(players[0].Address) diff --git a/integrationTests/node/getAccount/getAccount_test.go b/integrationTests/node/getAccount/getAccount_test.go index 0132f7cb117..c3123a41b29 100644 --- a/integrationTests/node/getAccount/getAccount_test.go +++ b/integrationTests/node/getAccount/getAccount_test.go @@ -53,7 +53,8 @@ func TestNode_GetAccountAccountDoesNotExistsShouldRetEmpty(t *testing.T) { node.WithStateComponents(stateComponents), ) - encodedAddress := integrationTests.TestAddressPubkeyConverter.Encode(integrationTests.CreateRandomBytes(32)) + encodedAddress, err := integrationTests.TestAddressPubkeyConverter.Encode(integrationTests.CreateRandomBytes(32)) + require.Nil(t, err) recovAccnt, _, err := n.GetAccount(encodedAddress, api.AccountQueryOptions{}) require.Nil(t, err) @@ -92,7 +93,8 @@ func TestNode_GetAccountAccountExistsShouldReturn(t *testing.T) { node.WithStateComponents(stateComponents), ) - testAddress := coreComponents.AddressPubKeyConverter().Encode(testPubkey) + testAddress, err := coreComponents.AddressPubKeyConverter().Encode(testPubkey) + require.Nil(t, err) recovAccnt, _, err := n.GetAccount(testAddress, api.AccountQueryOptions{}) require.Nil(t, err) diff --git a/integrationTests/singleShard/transaction/interceptedBulkTx/interceptedBulkTx_test.go b/integrationTests/singleShard/transaction/interceptedBulkTx/interceptedBulkTx_test.go index 7a849078570..1a6b0d2e501 100644 --- a/integrationTests/singleShard/transaction/interceptedBulkTx/interceptedBulkTx_test.go +++ b/integrationTests/singleShard/transaction/interceptedBulkTx/interceptedBulkTx_test.go @@ -87,9 +87,11 @@ func TestNode_GenerateSendInterceptBulkTransactionsWithMessenger(t *testing.T) { mintingValue := big.NewInt(10000000000) integrationTests.CreateMintingForSenders([]*integrationTests.TestProcessorNode{n}, shardId, senderPrivateKeys, mintingValue) - receiver := integrationTests.TestAddressPubkeyConverter.Encode(integrationTests.CreateRandomBytes(32)) - err := n.Node.GenerateAndSendBulkTransactions( - receiver, + encodedReceiverAddr, err := integrationTests.TestAddressPubkeyConverter.Encode(integrationTests.CreateRandomBytes(32)) + assert.Nil(t, err) + + err = n.Node.GenerateAndSendBulkTransactions( + encodedReceiverAddr, big.NewInt(1), uint64(noOfTx), n.OwnAccount.SkTxSign, diff --git a/integrationTests/testConsensusNode.go b/integrationTests/testConsensusNode.go index fe7a588430e..c4b6f89c673 100644 --- a/integrationTests/testConsensusNode.go +++ b/integrationTests/testConsensusNode.go @@ -266,7 +266,7 @@ func (tcn *TestConsensusNode) initNode(args ArgsTestConsensusNode) { } pubKeyBytes, _ := pubKey.ToByteArray() - pubKeyString := coreComponents.ValidatorPubKeyConverterField.Encode(pubKeyBytes) + pubKeyString := coreComponents.ValidatorPubKeyConverterField.SilentEncode(pubKeyBytes, log) argsKeysHandler := keysManagement.ArgsKeysHandler{ ManagedPeersHolder: keysHolder, PrivateKey: tcn.NodeKeys.Sk, diff --git a/integrationTests/testInitializer.go b/integrationTests/testInitializer.go index 87bfdfcd9d8..7ff1c51bdb1 100644 --- a/integrationTests/testInitializer.go +++ b/integrationTests/testInitializer.go @@ -1571,13 +1571,17 @@ func DisplayAndStartNodes(nodes []*TestProcessorNode) { pkTxBuff, _ := n.OwnAccount.PkTxSign.ToByteArray() pkNode := n.NodesCoordinator.GetOwnPublicKey() + encodedPkNode := TestValidatorPubkeyConverter.SilentEncode(pkNode, log) + log.Info(fmt.Sprintf("Shard ID: %v, pkNode: %s", n.ShardCoordinator.SelfId(), - TestValidatorPubkeyConverter.Encode(pkNode))) + encodedPkNode)) + + encodedPkTxBuff := TestAddressPubkeyConverter.SilentEncode(pkTxBuff, log) log.Info(fmt.Sprintf("skTx: %s, pkTx: %s", hex.EncodeToString(skTxBuff), - TestAddressPubkeyConverter.Encode(pkTxBuff))) + encodedPkTxBuff)) } log.Info("Delaying for node bootstrap and topic announcement...") @@ -2142,9 +2146,15 @@ func generateValidTx( node.WithStateComponents(stateComponents), ) + encodedPkSenderBuff, err := TestAddressPubkeyConverter.Encode(pkSenderBuff) + assert.Nil(t, err) + + encodedPkRecvBuff, err := TestAddressPubkeyConverter.Encode(pkRecvBuff) + assert.Nil(t, err) + tx, err := mockNode.GenerateTransaction( - TestAddressPubkeyConverter.Encode(pkSenderBuff), - TestAddressPubkeyConverter.Encode(pkRecvBuff), + encodedPkSenderBuff, + encodedPkRecvBuff, big.NewInt(1), "", skSender, diff --git a/integrationTests/testProcessorNode.go b/integrationTests/testProcessorNode.go index 8f4bb2a4c52..a242624c051 100644 --- a/integrationTests/testProcessorNode.go +++ b/integrationTests/testProcessorNode.go @@ -144,7 +144,7 @@ var TestVmMarshalizer = &marshal.JsonMarshalizer{} var TestTxSignMarshalizer = &marshal.JsonMarshalizer{} // TestAddressPubkeyConverter represents an address public key converter -var TestAddressPubkeyConverter, _ = pubkeyConverter.NewBech32PubkeyConverter(32, log) +var TestAddressPubkeyConverter, _ = pubkeyConverter.NewBech32PubkeyConverter(32, AddressHrp) // TestValidatorPubkeyConverter represents an address public key converter var TestValidatorPubkeyConverter, _ = pubkeyConverter.NewHexPubkeyConverter(96) @@ -2341,12 +2341,22 @@ func (tpn *TestProcessorNode) initNode() { // SendTransaction can send a transaction (it does the dispatching) func (tpn *TestProcessorNode) SendTransaction(tx *dataTransaction.Transaction) (string, error) { + encodedRcvAddr, err := TestAddressPubkeyConverter.Encode(tx.RcvAddr) + if err != nil { + return "", err + } + + encodedSndAddr, err := TestAddressPubkeyConverter.Encode(tx.SndAddr) + if err != nil { + return "", err + } + tx, txHash, err := tpn.Node.CreateTransaction( tx.Nonce, tx.Value.String(), - TestAddressPubkeyConverter.Encode(tx.RcvAddr), + encodedRcvAddr, nil, - TestAddressPubkeyConverter.Encode(tx.SndAddr), + encodedSndAddr, nil, tx.GasPrice, tx.GasLimit, diff --git a/integrationTests/vm/esdt/multisign/esdtMultisign_test.go b/integrationTests/vm/esdt/multisign/esdtMultisign_test.go index db330d15c7a..3e221267888 100644 --- a/integrationTests/vm/esdt/multisign/esdtMultisign_test.go +++ b/integrationTests/vm/esdt/multisign/esdtMultisign_test.go @@ -186,7 +186,10 @@ func deployMultisig(t *testing.T, nodes []*integrationTests.TestProcessorNode, o ) require.Nil(t, err) - log.Info("multisign contract", "address", integrationTests.TestAddressPubkeyConverter.Encode(multisigContractAddress)) + encodedMultisigContractAddress, err := integrationTests.TestAddressPubkeyConverter.Encode(multisigContractAddress) + require.Nil(t, err) + + log.Info("multisign contract", "address", encodedMultisigContractAddress) integrationTests.CreateAndSendTransaction(nodes[ownerIdx], nodes, big.NewInt(0), emptyAddress, txData, 100000) return multisigContractAddress diff --git a/integrationTests/vm/txsFee/scCalls_test.go b/integrationTests/vm/txsFee/scCalls_test.go index 18e28691225..9717f0c3c86 100644 --- a/integrationTests/vm/txsFee/scCalls_test.go +++ b/integrationTests/vm/txsFee/scCalls_test.go @@ -19,6 +19,7 @@ import ( "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/common/forking" "github.com/multiversx/mx-chain-go/config" + "github.com/multiversx/mx-chain-go/integrationTests" "github.com/multiversx/mx-chain-go/integrationTests/mock" "github.com/multiversx/mx-chain-go/integrationTests/vm" "github.com/multiversx/mx-chain-go/integrationTests/vm/txsFee/utils" @@ -553,7 +554,8 @@ func TestScCallDistributeStakingRewards_ShouldWork(t *testing.T) { testContext, scAddress := prepareTestContextForEpoch836(t) defer testContext.Close() - pkConv, _ := pubkeyConverter.NewBech32PubkeyConverter(32, log) + pkConv, err := pubkeyConverter.NewBech32PubkeyConverter(32, integrationTests.AddressHrp) + require.NoError(t, err) sndAddr1, err := pkConv.Decode("erd1rkhyj0ne054upekymjafwas44v2trdykd22vcg27ap8x2hpg5u7q0296ne") require.Nil(t, err) diff --git a/integrationTests/vm/wasm/delegation/testRunner.go b/integrationTests/vm/wasm/delegation/testRunner.go index bf395fd14c3..3623f070858 100644 --- a/integrationTests/vm/wasm/delegation/testRunner.go +++ b/integrationTests/vm/wasm/delegation/testRunner.go @@ -103,7 +103,12 @@ func RunDelegationStressTest( } delegationAddr, err := node.BlockchainHook.NewAddress(node.OwnAccount.Address, node.OwnAccount.Nonce, []byte{5, 0}) - log.Debug("delegation contract", "address", integrationTests.TestAddressPubkeyConverter.Encode(delegationAddr)) + encodedDelegationAddr, err := integrationTests.TestAddressPubkeyConverter.Encode(delegationAddr) + if err != nil { + return nil, err + } + + log.Debug("delegation contract", "address", encodedDelegationAddr) err = deployDelegationSC(node, delegationFilename) if err != nil { diff --git a/node/external/blockAPI/apiBlockFactory_test.go b/node/external/blockAPI/apiBlockFactory_test.go index 00df3a67665..0ecd79b8b73 100644 --- a/node/external/blockAPI/apiBlockFactory_test.go +++ b/node/external/blockAPI/apiBlockFactory_test.go @@ -33,7 +33,7 @@ func createMockArgsAPIBlockProc() *ArgAPIBlockProcessor { APITransactionHandler: &mock.TransactionAPIHandlerStub{}, StatusComputer: statusComputer, Hasher: &mock.HasherMock{}, - AddressPubkeyConverter: &mock.PubkeyConverterMock{}, + AddressPubkeyConverter: &testscommon.PubkeyConverterMock{}, LogsFacade: &testscommon.LogsFacadeStub{}, ReceiptsRepository: &testscommon.ReceiptsRepositoryStub{}, AlteredAccountsProvider: &testscommon.AlteredAccountsProviderStub{}, diff --git a/node/external/blockAPI/baseBlock_test.go b/node/external/blockAPI/baseBlock_test.go index 4303f04a35a..e65e10ccbd1 100644 --- a/node/external/blockAPI/baseBlock_test.go +++ b/node/external/blockAPI/baseBlock_test.go @@ -37,7 +37,7 @@ func createBaseBlockProcessor() *baseAPIBlockProcessor { uint64ByteSliceConverter: mock.NewNonceHashConverterMock(), historyRepo: &dblookupext.HistoryRepositoryStub{}, hasher: &hashingMocks.HasherMock{}, - addressPubKeyConverter: mock.NewPubkeyConverterMock(32), + addressPubKeyConverter: testscommon.NewPubkeyConverterMock(32), txStatusComputer: &mock.StatusComputerStub{}, apiTransactionHandler: &mock.TransactionAPIHandlerStub{}, logsFacade: &testscommon.LogsFacadeStub{}, @@ -136,9 +136,12 @@ func TestBaseBlockGetIntraMiniblocksReceipts(t *testing.T) { baseAPIBlockProc.apiTransactionHandler = &mock.TransactionAPIHandlerStub{ UnmarshalReceiptCalled: func(receiptBytes []byte) (*transaction.ApiReceipt, error) { + encodedSndAddrReceiptObj, err := baseAPIBlockProc.addressPubKeyConverter.Encode(receiptObj.SndAddr) + require.NoError(t, err) + return &transaction.ApiReceipt{ Value: receiptObj.Value, - SndAddr: baseAPIBlockProc.addressPubKeyConverter.Encode(receiptObj.SndAddr), + SndAddr: encodedSndAddrReceiptObj, Data: string(receiptObj.Data), TxHash: hex.EncodeToString(receiptObj.TxHash), }, nil diff --git a/node/external/logs/logsConverter.go b/node/external/logs/logsConverter.go index 9276a954f6a..7b05b2122b6 100644 --- a/node/external/logs/logsConverter.go +++ b/node/external/logs/logsConverter.go @@ -19,20 +19,24 @@ func (converter *logsConverter) txLogToApiResource(logKey []byte, log *transacti events := make([]*transaction.Events, len(log.Events)) for i, event := range log.Events { + eventAddress := converter.encodeAddress(event.Address) + events[i] = &transaction.Events{ - Address: converter.encodeAddress(event.Address), + Address: eventAddress, Identifier: string(event.Identifier), Topics: event.Topics, Data: event.Data, } } + logAddress := converter.encodeAddress(log.Address) + return &transaction.ApiLogs{ - Address: converter.encodeAddress(log.Address), + Address: logAddress, Events: events, } } func (converter *logsConverter) encodeAddress(pubkey []byte) string { - return converter.pubKeyConverter.Encode(pubkey) + return converter.pubKeyConverter.SilentEncode(pubkey, log) } diff --git a/node/external/logs/logsConverter_test.go b/node/external/logs/logsConverter_test.go index b9b590cb322..baed8c9c149 100644 --- a/node/external/logs/logsConverter_test.go +++ b/node/external/logs/logsConverter_test.go @@ -9,7 +9,7 @@ import ( ) func TestLogsConverter_TxLogToApiResourceShouldWork(t *testing.T) { - pkConverter, _ := pubkeyConverter.NewBech32PubkeyConverter(32, log) + pkConverter, _ := pubkeyConverter.NewBech32PubkeyConverter(32, "erd") logsConverter := newLogsConverter(pkConverter) contractAddressBech32 := "erd1qqqqqqqqqqqqqpgqxwakt2g7u9atsnr03gqcgmhcv38pt7mkd94q6shuwt" diff --git a/node/external/logs/logsFacade.go b/node/external/logs/logsFacade.go index e26aa382f84..5ce4e6d9ecb 100644 --- a/node/external/logs/logsFacade.go +++ b/node/external/logs/logsFacade.go @@ -38,6 +38,7 @@ func (facade *logsFacade) GetLog(logKey []byte, epoch uint32) (*transaction.ApiL } apiResource := facade.converter.txLogToApiResource(logKey, txLog) + return apiResource, nil } diff --git a/node/external/nodeApiResolver.go b/node/external/nodeApiResolver.go index aef2c7a1316..acdb5e97fe6 100644 --- a/node/external/nodeApiResolver.go +++ b/node/external/nodeApiResolver.go @@ -17,9 +17,12 @@ import ( "github.com/multiversx/mx-chain-go/sharding" "github.com/multiversx/mx-chain-go/sharding/nodesCoordinator" "github.com/multiversx/mx-chain-go/state" + logger "github.com/multiversx/mx-chain-logger-go" vmcommon "github.com/multiversx/mx-chain-vm-common-go" ) +var log = logger.GetOrCreate("node/external") + // ArgNodeApiResolver represents the DTO structure used in the NewNodeApiResolver constructor type ArgNodeApiResolver struct { SCQueryService SCQueryService @@ -294,7 +297,11 @@ func bigInToString(input *big.Int) string { // GetGenesisNodesPubKeys will return genesis nodes public keys by shard func (nar *nodeApiResolver) GetGenesisNodesPubKeys() (map[uint32][]string, map[uint32][]string) { eligibleNodesConfig, waitingNodesConfig := nar.genesisNodesSetupHandler.InitialNodesInfo() - return nar.getInitialNodesPubKeysBytes(eligibleNodesConfig), nar.getInitialNodesPubKeysBytes(waitingNodesConfig) + + eligibleNodesPubKeysBytes := nar.getInitialNodesPubKeysBytes(eligibleNodesConfig) + waitingNodesPubKeysBytes := nar.getInitialNodesPubKeysBytes(waitingNodesConfig) + + return eligibleNodesPubKeysBytes, waitingNodesPubKeysBytes } func (nar *nodeApiResolver) getInitialNodesPubKeysBytes(nodesInfo map[uint32][]nodesCoordinator.GenesisNodeInfoHandler) map[uint32][]string { @@ -302,7 +309,8 @@ func (nar *nodeApiResolver) getInitialNodesPubKeysBytes(nodesInfo map[uint32][]n for shardID, ni := range nodesInfo { for i := 0; i < len(ni); i++ { - nodesInfoPubkeys[shardID] = append(nodesInfoPubkeys[shardID], nar.validatorPubKeyConverter.Encode(ni[i].PubKeyBytes())) + validatorPubKey := nar.validatorPubKeyConverter.SilentEncode(ni[i].PubKeyBytes(), log) + nodesInfoPubkeys[shardID] = append(nodesInfoPubkeys[shardID], validatorPubKey) } } diff --git a/node/external/transactionAPI/apiTransactionProcessor.go b/node/external/transactionAPI/apiTransactionProcessor.go index 372dafec4db..e5735f3a43c 100644 --- a/node/external/transactionAPI/apiTransactionProcessor.go +++ b/node/external/transactionAPI/apiTransactionProcessor.go @@ -63,7 +63,7 @@ func NewAPITransactionProcessor(args *ArgAPITransactionProcessor) (*apiTransacti args.DataFieldParser, ) - refundDetector := newRefundDetector() + refundDetectorInstance := newRefundDetector() gasUsedAndFeeProc := newGasUsedAndFeeProcessor(args.FeeComputer, args.AddressPubKeyConverter) return &apiTransactionProcessor{ @@ -80,7 +80,7 @@ func NewAPITransactionProcessor(args *ArgAPITransactionProcessor) (*apiTransacti txTypeHandler: args.TxTypeHandler, txUnmarshaller: txUnmarshalerAndPreparer, transactionResultsProcessor: txResultsProc, - refundDetector: refundDetector, + refundDetector: refundDetectorInstance, gasUsedAndFeeProcessor: gasUsedAndFeeProc, }, nil } @@ -109,10 +109,7 @@ func (atp *apiTransactionProcessor) GetTransaction(txHash string, withResults bo } func (atp *apiTransactionProcessor) doGetTransaction(hash []byte, withResults bool) (*transaction.ApiTransactionResult, error) { - tx, err := atp.optionallyGetTransactionFromPool(hash) - if err != nil { - return nil, err - } + tx := atp.optionallyGetTransactionFromPool(hash) if tx != nil { return tx, nil } @@ -177,10 +174,7 @@ func (atp *apiTransactionProcessor) GetTransactionsPool(fields string) (*common. return nil, err } - transactions.SmartContractResults, err = atp.getUnsignedTransactionsFromPool(requestedFieldsHandler) - if err != nil { - return nil, err - } + transactions.SmartContractResults = atp.getUnsignedTransactionsFromPool(requestedFieldsHandler) return transactions, nil } @@ -207,6 +201,7 @@ func (atp *apiTransactionProcessor) GetTransactionsPoolForSender(sender, fields transactions := &common.TransactionsPoolForSenderApiResponse{} for _, wrappedTx := range wrappedTxs { tx := atp.extractRequestedTxInfo(wrappedTx, requestedFieldsHandler) + transactions.Transactions = append(transactions.Transactions, tx) } @@ -248,18 +243,17 @@ func (atp *apiTransactionProcessor) GetTransactionsPoolNonceGapsForSender(sender }, nil } -func (atp *apiTransactionProcessor) extractRequestedTxInfoFromObj(txObj interface{}, txType transaction.TxType, txHash []byte, requestedFieldsHandler fieldsHandler) (common.Transaction, error) { - txResult, err := atp.getApiResultFromObj(txObj, txType) - if err != nil { - return common.Transaction{}, err - } +func (atp *apiTransactionProcessor) extractRequestedTxInfoFromObj(txObj interface{}, txType transaction.TxType, txHash []byte, requestedFieldsHandler fieldsHandler) common.Transaction { + txResult := atp.getApiResultFromObj(txObj, txType) wrappedTx := &txcache.WrappedTransaction{ Tx: txResult.Tx, TxHash: txHash, } - return atp.extractRequestedTxInfo(wrappedTx, requestedFieldsHandler), nil + requestedTxInfo := atp.extractRequestedTxInfo(wrappedTx, requestedFieldsHandler) + + return requestedTxInfo } func (atp *apiTransactionProcessor) getRegularTransactionsFromPool(requestedFieldsHandler fieldsHandler) ([]common.Transaction, error) { @@ -271,10 +265,7 @@ func (atp *apiTransactionProcessor) getRegularTransactionsFromPool(requestedFiel continue } - tx, err := atp.extractRequestedTxInfoFromObj(txObj, transaction.TxTypeNormal, key, requestedFieldsHandler) - if err != nil { - return nil, err - } + tx := atp.extractRequestedTxInfoFromObj(txObj, transaction.TxTypeNormal, key, requestedFieldsHandler) regularTxs[idx] = tx } @@ -291,10 +282,7 @@ func (atp *apiTransactionProcessor) getRewardTransactionsFromPool(requestedField continue } - tx, err := atp.extractRequestedTxInfoFromObj(txObj, transaction.TxTypeReward, key, requestedFieldsHandler) - if err != nil { - return nil, err - } + tx := atp.extractRequestedTxInfoFromObj(txObj, transaction.TxTypeReward, key, requestedFieldsHandler) rewardTxs[idx] = tx } @@ -302,7 +290,7 @@ func (atp *apiTransactionProcessor) getRewardTransactionsFromPool(requestedField return rewardTxs, nil } -func (atp *apiTransactionProcessor) getUnsignedTransactionsFromPool(requestedFieldsHandler fieldsHandler) ([]common.Transaction, error) { +func (atp *apiTransactionProcessor) getUnsignedTransactionsFromPool(requestedFieldsHandler fieldsHandler) []common.Transaction { unsignedTxKeys := atp.dataPool.UnsignedTransactions().Keys() unsignedTxs := make([]common.Transaction, len(unsignedTxKeys)) for idx, key := range unsignedTxKeys { @@ -311,15 +299,12 @@ func (atp *apiTransactionProcessor) getUnsignedTransactionsFromPool(requestedFie continue } - tx, err := atp.extractRequestedTxInfoFromObj(txObj, transaction.TxTypeUnsigned, key, requestedFieldsHandler) - if err != nil { - return nil, err - } + tx := atp.extractRequestedTxInfoFromObj(txObj, transaction.TxTypeUnsigned, key, requestedFieldsHandler) unsignedTxs[idx] = tx } - return unsignedTxs, nil + return unsignedTxs } func (atp *apiTransactionProcessor) extractRequestedTxInfo(wrappedTx *txcache.WrappedTransaction, requestedFieldsHandler fieldsHandler) common.Transaction { @@ -332,12 +317,15 @@ func (atp *apiTransactionProcessor) extractRequestedTxInfo(wrappedTx *txcache.Wr if requestedFieldsHandler.HasNonce { tx.TxFields[nonceField] = wrappedTx.Tx.GetNonce() } + if requestedFieldsHandler.HasSender { - tx.TxFields[senderField] = atp.addressPubKeyConverter.Encode(wrappedTx.Tx.GetSndAddr()) + tx.TxFields[senderField], _ = atp.addressPubKeyConverter.Encode(wrappedTx.Tx.GetSndAddr()) } + if requestedFieldsHandler.HasReceiver { - tx.TxFields[receiverField] = atp.addressPubKeyConverter.Encode(wrappedTx.Tx.GetRcvAddr()) + tx.TxFields[receiverField], _ = atp.addressPubKeyConverter.Encode(wrappedTx.Tx.GetRcvAddr()) } + if requestedFieldsHandler.HasGasLimit { tx.TxFields[gasLimitField] = wrappedTx.Tx.GetGasLimit() } @@ -431,26 +419,23 @@ func (atp *apiTransactionProcessor) appendGapFromAccountNonceIfNeeded( } } -func (atp *apiTransactionProcessor) optionallyGetTransactionFromPool(hash []byte) (*transaction.ApiTransactionResult, error) { +func (atp *apiTransactionProcessor) optionallyGetTransactionFromPool(hash []byte) *transaction.ApiTransactionResult { txObj, txType, found := atp.getTxObjFromDataPool(hash) if !found { - return nil, nil + return nil } return atp.getApiResultFromObj(txObj, txType) } -func (atp *apiTransactionProcessor) getApiResultFromObj(txObj interface{}, txType transaction.TxType) (*transaction.ApiTransactionResult, error) { - tx, err := atp.castObjToTransaction(txObj, txType) - if err != nil { - return nil, err - } +func (atp *apiTransactionProcessor) getApiResultFromObj(txObj interface{}, txType transaction.TxType) *transaction.ApiTransactionResult { + tx := atp.castObjToTransaction(txObj, txType) tx.SourceShard = atp.shardCoordinator.ComputeId(tx.Tx.GetSndAddr()) tx.DestinationShard = atp.shardCoordinator.ComputeId(tx.Tx.GetRcvAddr()) tx.Status = transaction.TxStatusPending - return tx, nil + return tx } // computeTimestampForRound will return the timestamp for the given round @@ -668,7 +653,7 @@ func (atp *apiTransactionProcessor) getTxBytesFromStorageByEpoch(hash []byte, ep return nil, transaction.TxTypeInvalid, false } -func (atp *apiTransactionProcessor) castObjToTransaction(txObj interface{}, txType transaction.TxType) (*transaction.ApiTransactionResult, error) { +func (atp *apiTransactionProcessor) castObjToTransaction(txObj interface{}, txType transaction.TxType) *transaction.ApiTransactionResult { switch txType { case transaction.TxTypeNormal: if tx, ok := txObj.(*transaction.Transaction); ok { @@ -689,7 +674,7 @@ func (atp *apiTransactionProcessor) castObjToTransaction(txObj interface{}, txTy } log.Warn("castObjToTransaction() unexpected: unknown txType", "txType", txType) - return &transaction.ApiTransactionResult{Type: string(transaction.TxTypeInvalid)}, nil + return &transaction.ApiTransactionResult{Type: string(transaction.TxTypeInvalid)} } func getTxValue(wrappedTx *txcache.WrappedTransaction) string { diff --git a/node/external/transactionAPI/apiTransactionProcessor_test.go b/node/external/transactionAPI/apiTransactionProcessor_test.go index 21ab7a19f0b..f7d90c8f15b 100644 --- a/node/external/transactionAPI/apiTransactionProcessor_test.go +++ b/node/external/transactionAPI/apiTransactionProcessor_test.go @@ -13,7 +13,6 @@ import ( "time" "github.com/multiversx/mx-chain-core-go/core" - coreMock "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" "github.com/multiversx/mx-chain-core-go/data/block" @@ -46,7 +45,7 @@ func createMockArgAPITransactionProcessor() *ArgAPITransactionProcessor { RoundDuration: 0, GenesisTime: time.Time{}, Marshalizer: &mock.MarshalizerFake{}, - AddressPubKeyConverter: &mock.PubkeyConverterMock{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterMock{}, ShardCoordinator: createShardCoordinator(), HistoryRepository: &dblookupextMock.HistoryRepositoryStub{}, StorageService: &storageStubs.ChainStorerStub{}, @@ -446,7 +445,7 @@ func TestNode_GetTransactionWithResultsFromStorage(t *testing.T) { RoundDuration: 0, GenesisTime: time.Time{}, Marshalizer: &mock.MarshalizerFake{}, - AddressPubKeyConverter: &mock.PubkeyConverterMock{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterMock{}, ShardCoordinator: &mock.ShardCoordinatorMock{}, HistoryRepository: historyRepo, StorageService: chainStorer, @@ -806,11 +805,14 @@ func TestApiTransactionProcessor_GetTransactionsPoolForSender(t *testing.T) { } }, } - args.AddressPubKeyConverter = &mock.PubkeyConverterStub{ + args.AddressPubKeyConverter = &testscommon.PubkeyConverterStub{ DecodeCalled: func(humanReadable string) ([]byte, error) { return []byte(humanReadable), nil }, - EncodeCalled: func(pkBytes []byte) string { + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil + }, + SilentEncodeCalled: func(pkBytes []byte, log core.Logger) string { return string(pkBytes) }, } @@ -874,12 +876,12 @@ func TestApiTransactionProcessor_GetLastPoolNonceForSender(t *testing.T) { } }, } - args.AddressPubKeyConverter = &mock.PubkeyConverterStub{ + args.AddressPubKeyConverter = &testscommon.PubkeyConverterStub{ DecodeCalled: func(humanReadable string) ([]byte, error) { return []byte(humanReadable), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, } args.ShardCoordinator = &processMocks.ShardCoordinatorStub{ @@ -948,12 +950,12 @@ func TestApiTransactionProcessor_GetTransactionsPoolNonceGapsForSender(t *testin } }, } - args.AddressPubKeyConverter = &mock.PubkeyConverterStub{ + args.AddressPubKeyConverter = &testscommon.PubkeyConverterStub{ DecodeCalled: func(humanReadable string) ([]byte, error) { return []byte(humanReadable), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, } args.ShardCoordinator = &processMocks.ShardCoordinatorStub{ @@ -1015,7 +1017,7 @@ func createAPITransactionProc(t *testing.T, epoch uint32, withDbLookupExt bool) RoundDuration: 0, GenesisTime: time.Time{}, Marshalizer: &mock.MarshalizerFake{}, - AddressPubKeyConverter: &mock.PubkeyConverterMock{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterMock{}, ShardCoordinator: createShardCoordinator(), HistoryRepository: historyRepo, StorageService: chainStorer, @@ -1085,11 +1087,10 @@ func TestPrepareUnsignedTx(t *testing.T) { } n, _, _, _ := createAPITransactionProc(t, 0, true) - n.txUnmarshaller.addressPubKeyConverter, _ = pubkeyConverter.NewBech32PubkeyConverter(addrSize, &coreMock.LoggerMock{}) - n.addressPubKeyConverter, _ = pubkeyConverter.NewBech32PubkeyConverter(addrSize, &coreMock.LoggerMock{}) + n.txUnmarshaller.addressPubKeyConverter, _ = pubkeyConverter.NewBech32PubkeyConverter(addrSize, "erd") + n.addressPubKeyConverter, _ = pubkeyConverter.NewBech32PubkeyConverter(addrSize, "erd") - scrResult1, err := n.txUnmarshaller.prepareUnsignedTx(scr1) - assert.Nil(t, err) + scrResult1 := n.txUnmarshaller.prepareUnsignedTx(scr1) expectedScr1 := &transaction.ApiTransactionResult{ Tx: scr1, Nonce: 1, @@ -1110,8 +1111,7 @@ func TestPrepareUnsignedTx(t *testing.T) { OriginalSender: bytes.Repeat([]byte{7}, addrSize), } - scrResult2, err := n.txUnmarshaller.prepareUnsignedTx(scr2) - assert.Nil(t, err) + scrResult2 := n.txUnmarshaller.prepareUnsignedTx(scr2) expectedScr2 := &transaction.ApiTransactionResult{ Tx: scr2, Nonce: 3, diff --git a/node/external/transactionAPI/apiTransactionResults.go b/node/external/transactionAPI/apiTransactionResults.go index cf4f0f21c65..ad75632f2ca 100644 --- a/node/external/transactionAPI/apiTransactionResults.go +++ b/node/external/transactionAPI/apiTransactionResults.go @@ -13,7 +13,6 @@ import ( "github.com/multiversx/mx-chain-go/dblookupext" "github.com/multiversx/mx-chain-go/node/filters" "github.com/multiversx/mx-chain-go/sharding" - datafield "github.com/multiversx/mx-chain-vm-common-go/parsers/dataField" ) type apiTransactionResultsProcessor struct { @@ -122,6 +121,7 @@ func (arp *apiTransactionResultsProcessor) putSmartContractResultsInTransactionB } scrAPI := arp.adaptSmartContractResult(scrHash, scr) + arp.loadLogsIntoContractResults(scrHash, epoch, scrAPI) tx.SmartContractResults = append(tx.SmartContractResults, scrAPI) @@ -193,28 +193,23 @@ func (arp *apiTransactionResultsProcessor) adaptSmartContractResult(scrHash []by IsRefund: isRefund, } - if len(scr.SndAddr) == arp.addressPubKeyConverter.Len() { - apiSCR.SndAddr = arp.addressPubKeyConverter.Encode(scr.SndAddr) - } - - if len(scr.RcvAddr) == arp.addressPubKeyConverter.Len() { - apiSCR.RcvAddr = arp.addressPubKeyConverter.Encode(scr.RcvAddr) - } - - if len(scr.RelayerAddr) == arp.addressPubKeyConverter.Len() { - apiSCR.RelayerAddr = arp.addressPubKeyConverter.Encode(scr.RelayerAddr) - } - - if len(scr.OriginalSender) == arp.addressPubKeyConverter.Len() { - apiSCR.OriginalSender = arp.addressPubKeyConverter.Encode(scr.OriginalSender) - } + apiSCR.SndAddr, _ = arp.addressPubKeyConverter.Encode(scr.SndAddr) + apiSCR.RcvAddr, _ = arp.addressPubKeyConverter.Encode(scr.RcvAddr) + apiSCR.RelayerAddr, _ = arp.addressPubKeyConverter.Encode(scr.RelayerAddr) + apiSCR.OriginalSender, _ = arp.addressPubKeyConverter.Encode(scr.OriginalSender) res := arp.dataFieldParser.Parse(scr.Data, scr.GetSndAddr(), scr.GetRcvAddr(), arp.shardCoordinator.NumberOfShards()) apiSCR.Operation = res.Operation apiSCR.Function = res.Function apiSCR.ESDTValues = res.ESDTValues apiSCR.Tokens = res.Tokens - apiSCR.Receivers = datafield.EncodeBytesSlice(arp.addressPubKeyConverter.Encode, res.Receivers) + + var err error + apiSCR.Receivers, err = arp.addressPubKeyConverter.EncodeSlice(res.Receivers) + if err != nil { + log.Warn("bech32PubkeyConverter.EncodeSlice() failed while encoding apiSCR.Receivers with", "err", err, "hash", scrHash) + } + apiSCR.ReceiversShardIDs = res.ReceiversShardID apiSCR.IsRelayed = res.IsRelayed diff --git a/node/external/transactionAPI/apiTransactionResults_test.go b/node/external/transactionAPI/apiTransactionResults_test.go index aed5688c04a..7676ade83ad 100644 --- a/node/external/transactionAPI/apiTransactionResults_test.go +++ b/node/external/transactionAPI/apiTransactionResults_test.go @@ -54,7 +54,7 @@ func TestPutEventsInTransactionReceipt(t *testing.T) { }, } - pubKeyConverter := &mock.PubkeyConverterMock{} + pubKeyConverter := &testscommon.PubkeyConverterMock{} logsFacade := &testscommon.LogsFacadeStub{} dataFieldParser := &testscommon.DataFieldParserStub{ ParseCalled: func(dataField []byte, sender, receiver []byte, _ uint32) *datafield.ResponseParseData { @@ -69,14 +69,17 @@ func TestPutEventsInTransactionReceipt(t *testing.T) { tx := &transaction.ApiTransactionResult{} + encodedSndAddr, err := pubKeyConverter.Encode(rec.SndAddr) + require.Nil(t, err) + expectedRecAPI := &transaction.ApiReceipt{ Value: rec.Value, Data: string(rec.Data), TxHash: hex.EncodeToString(txHash), - SndAddr: pubKeyConverter.Encode(rec.SndAddr), + SndAddr: encodedSndAddr, } - err := n.putResultsInTransaction(txHash, tx, epoch) + err = n.putResultsInTransaction(txHash, tx, epoch) require.Nil(t, err) require.Equal(t, expectedRecAPI, tx.Receipt) } @@ -212,10 +215,19 @@ func TestPutEventsInTransactionSmartContractResults(t *testing.T) { }, } shardCoordinator := mock.NewOneShardCoordinatorMock() - pubKeyConverter := mock.NewPubkeyConverterMock(3) + pubKeyConverter := testscommon.NewPubkeyConverterMock(3) txUnmarshalerAndPreparer := newTransactionUnmarshaller(marshalizerdMock, pubKeyConverter, dataFieldParser, shardCoordinator) n := newAPITransactionResultProcessor(pubKeyConverter, historyRepo, dataStore, marshalizerdMock, txUnmarshalerAndPreparer, logsFacade, shardCoordinator, dataFieldParser) + encodedSndAddr, err := pubKeyConverter.Encode(scr1.SndAddr) + require.Nil(t, err) + encodedRcvAddr, err := pubKeyConverter.Encode(scr1.RcvAddr) + require.Nil(t, err) + encodedRelayerAddr, err := pubKeyConverter.Encode(scr1.RelayerAddr) + require.Nil(t, err) + encodedOriginalAddr, err := pubKeyConverter.Encode(scr1.OriginalSender) + require.Nil(t, err) + expectedSCRS := []*transaction.ApiSmartContractResult{ { Hash: hex.EncodeToString(scrHash1), @@ -231,10 +243,10 @@ func TestPutEventsInTransactionSmartContractResults(t *testing.T) { CallType: scr1.CallType, CodeMetadata: string(scr1.CodeMetadata), ReturnMessage: string(scr1.ReturnMessage), - SndAddr: pubKeyConverter.Encode(scr1.SndAddr), - RcvAddr: pubKeyConverter.Encode(scr1.RcvAddr), - RelayerAddr: pubKeyConverter.Encode(scr1.RelayerAddr), - OriginalSender: pubKeyConverter.Encode(scr1.OriginalSender), + SndAddr: encodedSndAddr, + RcvAddr: encodedRcvAddr, + RelayerAddr: encodedRelayerAddr, + OriginalSender: encodedOriginalAddr, Logs: logs, Receivers: []string{}, }, @@ -247,7 +259,7 @@ func TestPutEventsInTransactionSmartContractResults(t *testing.T) { } tx := &transaction.ApiTransactionResult{} - err := n.putResultsInTransaction(testTxHash, tx, testEpoch) + err = n.putResultsInTransaction(testTxHash, tx, testEpoch) require.Nil(t, err) require.Equal(t, expectedSCRS, tx.SmartContractResults) } @@ -301,7 +313,7 @@ func TestPutLogsInTransaction(t *testing.T) { }, } shardCoordinator := mock.NewOneShardCoordinatorMock() - pubKeyConverter := &mock.PubkeyConverterMock{} + pubKeyConverter := &testscommon.PubkeyConverterMock{} txUnmarshalerAndPreparer := newTransactionUnmarshaller(marshalizerMock, pubKeyConverter, dataFieldParser, shardCoordinator) n := newAPITransactionResultProcessor(pubKeyConverter, historyRepo, dataStore, marshalizerMock, txUnmarshalerAndPreparer, logsFacade, shardCoordinator, dataFieldParser) diff --git a/node/external/transactionAPI/gasUsedAndFeeProcessor_test.go b/node/external/transactionAPI/gasUsedAndFeeProcessor_test.go index 2c351fd8be0..e2e655d898b 100644 --- a/node/external/transactionAPI/gasUsedAndFeeProcessor_test.go +++ b/node/external/transactionAPI/gasUsedAndFeeProcessor_test.go @@ -12,7 +12,7 @@ import ( "github.com/stretchr/testify/require" ) -var pubKeyConverter, _ = pubkeyConverter.NewBech32PubkeyConverter(32, log) +var pubKeyConverter, _ = pubkeyConverter.NewBech32PubkeyConverter(32, "erd") func TestComputeTransactionGasUsedAndFeeMoveBalance(t *testing.T) { t.Parallel() diff --git a/node/external/transactionAPI/unmarshaller.go b/node/external/transactionAPI/unmarshaller.go index b2f9e753a38..cf320c979f9 100644 --- a/node/external/transactionAPI/unmarshaller.go +++ b/node/external/transactionAPI/unmarshaller.go @@ -11,7 +11,6 @@ import ( "github.com/multiversx/mx-chain-core-go/data/transaction" "github.com/multiversx/mx-chain-core-go/marshal" "github.com/multiversx/mx-chain-go/sharding" - datafield "github.com/multiversx/mx-chain-vm-common-go/parsers/dataField" ) type txUnmarshaller struct { @@ -42,9 +41,11 @@ func (tu *txUnmarshaller) unmarshalReceipt(receiptBytes []byte) (*transaction.Ap return nil, err } + senderAddress := tu.addressPubKeyConverter.SilentEncode(rec.SndAddr, log) + return &transaction.ApiReceipt{ Value: rec.Value, - SndAddr: tu.addressPubKeyConverter.Encode(rec.SndAddr), + SndAddr: senderAddress, Data: string(rec.Data), TxHash: hex.EncodeToString(rec.TxHash), }, nil @@ -61,21 +62,21 @@ func (tu *txUnmarshaller) unmarshalTransaction(txBytes []byte, txType transactio if err != nil { return nil, err } - apiTx, err = tu.prepareNormalTx(&tx) + apiTx = tu.prepareNormalTx(&tx) case transaction.TxTypeInvalid: var tx transaction.Transaction err = tu.marshalizer.Unmarshal(&tx, txBytes) if err != nil { return nil, err } - apiTx, err = tu.prepareInvalidTx(&tx) + apiTx = tu.prepareInvalidTx(&tx) case transaction.TxTypeReward: var tx rewardTxData.RewardTx err = tu.marshalizer.Unmarshal(&tx, txBytes) if err != nil { return nil, err } - apiTx, err = tu.prepareRewardTx(&tx) + apiTx = tu.prepareRewardTx(&tx) case transaction.TxTypeUnsigned: var tx smartContractResult.SmartContractResult @@ -83,7 +84,7 @@ func (tu *txUnmarshaller) unmarshalTransaction(txBytes []byte, txType transactio if err != nil { return nil, err } - apiTx, err = tu.prepareUnsignedTx(&tx) + apiTx = tu.prepareUnsignedTx(&tx) } if err != nil { return nil, err @@ -94,22 +95,29 @@ func (tu *txUnmarshaller) unmarshalTransaction(txBytes []byte, txType transactio apiTx.Function = res.Function apiTx.ESDTValues = res.ESDTValues apiTx.Tokens = res.Tokens - apiTx.Receivers = datafield.EncodeBytesSlice(tu.addressPubKeyConverter.Encode, res.Receivers) + apiTx.Receivers, err = tu.addressPubKeyConverter.EncodeSlice(res.Receivers) + if err != nil { + log.Warn("bech32PubkeyConverter.EncodeSlice() failed while encoding apiSCR.Receivers with", "err", err) + } + apiTx.ReceiversShardIDs = res.ReceiversShardID apiTx.IsRelayed = res.IsRelayed return apiTx, nil } -func (tu *txUnmarshaller) prepareNormalTx(tx *transaction.Transaction) (*transaction.ApiTransactionResult, error) { +func (tu *txUnmarshaller) prepareNormalTx(tx *transaction.Transaction) *transaction.ApiTransactionResult { + receiverAddress := tu.addressPubKeyConverter.SilentEncode(tx.RcvAddr, log) + senderAddress := tu.addressPubKeyConverter.SilentEncode(tx.SndAddr, log) + return &transaction.ApiTransactionResult{ Tx: tx, Type: string(transaction.TxTypeNormal), Nonce: tx.Nonce, Value: tx.Value.String(), - Receiver: tu.addressPubKeyConverter.Encode(tx.RcvAddr), + Receiver: receiverAddress, ReceiverUsername: tx.RcvUserName, - Sender: tu.addressPubKeyConverter.Encode(tx.SndAddr), + Sender: senderAddress, SenderUsername: tx.SndUserName, GasPrice: tx.GasPrice, GasLimit: tx.GasLimit, @@ -118,27 +126,32 @@ func (tu *txUnmarshaller) prepareNormalTx(tx *transaction.Transaction) (*transac Options: tx.Options, Version: tx.Version, ChainID: string(tx.ChainID), - }, nil + } } -func (tu *txUnmarshaller) prepareInvalidTx(tx *transaction.Transaction) (*transaction.ApiTransactionResult, error) { +func (tu *txUnmarshaller) prepareInvalidTx(tx *transaction.Transaction) *transaction.ApiTransactionResult { + receiverAddress := tu.addressPubKeyConverter.SilentEncode(tx.RcvAddr, log) + senderAddress := tu.addressPubKeyConverter.SilentEncode(tx.SndAddr, log) + return &transaction.ApiTransactionResult{ Tx: tx, Type: string(transaction.TxTypeInvalid), Nonce: tx.Nonce, Value: tx.Value.String(), - Receiver: tu.addressPubKeyConverter.Encode(tx.RcvAddr), + Receiver: receiverAddress, ReceiverUsername: tx.RcvUserName, - Sender: tu.addressPubKeyConverter.Encode(tx.SndAddr), + Sender: senderAddress, SenderUsername: tx.SndUserName, GasPrice: tx.GasPrice, GasLimit: tx.GasLimit, Data: tx.Data, Signature: hex.EncodeToString(tx.Signature), - }, nil + } } -func (tu *txUnmarshaller) prepareRewardTx(tx *rewardTxData.RewardTx) (*transaction.ApiTransactionResult, error) { +func (tu *txUnmarshaller) prepareRewardTx(tx *rewardTxData.RewardTx) *transaction.ApiTransactionResult { + receiverAddress := tu.addressPubKeyConverter.SilentEncode(tx.GetRcvAddr(), log) + return &transaction.ApiTransactionResult{ Tx: tx, Type: string(transaction.TxTypeReward), @@ -146,19 +159,22 @@ func (tu *txUnmarshaller) prepareRewardTx(tx *rewardTxData.RewardTx) (*transacti Epoch: tx.GetEpoch(), Value: tx.GetValue().String(), Sender: "metachain", - Receiver: tu.addressPubKeyConverter.Encode(tx.GetRcvAddr()), + Receiver: receiverAddress, SourceShard: core.MetachainShardId, - }, nil + } } -func (tu *txUnmarshaller) prepareUnsignedTx(tx *smartContractResult.SmartContractResult) (*transaction.ApiTransactionResult, error) { +func (tu *txUnmarshaller) prepareUnsignedTx(tx *smartContractResult.SmartContractResult) *transaction.ApiTransactionResult { + receiverAddress := tu.addressPubKeyConverter.SilentEncode(tx.GetRcvAddr(), log) + senderAddress := tu.addressPubKeyConverter.SilentEncode(tx.GetSndAddr(), log) + txResult := &transaction.ApiTransactionResult{ Tx: tx, Type: string(transaction.TxTypeUnsigned), Nonce: tx.GetNonce(), Value: tx.GetValue().String(), - Receiver: tu.addressPubKeyConverter.Encode(tx.GetRcvAddr()), - Sender: tu.addressPubKeyConverter.Encode(tx.GetSndAddr()), + Receiver: receiverAddress, + Sender: senderAddress, GasPrice: tx.GetGasPrice(), GasLimit: tx.GetGasLimit(), Data: tx.GetData(), @@ -173,12 +189,12 @@ func (tu *txUnmarshaller) prepareUnsignedTx(tx *smartContractResult.SmartContrac OriginalSender: tu.getEncodedAddress(tx.GetOriginalSender()), } - return txResult, nil + return txResult } func (tu *txUnmarshaller) getEncodedAddress(address []byte) string { if len(address) == tu.addressPubKeyConverter.Len() { - return tu.addressPubKeyConverter.Encode(address) + return tu.addressPubKeyConverter.SilentEncode(address, log) } return "" diff --git a/node/external/transactionAPI/unmarshaller_test.go b/node/external/transactionAPI/unmarshaller_test.go index 4e85d5c6b54..d2e90c71347 100644 --- a/node/external/transactionAPI/unmarshaller_test.go +++ b/node/external/transactionAPI/unmarshaller_test.go @@ -4,21 +4,22 @@ import ( "math/big" "testing" - "github.com/multiversx/mx-chain-go/process/mock" + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-go/testscommon" "github.com/stretchr/testify/require" ) func TestGetEncodedAddress(t *testing.T) { t.Parallel() - address := []byte("address") - expectedEncodedAddr := "encoded" + address := []byte("12345678901234567890123456789012") + expectedEncodedAddr := "erd1xyerxdp4xcmnswfsxyerxdp4xcmnswfsxyerxdp4xcmnswfsxyeqlrqt99" txUnmarshalledHandler := &txUnmarshaller{ - addressPubKeyConverter: &mock.PubkeyConverterStub{ + addressPubKeyConverter: &testscommon.PubkeyConverterStub{ LenCalled: func() int { return len(address) }, - EncodeCalled: func(pkBytes []byte) string { + SilentEncodeCalled: func(pkBytes []byte, log core.Logger) string { require.Equal(t, pkBytes, address) return expectedEncodedAddr }, @@ -28,7 +29,7 @@ func TestGetEncodedAddress(t *testing.T) { encodedAddr := txUnmarshalledHandler.getEncodedAddress(address) require.Equal(t, expectedEncodedAddr, encodedAddr) - encodedAddr = txUnmarshalledHandler.getEncodedAddress([]byte("adr")) + encodedAddr = txUnmarshalledHandler.getEncodedAddress([]byte("abc")) require.Empty(t, encodedAddr) } diff --git a/node/mock/pubkeyConverterMock.go b/node/mock/pubkeyConverterMock.go deleted file mode 100644 index 2495757f430..00000000000 --- a/node/mock/pubkeyConverterMock.go +++ /dev/null @@ -1,37 +0,0 @@ -package mock - -import ( - "encoding/hex" -) - -// PubkeyConverterMock - -type PubkeyConverterMock struct { - len int -} - -// NewPubkeyConverterMock - -func NewPubkeyConverterMock(addressLen int) *PubkeyConverterMock { - return &PubkeyConverterMock{ - len: addressLen, - } -} - -// Decode - -func (pcm *PubkeyConverterMock) Decode(humanReadable string) ([]byte, error) { - return hex.DecodeString(humanReadable) -} - -// Encode - -func (pcm *PubkeyConverterMock) Encode(pkBytes []byte) string { - return hex.EncodeToString(pkBytes) -} - -// Len - -func (pcm *PubkeyConverterMock) Len() int { - return pcm.len -} - -// IsInterfaceNil - -func (pcm *PubkeyConverterMock) IsInterfaceNil() bool { - return pcm == nil -} diff --git a/node/mock/pubkeyConverterStub.go b/node/mock/pubkeyConverterStub.go deleted file mode 100644 index f8ef5507235..00000000000 --- a/node/mock/pubkeyConverterStub.go +++ /dev/null @@ -1,40 +0,0 @@ -package mock - -// PubkeyConverterStub - -type PubkeyConverterStub struct { - LenCalled func() int - DecodeCalled func(humanReadable string) ([]byte, error) - EncodeCalled func(pkBytes []byte) string -} - -// Len - -func (pcs *PubkeyConverterStub) Len() int { - if pcs.LenCalled != nil { - return pcs.LenCalled() - } - - return 0 -} - -// Decode - -func (pcs *PubkeyConverterStub) Decode(humanReadable string) ([]byte, error) { - if pcs.DecodeCalled != nil { - return pcs.DecodeCalled(humanReadable) - } - - return make([]byte, 0), nil -} - -// Encode - -func (pcs *PubkeyConverterStub) Encode(pkBytes []byte) string { - if pcs.EncodeCalled != nil { - return pcs.EncodeCalled(pkBytes) - } - - return "" -} - -// IsInterfaceNil - -func (pcs *PubkeyConverterStub) IsInterfaceNil() bool { - return pcs == nil -} diff --git a/node/node.go b/node/node.go index ce56b3a02e4..68dbe03ae30 100644 --- a/node/node.go +++ b/node/node.go @@ -367,7 +367,9 @@ func (n *Node) GetESDTData(address, tokenID string, nonce uint64, options api.Ac } if esdtToken.TokenMetaData != nil { - esdtToken.TokenMetaData.Creator = []byte(n.coreComponents.AddressPubKeyConverter().Encode(esdtToken.TokenMetaData.Creator)) + esdtTokenCreatorAddr := n.coreComponents.AddressPubKeyConverter().SilentEncode(esdtToken.TokenMetaData.Creator, log) + + esdtToken.TokenMetaData.Creator = []byte(esdtTokenCreatorAddr) } return esdtToken, blockInfo, nil @@ -566,7 +568,11 @@ func (n *Node) GetAllESDTTokens(address string, options api.AccountQueryOptions, } if esdtToken.TokenMetaData != nil { - esdtToken.TokenMetaData.Creator = []byte(n.coreComponents.AddressPubKeyConverter().Encode(esdtToken.TokenMetaData.Creator)) + esdtTokenCreatorAddr, err := n.coreComponents.AddressPubKeyConverter().Encode(esdtToken.TokenMetaData.Creator) + if err != nil { + return nil, api.BlockInfo{}, err + } + esdtToken.TokenMetaData.Creator = []byte(esdtTokenCreatorAddr) tokenName = adjustNftTokenIdentifier(tokenName, esdtToken.TokenMetaData.Nonce) } @@ -854,7 +860,10 @@ func (n *Node) GetAccount(address string, options api.AccountQueryOptions) (api. ownerAddress := "" if len(account.GetOwnerAddress()) > 0 { addressPubkeyConverter := n.coreComponents.AddressPubKeyConverter() - ownerAddress = addressPubkeyConverter.Encode(account.GetOwnerAddress()) + ownerAddress, err = addressPubkeyConverter.Encode(account.GetOwnerAddress()) + if err != nil { + return api.AccountResponse{}, api.BlockInfo{}, err + } } return api.AccountResponse{ @@ -910,7 +919,7 @@ func (n *Node) EncodeAddressPubkey(pk []byte) (string, error) { return "", fmt.Errorf("%w for addressPubkeyConverter", ErrNilPubkeyConverter) } - return n.coreComponents.AddressPubKeyConverter().Encode(pk), nil + return n.coreComponents.AddressPubKeyConverter().Encode(pk) } // DecodeAddressPubkey will try to decode the provided address public key string @@ -977,7 +986,10 @@ func (n *Node) GetPeerInfo(pid string) ([]core.QueryP2PPeerInfo, error) { peerInfoSlice := make([]core.QueryP2PPeerInfo, 0, len(pidsFound)) for _, p := range pidsFound { - pidInfo := n.createPidInfo(p) + pidInfo, err := n.createPidInfo(p) + if err != nil { + return nil, err + } peerInfoSlice = append(peerInfoSlice, pidInfo) } @@ -1119,7 +1131,7 @@ func (n *Node) GetStatusComponents() mainFactory.StatusComponentsHolder { return n.statusComponents } -func (n *Node) createPidInfo(p core.PeerID) core.QueryP2PPeerInfo { +func (n *Node) createPidInfo(p core.PeerID) (core.QueryP2PPeerInfo, error) { result := core.QueryP2PPeerInfo{ Pid: p.Pretty(), Addresses: n.networkComponents.NetworkMessenger().PeerAddresses(p), @@ -1132,10 +1144,14 @@ func (n *Node) createPidInfo(p core.PeerID) core.QueryP2PPeerInfo { if len(peerInfo.PkBytes) == 0 { result.Pk = "" } else { - result.Pk = n.coreComponents.ValidatorPubKeyConverter().Encode(peerInfo.PkBytes) + var err error + result.Pk, err = n.coreComponents.ValidatorPubKeyConverter().Encode(peerInfo.PkBytes) + if err != nil { + return core.QueryP2PPeerInfo{}, fmt.Errorf("%w while encoding public key for creating peer id info %s", err, hex.EncodeToString(peerInfo.PkBytes)) + } } - return result + return result, nil } // Close closes all underlying components diff --git a/node/nodeDebugFactory/interceptedDebugHandler_test.go b/node/nodeDebugFactory/interceptedDebugHandler_test.go index 16309b69892..786d46e5d3a 100644 --- a/node/nodeDebugFactory/interceptedDebugHandler_test.go +++ b/node/nodeDebugFactory/interceptedDebugHandler_test.go @@ -87,7 +87,7 @@ func TestCreateInterceptedDebugHandler_InvalidDebugConfigShouldErr(t *testing.T) ) assert.NotNil(t, err) - assert.True(t, strings.Contains(err.Error(), "Must provide a positive size")) + assert.True(t, strings.Contains(err.Error(), "must provide a positive size")) } func TestCreateInterceptedDebugHandler_SettingOnInterceptorsErrShouldErr(t *testing.T) { diff --git a/node/nodeTesting_test.go b/node/nodeTesting_test.go index 284258057f1..89aa392bfc4 100644 --- a/node/nodeTesting_test.go +++ b/node/nodeTesting_test.go @@ -208,7 +208,7 @@ func TestGenerateAndSendBulkTransactions_InvalidReceiverAddressShouldErr(t *test } expectedErr := errors.New("expected error") coreComponents := getDefaultCoreComponents() - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(humanReadable string) ([]byte, error) { if len(humanReadable) == 0 { return nil, expectedErr diff --git a/node/node_test.go b/node/node_test.go index 089cc70a603..51503cfadf8 100644 --- a/node/node_test.go +++ b/node/node_test.go @@ -62,8 +62,8 @@ import ( "github.com/stretchr/testify/require" ) -func createMockPubkeyConverter() *mock.PubkeyConverterMock { - return mock.NewPubkeyConverterMock(32) +func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { + return testscommon.NewPubkeyConverterMock(32) } func getAccAdapter(balance *big.Int) *stateMock.AccountsStub { @@ -797,7 +797,6 @@ func TestNode_GetAllESDTTokensShouldReturnEsdtAndFormattedNft(t *testing.T) { esdtData := &esdt.ESDigitalToken{Value: big.NewInt(10)} marshalledData, _ := getMarshalizer().Marshal(esdtData) - suffix := append(esdtKey, acc.AddressBytes()...) nftToken := "TCKR-67tgv3" @@ -806,7 +805,8 @@ func TestNode_GetAllESDTTokensShouldReturnEsdtAndFormattedNft(t *testing.T) { nftKeyWithBytes := append(nftKey, nftNonce.Bytes()...) nftSuffix := append(nftKeyWithBytes, acc.AddressBytes()...) - nftData := &esdt.ESDigitalToken{Type: uint32(core.NonFungible), Value: big.NewInt(10), TokenMetaData: &esdt.MetaData{Nonce: nftNonce.Uint64()}} + nftMetaData := &esdt.MetaData{Nonce: nftNonce.Uint64(), Creator: []byte("12345678901234567890123456789012")} + nftData := &esdt.ESDigitalToken{Type: uint32(core.NonFungible), Value: big.NewInt(10), TokenMetaData: nftMetaData} marshalledNftData, _ := getMarshalizer().Marshal(nftData) esdtStorageStub := &testscommon.EsdtStorageHandlerStub{ @@ -1620,7 +1620,7 @@ func TestCreateTransaction_NilAccountsAdapterShouldErr(t *testing.T) { coreComponents.IntMarsh = getMarshalizer() coreComponents.VmMarsh = getMarshalizer() coreComponents.Hash = getHasher() - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, @@ -1675,7 +1675,7 @@ func TestCreateTransaction_InvalidSignatureShouldErr(t *testing.T) { coreComponents.VmMarsh = getMarshalizer() coreComponents.TxMarsh = getMarshalizer() coreComponents.Hash = getHasher() - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, @@ -1718,12 +1718,12 @@ func TestCreateTransaction_ChainIDFieldChecks(t *testing.T) { return expectedHash }, } - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, LenCalled: func() int { return 3 @@ -1776,12 +1776,12 @@ func TestCreateTransaction_InvalidTxVersionShouldErr(t *testing.T) { return expectedHash }, } - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, LenCalled: func() int { return 3 @@ -1824,12 +1824,12 @@ func TestCreateTransaction_SenderShardIdIsInDifferentShardShouldNotValidate(t *t return expectedHash }, } - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, LenCalled: func() int { return 3 @@ -1915,12 +1915,12 @@ func TestCreateTransaction_SignatureLengthChecks(t *testing.T) { coreComponents.ChainIdCalled = func() string { return chainID } - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, LenCalled: func() int { return 3 @@ -1981,12 +1981,12 @@ func TestCreateTransaction_SenderLengthChecks(t *testing.T) { return bi }, } - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, LenCalled: func() int { return encodedAddressLen @@ -2045,12 +2045,12 @@ func TestCreateTransaction_ReceiverLengthChecks(t *testing.T) { return bi }, } - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, LenCalled: func() int { return encodedAddressLen @@ -2108,12 +2108,12 @@ func TestCreateTransaction_TooBigSenderUsernameShouldErr(t *testing.T) { return bi }, } - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, LenCalled: func() int { return 3 @@ -2167,12 +2167,12 @@ func TestCreateTransaction_TooBigReceiverUsernameShouldErr(t *testing.T) { return bi }, } - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, LenCalled: func() int { return 3 @@ -2226,12 +2226,12 @@ func TestCreateTransaction_DataFieldSizeExceedsMaxShouldErr(t *testing.T) { return bi }, } - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, LenCalled: func() int { return 3 @@ -2282,12 +2282,12 @@ func TestCreateTransaction_TooLargeValueFieldShouldErr(t *testing.T) { return bi }, } - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, LenCalled: func() int { return 3 @@ -2333,12 +2333,12 @@ func TestCreateTransaction_OkValsShouldWork(t *testing.T) { }, } coreComponents.TxVersionCheckHandler = versioning.NewTxVersionChecker(version) - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, LenCalled: func() int { return 3 @@ -2417,12 +2417,12 @@ func TestCreateTransaction_TxSignedWithHashShouldErrVersionShoudBe2(t *testing.T coreComponents.MinTransactionVersionCalled = func() uint32 { return version } - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, LenCalled: func() int { return 3 @@ -2514,12 +2514,12 @@ func TestCreateTransaction_TxSignedWithHashNoEnabledShouldErr(t *testing.T) { coreComponents.MinTransactionVersionCalled = func() uint32 { return version } - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return []byte(hexAddress), nil }, - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, LenCalled: func() int { return 3 @@ -2859,7 +2859,7 @@ func TestNode_GetAccountPubkeyConverterFailsShouldErr(t *testing.T) { errExpected := errors.New("expected error") coreComponents := getDefaultCoreComponents() - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(hexAddress string) ([]byte, error) { return nil, errExpected }, @@ -3106,7 +3106,7 @@ func TestNode_EncodeDecodeAddressPubkey(t *testing.T) { buff := []byte("abcdefg") coreComponents := getDefaultCoreComponents() - coreComponents.AddrPubKeyConv = mock.NewPubkeyConverterMock(32) + coreComponents.AddrPubKeyConv = testscommon.NewPubkeyConverterMock(32) n, _ := node.NewNode( node.WithCoreComponents(coreComponents), ) @@ -3321,7 +3321,7 @@ func TestNode_ShouldWork(t *testing.T) { } coreComponents := getDefaultCoreComponents() - coreComponents.ValPubKeyConv = mock.NewPubkeyConverterMock(32) + coreComponents.ValPubKeyConv = testscommon.NewPubkeyConverterMock(32) n, _ := node.NewNode( node.WithNetworkComponents(networkComponents), @@ -3368,7 +3368,7 @@ func TestNode_ValidateTransactionForSimulation_CheckSignatureFalse(t *testing.T) coreComponents.IntMarsh = getMarshalizer() coreComponents.VmMarsh = getMarshalizer() coreComponents.Hash = getHasher() - coreComponents.AddrPubKeyConv = mock.NewPubkeyConverterMock(3) + coreComponents.AddrPubKeyConv = testscommon.NewPubkeyConverterMock(3) stateComponents := getDefaultStateComponents() stateComponents.AccountsAPI = &stateMock.AccountsStub{} @@ -3417,7 +3417,7 @@ func TestGetKeyValuePairs_CannotDecodeAddress(t *testing.T) { expectedErr := errors.New("local err") coreComponents := getDefaultCoreComponents() - coreComponents.AddrPubKeyConv = &mock.PubkeyConverterStub{ + coreComponents.AddrPubKeyConv = &testscommon.PubkeyConverterStub{ DecodeCalled: func(humanReadable string) ([]byte, error) { return nil, expectedErr }, diff --git a/node/trieIterators/delegatedListProcessor.go b/node/trieIterators/delegatedListProcessor.go index 5db7ecb4116..2b254c61ff5 100644 --- a/node/trieIterators/delegatedListProcessor.go +++ b/node/trieIterators/delegatedListProcessor.go @@ -96,8 +96,13 @@ func (dlp *delegatedListProcessor) getDelegatorsInfo(delegationSC []byte, delega delegatorInfo, ok := delegatorsMap[string(delegatorAddress)] if !ok { + encodedDelegatorAddress, err := dlp.publicKeyConverter.Encode(delegatorAddress) + if err != nil { + return fmt.Errorf("%w encoding the address of the delegator %s", err, hex.EncodeToString(delegatorAddress)) + } + delegatorInfo = &api.Delegator{ - DelegatorAddress: dlp.publicKeyConverter.Encode(delegatorAddress), + DelegatorAddress: encodedDelegatorAddress, DelegatedTo: make([]*api.DelegatedValue, 0), TotalAsBigInt: big.NewInt(0), } @@ -107,8 +112,13 @@ func (dlp *delegatedListProcessor) getDelegatorsInfo(delegationSC []byte, delega delegatorInfo.TotalAsBigInt = big.NewInt(0).Add(delegatorInfo.TotalAsBigInt, value) delegatorInfo.Total = delegatorInfo.TotalAsBigInt.String() + delegationSCAddress, err := dlp.publicKeyConverter.Encode(delegationSC) + if err != nil { + return fmt.Errorf("%w encoding delegation SC address %s", err, hex.EncodeToString(delegationSC)) + } + delegatorInfo.DelegatedTo = append(delegatorInfo.DelegatedTo, &api.DelegatedValue{ - DelegationScAddress: dlp.publicKeyConverter.Encode(delegationSC), + DelegationScAddress: delegationSCAddress, Value: value.String(), }) } diff --git a/node/trieIterators/delegatedListProcessor_test.go b/node/trieIterators/delegatedListProcessor_test.go index 090f8ce68e1..caf9bfa0f10 100644 --- a/node/trieIterators/delegatedListProcessor_test.go +++ b/node/trieIterators/delegatedListProcessor_test.go @@ -17,6 +17,7 @@ import ( "github.com/multiversx/mx-chain-go/node/mock" "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/state" + "github.com/multiversx/mx-chain-go/testscommon" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" trieMock "github.com/multiversx/mx-chain-go/testscommon/trie" vmcommon "github.com/multiversx/mx-chain-vm-common-go" @@ -99,7 +100,7 @@ func TestDelegatedListProc_GetDelegatorsListContextShouldTimeout(t *testing.T) { delegators := [][]byte{[]byte("delegator1"), []byte("delegator2")} arg := createMockArgs() - arg.PublicKeyConverter = mock.NewPubkeyConverterMock(10) + arg.PublicKeyConverter = testscommon.NewPubkeyConverterMock(10) delegationSc := [][]byte{[]byte("delegationSc1"), []byte("delegationSc2")} arg.QueryService = &mock.SCQueryServiceStub{ ExecuteQueryCalled: func(query *process.SCQuery) (*vmcommon.VMOutput, error) { @@ -146,7 +147,7 @@ func TestDelegatedListProc_GetDelegatorsListShouldWork(t *testing.T) { delegators := [][]byte{[]byte("delegator1"), []byte("delegator2")} arg := createMockArgs() - arg.PublicKeyConverter = mock.NewPubkeyConverterMock(10) + arg.PublicKeyConverter = testscommon.NewPubkeyConverterMock(10) delegationSc := [][]byte{[]byte("delegationSc1"), []byte("delegationSc2")} arg.QueryService = &mock.SCQueryServiceStub{ ExecuteQueryCalled: func(query *process.SCQuery) (*vmcommon.VMOutput, error) { @@ -182,15 +183,25 @@ func TestDelegatedListProc_GetDelegatorsListShouldWork(t *testing.T) { delegatorsValues, err := dlp.GetDelegatorsList(context.Background()) require.Nil(t, err) require.Equal(t, 2, len(delegatorsValues)) + + encodedDelegator1PubKey, err := arg.PublicKeyConverter.Encode(delegators[0]) + require.Nil(t, err) + + encodedDelegationSc1, err := arg.PublicKeyConverter.Encode(delegationSc[0]) + require.Nil(t, err) + + encodedDelegationSc2, err := arg.PublicKeyConverter.Encode(delegationSc[1]) + require.Nil(t, err) + expectedDelegator1 := api.Delegator{ - DelegatorAddress: arg.PublicKeyConverter.Encode(delegators[0]), + DelegatorAddress: encodedDelegator1PubKey, DelegatedTo: []*api.DelegatedValue{ { - DelegationScAddress: arg.PublicKeyConverter.Encode(delegationSc[0]), + DelegationScAddress: encodedDelegationSc1, Value: "1", }, { - DelegationScAddress: arg.PublicKeyConverter.Encode(delegationSc[1]), + DelegationScAddress: encodedDelegationSc2, Value: "1", }, }, @@ -198,15 +209,18 @@ func TestDelegatedListProc_GetDelegatorsListShouldWork(t *testing.T) { TotalAsBigInt: big.NewInt(2), } + encodedDelegator2PubKey, err := arg.PublicKeyConverter.Encode(delegators[1]) + require.Nil(t, err) + expectedDelegator2 := api.Delegator{ - DelegatorAddress: arg.PublicKeyConverter.Encode(delegators[1]), + DelegatorAddress: encodedDelegator2PubKey, DelegatedTo: []*api.DelegatedValue{ { - DelegationScAddress: arg.PublicKeyConverter.Encode(delegationSc[0]), + DelegationScAddress: encodedDelegationSc1, Value: "2", }, { - DelegationScAddress: arg.PublicKeyConverter.Encode(delegationSc[1]), + DelegationScAddress: encodedDelegationSc2, Value: "2", }, }, diff --git a/node/trieIterators/directStakedListProcessor.go b/node/trieIterators/directStakedListProcessor.go index 0ff046919b4..2034a0a6a42 100644 --- a/node/trieIterators/directStakedListProcessor.go +++ b/node/trieIterators/directStakedListProcessor.go @@ -10,8 +10,11 @@ import ( "github.com/multiversx/mx-chain-go/state" "github.com/multiversx/mx-chain-go/trie/keyBuilder" "github.com/multiversx/mx-chain-go/vm" + logger "github.com/multiversx/mx-chain-logger-go" ) +var log = logger.GetOrCreate("node/trieIterators") + type directStakedListProcessor struct { *commonStakingProcessor publicKeyConverter core.PubkeyConverter @@ -80,8 +83,10 @@ func (dslp *directStakedListProcessor) getAllStakedAccounts(validatorAccount sta baseStaked := big.NewInt(0).Set(info.totalStakedValue) baseStaked.Sub(baseStaked, info.topUpValue) + encodedLeafKey := dslp.publicKeyConverter.SilentEncode(leafKey, log) + val := &api.DirectStakedValue{ - Address: dslp.publicKeyConverter.Encode(leafKey), + Address: encodedLeafKey, BaseStaked: baseStaked.String(), TopUp: info.topUpValue.String(), Total: info.totalStakedValue.String(), diff --git a/node/trieIterators/directStakedListProcessor_test.go b/node/trieIterators/directStakedListProcessor_test.go index 18b0bba952d..edb70de582a 100644 --- a/node/trieIterators/directStakedListProcessor_test.go +++ b/node/trieIterators/directStakedListProcessor_test.go @@ -16,6 +16,7 @@ import ( "github.com/multiversx/mx-chain-go/node/mock" "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/state" + "github.com/multiversx/mx-chain-go/testscommon" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" trieMock "github.com/multiversx/mx-chain-go/testscommon/trie" vmcommon "github.com/multiversx/mx-chain-vm-common-go" @@ -67,7 +68,7 @@ func TestDirectStakedListProc_GetDelegatorsListContextShouldTimeout(t *testing.T validators := [][]byte{[]byte("validator1"), []byte("validator2")} arg := createMockArgs() - arg.PublicKeyConverter = mock.NewPubkeyConverterMock(10) + arg.PublicKeyConverter = testscommon.NewPubkeyConverterMock(10) arg.QueryService = &mock.SCQueryServiceStub{ ExecuteQueryCalled: func(query *process.SCQuery) (*vmcommon.VMOutput, error) { return nil, fmt.Errorf("not an expected call") @@ -97,7 +98,7 @@ func TestDirectStakedListProc_GetDelegatorsListShouldWork(t *testing.T) { validators := [][]byte{[]byte("validator1"), []byte("validator2")} arg := createMockArgs() - arg.PublicKeyConverter = mock.NewPubkeyConverterMock(10) + arg.PublicKeyConverter = testscommon.NewPubkeyConverterMock(10) arg.QueryService = &mock.SCQueryServiceStub{ ExecuteQueryCalled: func(query *process.SCQuery) (*vmcommon.VMOutput, error) { switch query.FuncName { @@ -130,15 +131,19 @@ func TestDirectStakedListProc_GetDelegatorsListShouldWork(t *testing.T) { directStakedList, err := dslp.GetDirectStakedList(context.Background()) require.Nil(t, err) require.Equal(t, 2, len(directStakedList)) + encodedValidator0PubKey, err := arg.PublicKeyConverter.Encode(validators[0]) + require.Nil(t, err) + encodedValidator1PubKey, err := arg.PublicKeyConverter.Encode(validators[1]) + require.Nil(t, err) expectedDirectStake1 := api.DirectStakedValue{ - Address: arg.PublicKeyConverter.Encode(validators[0]), + Address: encodedValidator0PubKey, BaseStaked: "9", TopUp: "1", Total: "10", } expectedDirectStake2 := api.DirectStakedValue{ - Address: arg.PublicKeyConverter.Encode(validators[1]), + Address: encodedValidator1PubKey, BaseStaked: "18", TopUp: "2", Total: "20", diff --git a/node/trieIterators/factory/delegatedListHandlerFactory_test.go b/node/trieIterators/factory/delegatedListHandlerFactory_test.go index be3feca70a5..0ea20418ada 100644 --- a/node/trieIterators/factory/delegatedListHandlerFactory_test.go +++ b/node/trieIterators/factory/delegatedListHandlerFactory_test.go @@ -8,6 +8,7 @@ import ( "github.com/multiversx/mx-chain-core-go/core" "github.com/multiversx/mx-chain-go/node/mock" "github.com/multiversx/mx-chain-go/node/trieIterators" + "github.com/multiversx/mx-chain-go/testscommon" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -34,7 +35,7 @@ func TestCreateDelegatedListHandlerHandler_DelegatedListProcessor(t *testing.T) Mutex: &sync.Mutex{}, AccountsAdapter: &stateMock.AccountsStub{}, }, - PublicKeyConverter: &mock.PubkeyConverterMock{}, + PublicKeyConverter: &testscommon.PubkeyConverterMock{}, QueryService: &mock.SCQueryServiceStub{}, } diff --git a/node/trieIterators/factory/directStakedListHandlerFactory_test.go b/node/trieIterators/factory/directStakedListHandlerFactory_test.go index fe294e40267..68a8b2de929 100644 --- a/node/trieIterators/factory/directStakedListHandlerFactory_test.go +++ b/node/trieIterators/factory/directStakedListHandlerFactory_test.go @@ -8,6 +8,7 @@ import ( "github.com/multiversx/mx-chain-core-go/core" "github.com/multiversx/mx-chain-go/node/mock" "github.com/multiversx/mx-chain-go/node/trieIterators" + "github.com/multiversx/mx-chain-go/testscommon" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -34,7 +35,7 @@ func TestCreateDirectStakedListHandlerHandler_DirectStakedListProcessor(t *testi Mutex: &sync.Mutex{}, AccountsAdapter: &stateMock.AccountsStub{}, }, - PublicKeyConverter: &mock.PubkeyConverterMock{}, + PublicKeyConverter: &testscommon.PubkeyConverterMock{}, QueryService: &mock.SCQueryServiceStub{}, } diff --git a/node/trieIterators/factory/stakeValuesHandlerFactory_test.go b/node/trieIterators/factory/stakeValuesHandlerFactory_test.go index 3530dea5f8e..4dbb74d1d0c 100644 --- a/node/trieIterators/factory/stakeValuesHandlerFactory_test.go +++ b/node/trieIterators/factory/stakeValuesHandlerFactory_test.go @@ -8,6 +8,7 @@ import ( "github.com/multiversx/mx-chain-core-go/core" "github.com/multiversx/mx-chain-go/node/mock" "github.com/multiversx/mx-chain-go/node/trieIterators" + "github.com/multiversx/mx-chain-go/testscommon" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -34,7 +35,7 @@ func TestCreateTotalStakedValueHandler_TotalStakedValueProcessor(t *testing.T) { Mutex: &sync.Mutex{}, AccountsAdapter: &stateMock.AccountsStub{}, }, - PublicKeyConverter: &mock.PubkeyConverterMock{}, + PublicKeyConverter: &testscommon.PubkeyConverterMock{}, QueryService: &mock.SCQueryServiceStub{}, } diff --git a/node/trieIterators/stakeValuesProcessor_test.go b/node/trieIterators/stakeValuesProcessor_test.go index 166b4fc37f0..82a47ef3e45 100644 --- a/node/trieIterators/stakeValuesProcessor_test.go +++ b/node/trieIterators/stakeValuesProcessor_test.go @@ -14,6 +14,7 @@ import ( "github.com/multiversx/mx-chain-go/node/mock" "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/state" + "github.com/multiversx/mx-chain-go/testscommon" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" trieMock "github.com/multiversx/mx-chain-go/testscommon/trie" "github.com/multiversx/mx-chain-go/vm" @@ -33,7 +34,7 @@ func createMockArgs() ArgTrieIteratorProcessor { return ArgTrieIteratorProcessor{ Accounts: createAccountsWrapper(), QueryService: &mock.SCQueryServiceStub{}, - PublicKeyConverter: &mock.PubkeyConverterMock{}, + PublicKeyConverter: &testscommon.PubkeyConverterMock{}, } } @@ -344,7 +345,7 @@ func TestTotalStakedValueProcessor_GetTotalStakedValue(t *testing.T) { } }, } - arg.PublicKeyConverter = mock.NewPubkeyConverterMock(10) + arg.PublicKeyConverter = testscommon.NewPubkeyConverterMock(10) totalStakedProc, _ := NewTotalStakedValueProcessor(arg) stakeValues, err := totalStakedProc.GetTotalStakedValue(context.Background()) diff --git a/outport/factory/outportFactory_test.go b/outport/factory/outportFactory_test.go index 0fb10987b09..04dd4fe6633 100644 --- a/outport/factory/outportFactory_test.go +++ b/outport/factory/outportFactory_test.go @@ -10,6 +10,7 @@ import ( "github.com/multiversx/mx-chain-go/outport/factory" notifierFactory "github.com/multiversx/mx-chain-go/outport/factory" "github.com/multiversx/mx-chain-go/process/mock" + "github.com/multiversx/mx-chain-go/testscommon" "github.com/multiversx/mx-chain-go/testscommon/hashingMocks" "github.com/stretchr/testify/require" ) @@ -96,7 +97,7 @@ func TestCreateOutport_SubscribeNotifierDriver(t *testing.T) { args.EventNotifierFactoryArgs.Marshaller = &mock.MarshalizerMock{} args.EventNotifierFactoryArgs.Hasher = &hashingMocks.HasherMock{} - args.EventNotifierFactoryArgs.PubKeyConverter = &mock.PubkeyConverterMock{} + args.EventNotifierFactoryArgs.PubKeyConverter = &testscommon.PubkeyConverterMock{} args.EventNotifierFactoryArgs.RequestTimeoutSec = 1 outPort, err := factory.CreateOutport(args) require.Nil(t, err) diff --git a/outport/process/alteredaccounts/alteredAccountsProvider.go b/outport/process/alteredaccounts/alteredAccountsProvider.go index 209efde59cc..6e9588b2422 100644 --- a/outport/process/alteredaccounts/alteredAccountsProvider.go +++ b/outport/process/alteredaccounts/alteredAccountsProvider.go @@ -112,7 +112,7 @@ func (aap *alteredAccountsProvider) processMarkedAccountData( options shared.AlteredAccountsOptions, ) error { addressBytes := []byte(addressStr) - encodedAddress := aap.addressConverter.Encode(addressBytes) + encodedAddress := aap.addressConverter.SilentEncode(addressBytes, log) userAccount, err := aap.loadUserAccount(addressBytes, options) if err != nil { @@ -144,7 +144,7 @@ func (aap *alteredAccountsProvider) addAdditionalDataInAlteredAccount(alteredAcc ownerAddressBytes := userAccount.GetOwnerAddress() if core.IsSmartContractAddress(userAccount.AddressBytes()) && len(ownerAddressBytes) == aap.addressConverter.Len() { - alteredAccount.AdditionalData.CurrentOwner = aap.addressConverter.Encode(ownerAddressBytes) + alteredAccount.AdditionalData.CurrentOwner = aap.addressConverter.SilentEncode(ownerAddressBytes, log) } developerRewards := userAccount.GetDeveloperReward() if developerRewards != nil { @@ -235,10 +235,12 @@ func (aap *alteredAccountsProvider) convertMetaData(metaData *esdt.MetaData) *ou return nil } + metaDataCreatorAddr := aap.addressConverter.SilentEncode(metaData.Creator, log) + return &outportcore.TokenMetaData{ Nonce: metaData.Nonce, Name: string(metaData.Name), - Creator: aap.addressConverter.Encode(metaData.Creator), + Creator: metaDataCreatorAddr, Royalties: metaData.Royalties, Hash: metaData.Hash, URIs: metaData.URIs, diff --git a/outport/process/alteredaccounts/alteredAccountsProvider_test.go b/outport/process/alteredaccounts/alteredAccountsProvider_test.go index 91093408608..01fcefed050 100644 --- a/outport/process/alteredaccounts/alteredAccountsProvider_test.go +++ b/outport/process/alteredaccounts/alteredAccountsProvider_test.go @@ -312,11 +312,21 @@ func testExtractAlteredAccountsFromPoolBothSenderAndReceiverShards(t *testing.T) decodedKey, _ := args.AddressConverter.Decode(key) require.True(t, strings.HasPrefix(string(decodedKey), "shard0")) } - require.Contains(t, res, args.AddressConverter.Encode([]byte("shard0 addr - tx0 "))) - require.Contains(t, res, args.AddressConverter.Encode([]byte("shard0 addr 2 - tx0"))) - require.Contains(t, res, args.AddressConverter.Encode([]byte("shard0 addr 3 - tx1"))) - require.Contains(t, res, args.AddressConverter.Encode([]byte("shard0 addr - tx2 "))) - require.Contains(t, res, args.AddressConverter.Encode([]byte("shard0 addr - tx3 "))) + + shard0AddrTx0, _ := args.AddressConverter.Encode([]byte("shard0 addr - tx0 ")) + require.Contains(t, res, shard0AddrTx0) + + shard0Addr2Tx0, _ := args.AddressConverter.Encode([]byte("shard0 addr 2 - tx0")) + require.Contains(t, res, shard0Addr2Tx0) + + shard0Addr3Tx1, _ := args.AddressConverter.Encode([]byte("shard0 addr 3 - tx1")) + require.Contains(t, res, shard0Addr3Tx1) + + shard0AddrTx2, _ := args.AddressConverter.Encode([]byte("shard0 addr - tx2 ")) + require.Contains(t, res, shard0AddrTx2) + + shard0AddrTx3, _ := args.AddressConverter.Encode([]byte("shard0 addr - tx3 ")) + require.Contains(t, res, shard0AddrTx3) } func testExtractAlteredAccountsFromPoolTrieDataChecks(t *testing.T) { @@ -359,7 +369,8 @@ func testExtractAlteredAccountsFromPoolTrieDataChecks(t *testing.T) { require.NoError(t, err) require.Equal(t, 1, len(res)) - expectedAddressKey := args.AddressConverter.Encode([]byte(receiverInSelfShard)) + expectedAddressKey, err := args.AddressConverter.Encode([]byte(receiverInSelfShard)) + require.Nil(t, err) actualAccount, found := res[expectedAddressKey] require.True(t, found) require.Equal(t, expectedAddressKey, actualAccount.Address) @@ -525,8 +536,7 @@ func testExtractAlteredAccountsFromPoolShouldIncludeESDT(t *testing.T) { }, shared.AlteredAccountsOptions{}) require.NoError(t, err) - encodedAddr := args.AddressConverter.Encode([]byte("addr")) - + encodedAddr, _ := args.AddressConverter.Encode([]byte("addr")) require.Len(t, res, 1) require.Len(t, res[encodedAddr].Tokens, 1) require.Equal(t, &outportcore.AccountTokenData{ @@ -581,7 +591,7 @@ func testExtractAlteredAccountsFromPoolShouldIncludeNFT(t *testing.T) { }, shared.AlteredAccountsOptions{}) require.NoError(t, err) - encodedAddr := args.AddressConverter.Encode([]byte("addr")) + encodedAddr, _ := args.AddressConverter.Encode([]byte("addr")) require.Equal(t, &outportcore.AccountTokenData{ Identifier: "token0", Balance: expectedToken.Value.String(), @@ -647,13 +657,15 @@ func testExtractAlteredAccountsFromPoolShouldNotIncludeReceiverAddressIfNftCreat }) require.NoError(t, err) - sndAddrEncoded := args.AddressConverter.Encode(sendAddrShard0) + sndAddrEncoded, err := args.AddressConverter.Encode(sendAddrShard0) + require.Nil(t, err) require.Len(t, res, 1) require.True(t, res[sndAddrEncoded].Tokens[0].AdditionalData.IsNFTCreate) require.True(t, res[sndAddrEncoded].AdditionalData.BalanceChanged) require.True(t, res[sndAddrEncoded].AdditionalData.IsSender) - mapKeyToSearch := args.AddressConverter.Encode(receiverOnDestination) + mapKeyToSearch, err := args.AddressConverter.Encode(receiverOnDestination) + require.Nil(t, err) require.Nil(t, res[mapKeyToSearch]) } @@ -711,8 +723,10 @@ func testExtractAlteredAccountsFromPoolShouldIncludeDestinationFromTokensLogsTop require.Len(t, res, 2) - mapKeyToSearch := args.AddressConverter.Encode(receiverOnDestination) - creator := args.AddressConverter.Encode(expectedToken.TokenMetaData.Creator) + mapKeyToSearch, err := args.AddressConverter.Encode(receiverOnDestination) + require.Nil(t, err) + creator, err := args.AddressConverter.Encode(expectedToken.TokenMetaData.Creator) + require.Nil(t, err) require.Len(t, res[mapKeyToSearch].Tokens, 1) require.Equal(t, res[mapKeyToSearch].Tokens[0], &outportcore.AccountTokenData{ Identifier: "token0", @@ -788,7 +802,7 @@ func testExtractAlteredAccountsFromPoolAddressHasBalanceChangeEsdtAndfNft(t *tes }, shared.AlteredAccountsOptions{}) require.NoError(t, err) - encodedAddr := args.AddressConverter.Encode([]byte("addr")) + encodedAddr, _ := args.AddressConverter.Encode([]byte("addr")) require.Len(t, res[encodedAddr].Tokens, 2) } @@ -906,7 +920,7 @@ func testExtractAlteredAccountsFromPoolAddressHasMultipleNfts(t *testing.T) { }, shared.AlteredAccountsOptions{}) require.NoError(t, err) - encodedAddr := args.AddressConverter.Encode([]byte("addr")) + encodedAddr, _ := args.AddressConverter.Encode([]byte("addr")) require.Len(t, res, 1) require.Len(t, res[encodedAddr].Tokens, 3) @@ -991,8 +1005,8 @@ func testExtractAlteredAccountsFromPoolESDTTransferBalanceNotChanged(t *testing. }) require.NoError(t, err) - encodedAddrSnd := args.AddressConverter.Encode([]byte("snd")) - encodedAddrRcv := args.AddressConverter.Encode([]byte("rcv")) + encodedAddrSnd, _ := args.AddressConverter.Encode([]byte("snd")) + encodedAddrRcv, _ := args.AddressConverter.Encode([]byte("rcv")) require.Equal(t, map[string]*outportcore.AlteredAccount{ encodedAddrSnd: { Address: encodedAddrSnd, @@ -1069,8 +1083,10 @@ func testExtractAlteredAccountsFromPoolReceiverShouldHaveBalanceChanged(t *testi require.NoError(t, err) - encodedAddrSnd := args.AddressConverter.Encode([]byte("snd")) - encodedAddrRcv := args.AddressConverter.Encode([]byte("rcv")) + encodedAddrSnd, _ := args.AddressConverter.Encode([]byte("snd")) + + encodedAddrRcv, _ := args.AddressConverter.Encode([]byte("rcv")) + require.Equal(t, map[string]*outportcore.AlteredAccount{ encodedAddrSnd: { Address: encodedAddrSnd, @@ -1116,7 +1132,7 @@ func testExtractAlteredAccountsFromPoolOnlySenderShouldHaveBalanceChanged(t *tes }) require.NoError(t, err) - encodedAddrSnd := args.AddressConverter.Encode([]byte("snd")) + encodedAddrSnd, _ := args.AddressConverter.Encode([]byte("snd")) require.Equal(t, map[string]*outportcore.AlteredAccount{ encodedAddrSnd: { Address: encodedAddrSnd, @@ -1181,7 +1197,7 @@ func textExtractAlteredAccountsFromPoolNftCreate(t *testing.T) { }) require.NoError(t, err) - encodedAddrSnd := args.AddressConverter.Encode([]byte("snd")) + encodedAddrSnd, _ := args.AddressConverter.Encode([]byte("snd")) require.Equal(t, map[string]*outportcore.AlteredAccount{ encodedAddrSnd: { Address: encodedAddrSnd, @@ -1234,7 +1250,7 @@ func textExtractAlteredAccountsFromPoolTransactionValueNil(t *testing.T) { require.NoError(t, err) - encodedAddrSnd := args.AddressConverter.Encode([]byte("snd")) + encodedAddrSnd, _ := args.AddressConverter.Encode([]byte("snd")) require.Equal(t, map[string]*outportcore.AlteredAccount{ encodedAddrSnd: { Address: encodedAddrSnd, diff --git a/outport/process/alteredaccounts/errors.go b/outport/process/alteredaccounts/errors.go index eae3a48f175..4f7a3f27209 100644 --- a/outport/process/alteredaccounts/errors.go +++ b/outport/process/alteredaccounts/errors.go @@ -19,3 +19,6 @@ var errCannotCastToUserAccountHandler = errors.New("cannot cast account handler // errCannotCastToVmCommonUserAccountHandler signals an issue while casting to vm common user account handler var errCannotCastToVmCommonUserAccountHandler = errors.New("cannot cast user account handler to vm common user account handler") + +// ErrNilMetadata signals that a nil metadata has been provided +var ErrNilMetadata = errors.New("nil metadata provided") diff --git a/outport/process/transactionsfee/transactionsFeeProcessor_test.go b/outport/process/transactionsfee/transactionsFeeProcessor_test.go index 66a438489cd..65bc9622b1e 100644 --- a/outport/process/transactionsfee/transactionsFeeProcessor_test.go +++ b/outport/process/transactionsfee/transactionsFeeProcessor_test.go @@ -17,7 +17,7 @@ import ( "github.com/stretchr/testify/require" ) -var pubKeyConverter, _ = pubkeyConverter.NewBech32PubkeyConverter(32, &testscommon.LoggerStub{}) +var pubKeyConverter, _ = pubkeyConverter.NewBech32PubkeyConverter(32, "erd") func prepareMockArg() ArgTransactionsFeeProcessor { return ArgTransactionsFeeProcessor{ diff --git a/process/block/poolsCleaner/txsPoolsCleaner_test.go b/process/block/poolsCleaner/txsPoolsCleaner_test.go index e2eb0150440..125f44e1870 100644 --- a/process/block/poolsCleaner/txsPoolsCleaner_test.go +++ b/process/block/poolsCleaner/txsPoolsCleaner_test.go @@ -23,7 +23,7 @@ func createMockArgTxsPoolsCleaner() ArgTxsPoolsCleaner { ShardCoordinator: mock.NewMultipleShardsCoordinatorMock(), MaxRoundsToKeepUnprocessedData: 1, }, - AddressPubkeyConverter: &mock.PubkeyConverterStub{}, + AddressPubkeyConverter: &testscommon.PubkeyConverterStub{}, DataPool: dataRetrieverMock.NewPoolsHolderMock(), } } @@ -143,7 +143,7 @@ func TestGetShardFromAddress(t *testing.T) { args := createMockArgTxsPoolsCleaner() addrLen := 64 - args.AddressPubkeyConverter = &mock.PubkeyConverterStub{ + args.AddressPubkeyConverter = &testscommon.PubkeyConverterStub{ LenCalled: func() int { return addrLen }, diff --git a/process/block/postprocess/intermediateResults_test.go b/process/block/postprocess/intermediateResults_test.go index 8bc95a6614c..12773c61081 100644 --- a/process/block/postprocess/intermediateResults_test.go +++ b/process/block/postprocess/intermediateResults_test.go @@ -15,6 +15,7 @@ import ( "github.com/multiversx/mx-chain-go/dataRetriever" "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/mock" + "github.com/multiversx/mx-chain-go/testscommon" "github.com/multiversx/mx-chain-go/testscommon/hashingMocks" "github.com/multiversx/mx-chain-go/testscommon/storage" "github.com/stretchr/testify/assert" @@ -23,8 +24,8 @@ import ( const maxGasLimitPerBlock = uint64(1500000000) -func createMockPubkeyConverter() *mock.PubkeyConverterMock { - return mock.NewPubkeyConverterMock(32) +func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { + return testscommon.NewPubkeyConverterMock(32) } func TestNewIntermediateResultsProcessor_NilHashes(t *testing.T) { diff --git a/process/block/preprocess/transactions_test.go b/process/block/preprocess/transactions_test.go index 541f21fce4c..4afcf005c29 100644 --- a/process/block/preprocess/transactions_test.go +++ b/process/block/preprocess/transactions_test.go @@ -12,7 +12,6 @@ import ( "time" "github.com/multiversx/mx-chain-core-go/core" - "github.com/multiversx/mx-chain-core-go/core/pubkeyConverter" "github.com/multiversx/mx-chain-core-go/data" "github.com/multiversx/mx-chain-core-go/data/block" "github.com/multiversx/mx-chain-core-go/data/rewardTx" @@ -207,8 +206,8 @@ func initDataPool() *dataRetrieverMock.PoolsHolderStub { return sdp } -func createMockPubkeyConverter() *mock.PubkeyConverterMock { - return mock.NewPubkeyConverterMock(32) +func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { + return testscommon.NewPubkeyConverterMock(32) } func createDefaultTransactionsProcessorArgs() ArgsTransactionPreProcessor { @@ -1831,11 +1830,12 @@ func TestSortTransactionsBySenderAndNonceWithFrontRunningProtection_TestnetBids( "erd1hshz86ke95z58920xl59jnakv5ppmsfarwtump6scjjcyfr9zxwsd0cy8y", "erd13l5pgsz32u2t7mpanr9hyalahn2newj6ew85s8pgaln5kglm5s3s7w657h", } - bch32, _ := pubkeyConverter.NewBech32PubkeyConverter(32, log) + bech32 := testscommon.RealWorldBech32PubkeyConverter + txs := make([]*txcache.WrappedTransaction, 0) for idx, addr := range addresses { - addrBytes, _ := bch32.Decode(addr) + addrBytes, _ := bech32.Decode(addr) txs = append(txs, &txcache.WrappedTransaction{ Tx: &transaction.Transaction{Nonce: 2, SndAddr: addrBytes}, TxHash: []byte(fmt.Sprintf("hash%d", idx)), }) @@ -1847,8 +1847,9 @@ func TestSortTransactionsBySenderAndNonceWithFrontRunningProtection_TestnetBids( randomness := make([]byte, 32) _, _ = rand.Read(randomness) txPreproc.sortTransactionsBySenderAndNonceWithFrontRunningProtection(txs, randomness) - winner := bch32.Encode(txs[0].Tx.GetSndAddr()) - numWinsForAddresses[winner]++ + encodedWinnerAddr, err := bech32.Encode(txs[0].Tx.GetSndAddr()) + assert.Nil(t, err) + numWinsForAddresses[encodedWinnerAddr]++ } expectedWinsPerSender := numCalls / len(addresses) diff --git a/process/block/shardblock_test.go b/process/block/shardblock_test.go index 4da1f65e9a6..1dce393b2d2 100644 --- a/process/block/shardblock_test.go +++ b/process/block/shardblock_test.go @@ -48,8 +48,8 @@ import ( const MaxGasLimitPerBlock = uint64(100000) -func createMockPubkeyConverter() *mock.PubkeyConverterMock { - return mock.NewPubkeyConverterMock(32) +func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { + return testscommon.NewPubkeyConverterMock(32) } // ------- NewShardProcessor diff --git a/process/common.go b/process/common.go index d01fac9d47b..901b74c6221 100644 --- a/process/common.go +++ b/process/common.go @@ -695,15 +695,8 @@ func DisplayProcessTxDetails( return } - receiver := "" - if len(txHandler.GetRcvAddr()) == addressPubkeyConverter.Len() { - receiver = addressPubkeyConverter.Encode(txHandler.GetRcvAddr()) - } - - sender := "" - if len(txHandler.GetSndAddr()) == addressPubkeyConverter.Len() { - sender = addressPubkeyConverter.Encode(txHandler.GetSndAddr()) - } + receiverAddress, _ := addressPubkeyConverter.Encode(txHandler.GetRcvAddr()) + senderAddress, _ := addressPubkeyConverter.Encode(txHandler.GetSndAddr()) log.Trace("executing transaction", "txHash", txHash, @@ -712,8 +705,8 @@ func DisplayProcessTxDetails( "gas limit", txHandler.GetGasLimit(), "gas price", txHandler.GetGasPrice(), "data", hex.EncodeToString(txHandler.GetData()), - "sender", sender, - "receiver", receiver) + "sender", senderAddress, + "receiver", receiverAddress) } // IsAllowedToSaveUnderKey returns if saving key-value in data tries under given key is allowed diff --git a/process/coordinator/transactionType_test.go b/process/coordinator/transactionType_test.go index f2b2e88dd4b..2c66a6af68b 100644 --- a/process/coordinator/transactionType_test.go +++ b/process/coordinator/transactionType_test.go @@ -33,8 +33,8 @@ func createMockArguments() ArgNewTxTypeHandler { } } -func createMockPubkeyConverter() *mock.PubkeyConverterMock { - return mock.NewPubkeyConverterMock(32) +func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { + return testscommon.NewPubkeyConverterMock(32) } func TestNewTxTypeHandler_NilAddrConv(t *testing.T) { @@ -285,7 +285,7 @@ func TestTxTypeHandler_ComputeTransactionTypeMoveBalance(t *testing.T) { tx.Value = big.NewInt(45) arg := createMockArguments() - arg.PubkeyConverter = &mock.PubkeyConverterStub{ + arg.PubkeyConverter = &testscommon.PubkeyConverterStub{ LenCalled: func() int { return len(tx.RcvAddr) }, @@ -311,7 +311,7 @@ func TestTxTypeHandler_ComputeTransactionTypeBuiltInFunc(t *testing.T) { tx.Value = big.NewInt(45) arg := createMockArguments() - arg.PubkeyConverter = &mock.PubkeyConverterStub{ + arg.PubkeyConverter = &testscommon.PubkeyConverterStub{ LenCalled: func() int { return len(tx.RcvAddr) }, @@ -340,7 +340,7 @@ func TestTxTypeHandler_ComputeTransactionTypeBuiltInFuncNotActiveMoveBalance(t * tx.Value = big.NewInt(45) arg := createMockArguments() - arg.PubkeyConverter = &mock.PubkeyConverterStub{ + arg.PubkeyConverter = &testscommon.PubkeyConverterStub{ LenCalled: func() int { return len(tx.RcvAddr) }, @@ -371,7 +371,7 @@ func TestTxTypeHandler_ComputeTransactionTypeBuiltInFuncNotActiveSCCall(t *testi tx.Value = big.NewInt(45) arg := createMockArguments() - arg.PubkeyConverter = &mock.PubkeyConverterStub{ + arg.PubkeyConverter = &testscommon.PubkeyConverterStub{ LenCalled: func() int { return len(tx.RcvAddr) }, @@ -402,7 +402,7 @@ func TestTxTypeHandler_ComputeTransactionTypeRelayedFunc(t *testing.T) { tx.Value = big.NewInt(45) arg := createMockArguments() - arg.PubkeyConverter = &mock.PubkeyConverterStub{ + arg.PubkeyConverter = &testscommon.PubkeyConverterStub{ LenCalled: func() int { return len(tx.RcvAddr) }, @@ -428,7 +428,7 @@ func TestTxTypeHandler_ComputeTransactionTypeRelayedV2Func(t *testing.T) { tx.Value = big.NewInt(45) arg := createMockArguments() - arg.PubkeyConverter = &mock.PubkeyConverterStub{ + arg.PubkeyConverter = &testscommon.PubkeyConverterStub{ LenCalled: func() int { return len(tx.RcvAddr) }, @@ -455,7 +455,7 @@ func TestTxTypeHandler_ComputeTransactionTypeForSCRCallBack(t *testing.T) { tx.Value = big.NewInt(45) arg := createMockArguments() - arg.PubkeyConverter = &mock.PubkeyConverterStub{ + arg.PubkeyConverter = &testscommon.PubkeyConverterStub{ LenCalled: func() int { return len(tx.RcvAddr) }, diff --git a/process/dataValidators/txValidator.go b/process/dataValidators/txValidator.go index a49b82254f0..56a9a44ec1e 100644 --- a/process/dataValidators/txValidator.go +++ b/process/dataValidators/txValidator.go @@ -9,10 +9,13 @@ import ( "github.com/multiversx/mx-chain-go/process/interceptors/processor" "github.com/multiversx/mx-chain-go/sharding" "github.com/multiversx/mx-chain-go/state" + logger "github.com/multiversx/mx-chain-logger-go" ) var _ process.TxValidator = (*txValidator)(nil) +var log = logger.GetOrCreate("process/dataValidators") + // txValidator represents a tx handler validator that doesn't check the validity of provided txHandler type txValidator struct { accounts state.AccountsAdapter @@ -71,11 +74,12 @@ func (txv *txValidator) CheckTxValidity(interceptedTx process.TxValidatorHandler } senderAddress := interceptedTx.SenderAddress() + accountHandler, err := txv.accounts.GetExistingAccount(senderAddress) if err != nil { return fmt.Errorf("%w for address %s and shard %d, err: %s", process.ErrAccountNotFound, - txv.pubkeyConverter.Encode(senderAddress), + txv.pubkeyConverter.SilentEncode(senderAddress, log), shardID, err.Error(), ) @@ -98,7 +102,7 @@ func (txv *txValidator) CheckTxValidity(interceptedTx process.TxValidatorHandler if !ok { return fmt.Errorf("%w, account is not of type *state.Account, address: %s", process.ErrWrongTypeAssertion, - txv.pubkeyConverter.Encode(senderAddress), + txv.pubkeyConverter.SilentEncode(senderAddress, log), ) } @@ -107,7 +111,7 @@ func (txv *txValidator) CheckTxValidity(interceptedTx process.TxValidatorHandler if accountBalance.Cmp(txFee) < 0 { return fmt.Errorf("%w, for address: %s, wanted %v, have %v", process.ErrInsufficientFunds, - txv.pubkeyConverter.Encode(senderAddress), + txv.pubkeyConverter.SilentEncode(senderAddress, log), txFee, accountBalance, ) diff --git a/process/dataValidators/txValidator_test.go b/process/dataValidators/txValidator_test.go index fa128c700ac..83c9e6651d0 100644 --- a/process/dataValidators/txValidator_test.go +++ b/process/dataValidators/txValidator_test.go @@ -76,7 +76,7 @@ func TestNewTxValidator_NilAccountsShouldErr(t *testing.T) { nil, shardCoordinator, &testscommon.WhiteListHandlerStub{}, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), maxNonceDeltaAllowed, ) @@ -93,7 +93,7 @@ func TestNewTxValidator_NilShardCoordinatorShouldErr(t *testing.T) { adb, nil, &testscommon.WhiteListHandlerStub{}, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), maxNonceDeltaAllowed, ) @@ -111,7 +111,7 @@ func TestTxValidator_NewValidatorNilWhiteListHandlerShouldErr(t *testing.T) { adb, shardCoordinator, nil, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), maxNonceDeltaAllowed, ) @@ -147,7 +147,7 @@ func TestNewTxValidator_ShouldWork(t *testing.T) { adb, shardCoordinator, &testscommon.WhiteListHandlerStub{}, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), maxNonceDeltaAllowed, ) @@ -169,7 +169,7 @@ func TestTxValidator_CheckTxValidityTxCrossShardShouldWork(t *testing.T) { adb, shardCoordinator, &testscommon.WhiteListHandlerStub{}, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), maxNonceDeltaAllowed, ) assert.Nil(t, err) @@ -194,7 +194,7 @@ func TestTxValidator_CheckTxValidityAccountNonceIsGreaterThanTxNonceShouldReturn adb, shardCoordinator, &testscommon.WhiteListHandlerStub{}, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), maxNonceDeltaAllowed, ) assert.Nil(t, err) @@ -220,7 +220,7 @@ func TestTxValidator_CheckTxValidityTxNonceIsTooHigh(t *testing.T) { adb, shardCoordinator, &testscommon.WhiteListHandlerStub{}, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), maxNonceDeltaAllowed, ) assert.Nil(t, err) @@ -248,7 +248,7 @@ func TestTxValidator_CheckTxValidityAccountBalanceIsLessThanTxTotalValueShouldRe adb, shardCoordinator, &testscommon.WhiteListHandlerStub{}, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), maxNonceDeltaAllowed, ) assert.Nil(t, err) @@ -275,7 +275,7 @@ func TestTxValidator_CheckTxValidityAccountNotExitsShouldReturnFalse(t *testing. accDB, shardCoordinator, &testscommon.WhiteListHandlerStub{}, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), maxNonceDeltaAllowed, ) @@ -304,7 +304,7 @@ func TestTxValidator_CheckTxValidityAccountNotExitsButWhiteListedShouldReturnTru return true }, }, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), maxNonceDeltaAllowed, ) @@ -338,7 +338,7 @@ func TestTxValidator_CheckTxValidityWrongAccountTypeShouldReturnFalse(t *testing accDB, shardCoordinator, &testscommon.WhiteListHandlerStub{}, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), maxNonceDeltaAllowed, ) @@ -362,7 +362,7 @@ func TestTxValidator_CheckTxValidityTxIsOkShouldReturnTrue(t *testing.T) { adb, shardCoordinator, &testscommon.WhiteListHandlerStub{}, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), maxNonceDeltaAllowed, ) @@ -385,7 +385,7 @@ func TestTxValidator_IsInterfaceNil(t *testing.T) { adb, shardCoordinator, &testscommon.WhiteListHandlerStub{}, - mock.NewPubkeyConverterMock(32), + testscommon.NewPubkeyConverterMock(32), 100, ) _ = txValidator diff --git a/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go b/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go index 56a8a3ce1eb..1f5b5d09d87 100644 --- a/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go +++ b/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go @@ -638,7 +638,7 @@ func TestShardInterceptorsContainerFactory_With4ShardsShouldWork(t *testing.T) { } coreComp, cryptoComp := createMockComponentHolders() - coreComp.AddrPubKeyConv = mock.NewPubkeyConverterMock(32) + coreComp.AddrPubKeyConv = testscommon.NewPubkeyConverterMock(32) args := getArgumentsShard(coreComp, cryptoComp) args.ShardCoordinator = shardCoordinator args.NodesCoordinator = nodesCoordinator @@ -675,7 +675,7 @@ func createMockComponentHolders() (*mock.CoreComponentsMock, *mock.CryptoCompone TxSignHasherField: &hashingMocks.HasherMock{}, Hash: &hashingMocks.HasherMock{}, UInt64ByteSliceConv: mock.NewNonceHashConverterMock(), - AddrPubKeyConv: mock.NewPubkeyConverterMock(32), + AddrPubKeyConv: testscommon.NewPubkeyConverterMock(32), ChainIdCalled: func() string { return chainID }, diff --git a/process/factory/metachain/intermediateProcessorsContainerFactory_test.go b/process/factory/metachain/intermediateProcessorsContainerFactory_test.go index 4e404bab83b..03826424f18 100644 --- a/process/factory/metachain/intermediateProcessorsContainerFactory_test.go +++ b/process/factory/metachain/intermediateProcessorsContainerFactory_test.go @@ -6,14 +6,15 @@ import ( "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/factory/metachain" "github.com/multiversx/mx-chain-go/process/mock" + "github.com/multiversx/mx-chain-go/testscommon" dataRetrieverMock "github.com/multiversx/mx-chain-go/testscommon/dataRetriever" "github.com/multiversx/mx-chain-go/testscommon/hashingMocks" storageStubs "github.com/multiversx/mx-chain-go/testscommon/storage" "github.com/stretchr/testify/assert" ) -func createMockPubkeyConverter() *mock.PubkeyConverterMock { - return mock.NewPubkeyConverterMock(32) +func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { + return testscommon.NewPubkeyConverterMock(32) } func TestNewIntermediateProcessorsContainerFactory_NilShardCoord(t *testing.T) { diff --git a/process/factory/metachain/vmContainerFactory_test.go b/process/factory/metachain/vmContainerFactory_test.go index 582ee01a83f..824cd787560 100644 --- a/process/factory/metachain/vmContainerFactory_test.go +++ b/process/factory/metachain/vmContainerFactory_test.go @@ -26,7 +26,7 @@ import ( func createVmContainerMockArgument(gasSchedule core.GasScheduleNotifier) ArgsNewVMContainerFactory { return ArgsNewVMContainerFactory{ BlockChainHook: &testscommon.BlockChainHookStub{}, - PubkeyConv: mock.NewPubkeyConverterMock(32), + PubkeyConv: testscommon.NewPubkeyConverterMock(32), Economics: &economicsmocks.EconomicsHandlerStub{}, MessageSignVerifier: &mock.MessageSignVerifierMock{}, GasSchedule: gasSchedule, @@ -286,7 +286,7 @@ func TestVmContainerFactory_Create(t *testing.T) { argsNewVMContainerFactory := ArgsNewVMContainerFactory{ BlockChainHook: &testscommon.BlockChainHookStub{}, - PubkeyConv: mock.NewPubkeyConverterMock(32), + PubkeyConv: testscommon.NewPubkeyConverterMock(32), Economics: economicsData, MessageSignVerifier: &mock.MessageSignVerifierMock{}, GasSchedule: makeGasSchedule(), diff --git a/process/factory/shard/intermediateProcessorsContainerFactory_test.go b/process/factory/shard/intermediateProcessorsContainerFactory_test.go index 5c415cb4214..bcec9873e60 100644 --- a/process/factory/shard/intermediateProcessorsContainerFactory_test.go +++ b/process/factory/shard/intermediateProcessorsContainerFactory_test.go @@ -47,8 +47,8 @@ func createDataPools() dataRetriever.PoolsHolder { return pools } -func createMockPubkeyConverter() *mock.PubkeyConverterMock { - return mock.NewPubkeyConverterMock(32) +func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { + return testscommon.NewPubkeyConverterMock(32) } func TestNewIntermediateProcessorsContainerFactory_NilShardCoord(t *testing.T) { diff --git a/process/factory/shard/preProcessorsContainerFactory_test.go b/process/factory/shard/preProcessorsContainerFactory_test.go index 1a9f5938433..a44ffddcc87 100644 --- a/process/factory/shard/preProcessorsContainerFactory_test.go +++ b/process/factory/shard/preProcessorsContainerFactory_test.go @@ -14,8 +14,8 @@ import ( "github.com/stretchr/testify/assert" ) -func createMockPubkeyConverter() *mock.PubkeyConverterMock { - return mock.NewPubkeyConverterMock(32) +func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { + return testscommon.NewPubkeyConverterMock(32) } func TestNewPreProcessorsContainerFactory_NilShardCoordinator(t *testing.T) { diff --git a/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go b/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go index beb4ecd7c18..ba0bda4a67c 100644 --- a/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go +++ b/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go @@ -50,7 +50,7 @@ func createMockSigner() crypto.SingleSigner { } func createMockPubkeyConverter() core.PubkeyConverter { - return mock.NewPubkeyConverterMock(32) + return testscommon.NewPubkeyConverterMock(32) } func createMockFeeHandler() process.FeeHandler { diff --git a/process/mock/pubkeyConverterMock.go b/process/mock/pubkeyConverterMock.go deleted file mode 100644 index 2495757f430..00000000000 --- a/process/mock/pubkeyConverterMock.go +++ /dev/null @@ -1,37 +0,0 @@ -package mock - -import ( - "encoding/hex" -) - -// PubkeyConverterMock - -type PubkeyConverterMock struct { - len int -} - -// NewPubkeyConverterMock - -func NewPubkeyConverterMock(addressLen int) *PubkeyConverterMock { - return &PubkeyConverterMock{ - len: addressLen, - } -} - -// Decode - -func (pcm *PubkeyConverterMock) Decode(humanReadable string) ([]byte, error) { - return hex.DecodeString(humanReadable) -} - -// Encode - -func (pcm *PubkeyConverterMock) Encode(pkBytes []byte) string { - return hex.EncodeToString(pkBytes) -} - -// Len - -func (pcm *PubkeyConverterMock) Len() int { - return pcm.len -} - -// IsInterfaceNil - -func (pcm *PubkeyConverterMock) IsInterfaceNil() bool { - return pcm == nil -} diff --git a/process/mock/pubkeyConverterStub.go b/process/mock/pubkeyConverterStub.go deleted file mode 100644 index f8ef5507235..00000000000 --- a/process/mock/pubkeyConverterStub.go +++ /dev/null @@ -1,40 +0,0 @@ -package mock - -// PubkeyConverterStub - -type PubkeyConverterStub struct { - LenCalled func() int - DecodeCalled func(humanReadable string) ([]byte, error) - EncodeCalled func(pkBytes []byte) string -} - -// Len - -func (pcs *PubkeyConverterStub) Len() int { - if pcs.LenCalled != nil { - return pcs.LenCalled() - } - - return 0 -} - -// Decode - -func (pcs *PubkeyConverterStub) Decode(humanReadable string) ([]byte, error) { - if pcs.DecodeCalled != nil { - return pcs.DecodeCalled(humanReadable) - } - - return make([]byte, 0), nil -} - -// Encode - -func (pcs *PubkeyConverterStub) Encode(pkBytes []byte) string { - if pcs.EncodeCalled != nil { - return pcs.EncodeCalled(pkBytes) - } - - return "" -} - -// IsInterfaceNil - -func (pcs *PubkeyConverterStub) IsInterfaceNil() bool { - return pcs == nil -} diff --git a/process/peer/process.go b/process/peer/process.go index d5ed5d06b2e..83b3e2616c3 100644 --- a/process/peer/process.go +++ b/process/peer/process.go @@ -365,7 +365,10 @@ func (vs *validatorStatistics) UpdatePeerState(header data.MetaHeaderHandler, ca if err != nil { return nil, err } - leaderPK := core.GetTrimmedPk(vs.pubkeyConv.Encode(consensusGroup[0].PubKey())) + + encodedLeaderPk := vs.pubkeyConv.SilentEncode(consensusGroup[0].PubKey(), log) + + leaderPK := core.GetTrimmedPk(encodedLeaderPk) log.Trace("Increasing for leader", "leader", leaderPK, "round", previousHeader.GetRound()) log.Debug("UpdatePeerState - registering meta previous leader fees", "metaNonce", previousHeader.GetNonce()) @@ -774,7 +777,9 @@ func (vs *validatorStatistics) computeDecrease( swInner.Start("loadPeerAccount") leaderPeerAcc, err := vs.loadPeerAccount(consensusGroup[0].PubKey()) - leaderPK := core.GetTrimmedPk(vs.pubkeyConv.Encode(consensusGroup[0].PubKey())) + + encodedLeaderPk := vs.pubkeyConv.SilentEncode(consensusGroup[0].PubKey(), log) + leaderPK := core.GetTrimmedPk(encodedLeaderPk) swInner.Stop("loadPeerAccount") if err != nil { return err diff --git a/process/peer/process_test.go b/process/peer/process_test.go index ee1bab03e7f..8d35dd9d45a 100644 --- a/process/peer/process_test.go +++ b/process/peer/process_test.go @@ -50,8 +50,8 @@ const ( consensusGroupFormat = "%s_%v_%v_%v" ) -func createMockPubkeyConverter() *mock.PubkeyConverterMock { - return mock.NewPubkeyConverterMock(32) +func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { + return testscommon.NewPubkeyConverterMock(32) } func createMockArguments() peer.ArgValidatorStatisticsProcessor { @@ -1983,7 +1983,7 @@ func TestValidatorStatistics_ResetValidatorStatisticsAtNewEpoch(t *testing.T) { return nil, expectedErr } arguments.PeerAdapter = peerAdapter - arguments.PubkeyConv = mock.NewPubkeyConverterMock(4) + arguments.PubkeyConv = testscommon.NewPubkeyConverterMock(4) validatorStatistics, _ := peer.NewValidatorStatisticsProcessor(arguments) validatorInfos, _ := validatorStatistics.GetValidatorInfoForRootHash(hash) diff --git a/process/peer/validatorsProvider.go b/process/peer/validatorsProvider.go index 037eac433c8..ee363c04d4f 100644 --- a/process/peer/validatorsProvider.go +++ b/process/peer/validatorsProvider.go @@ -221,7 +221,8 @@ func (vp *validatorsProvider) createValidatorApiResponseMapFromValidatorInfoMap( newCache := make(map[string]*state.ValidatorApiResponse) for _, validatorInfosInShard := range allNodes { for _, validatorInfo := range validatorInfosInShard { - strKey := vp.pubkeyConverter.Encode(validatorInfo.PublicKey) + strKey := vp.pubkeyConverter.SilentEncode(validatorInfo.PublicKey, log) + newCache[strKey] = &state.ValidatorApiResponse{ NumLeaderSuccess: validatorInfo.LeaderSuccess, NumLeaderFailure: validatorInfo.LeaderFailure, @@ -252,8 +253,10 @@ func (vp *validatorsProvider) aggregateLists( ) { for shardID, shardValidators := range validatorsMap { for _, val := range shardValidators { - encodedKey := vp.pubkeyConverter.Encode(val) + encodedKey := vp.pubkeyConverter.SilentEncode(val, log) + foundInTrieValidator, ok := newCache[encodedKey] + peerType := string(currentList) if !ok || foundInTrieValidator == nil { diff --git a/process/peer/validatorsProvider_test.go b/process/peer/validatorsProvider_test.go index e9ab1e35c64..a97718fff09 100644 --- a/process/peer/validatorsProvider_test.go +++ b/process/peer/validatorsProvider_test.go @@ -19,6 +19,7 @@ import ( "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/mock" "github.com/multiversx/mx-chain-go/state" + "github.com/multiversx/mx-chain-go/testscommon" "github.com/multiversx/mx-chain-go/testscommon/shardingMocks" "github.com/pkg/errors" "github.com/stretchr/testify/assert" @@ -211,7 +212,7 @@ func TestValidatorsProvider_UpdateCache_WithError(t *testing.T) { cacheRefreshIntervalDuration: arg.CacheRefreshIntervalDurationInSec, refreshCache: nil, lock: sync.RWMutex{}, - pubkeyConverter: mock.NewPubkeyConverterMock(32), + pubkeyConverter: testscommon.NewPubkeyConverterMock(32), } vsp.updateCache() @@ -286,7 +287,7 @@ func TestValidatorsProvider_UpdateCache(t *testing.T) { cache: nil, cacheRefreshIntervalDuration: arg.CacheRefreshIntervalDurationInSec, refreshCache: nil, - pubkeyConverter: mock.NewPubkeyConverterMock(32), + pubkeyConverter: testscommon.NewPubkeyConverterMock(32), lock: sync.RWMutex{}, } @@ -294,14 +295,15 @@ func TestValidatorsProvider_UpdateCache(t *testing.T) { assert.NotNil(t, vsp.cache) assert.Equal(t, len(validatorsMap[initialShardId]), len(vsp.cache)) - encodedKey := arg.PubKeyConverter.Encode(pk) + encodedKey, err := arg.PubKeyConverter.Encode(pk) + assert.Nil(t, err) assert.NotNil(t, vsp.cache[encodedKey]) assert.Equal(t, initialList, vsp.cache[encodedKey].ValidatorStatus) assert.Equal(t, initialShardId, vsp.cache[encodedKey].ShardId) } func TestValidatorsProvider_aggregatePType_equal(t *testing.T) { - pubKeyConverter := mock.NewPubkeyConverterMock(32) + pubKeyConverter := testscommon.NewPubkeyConverterMock(32) pkInactive := []byte("pk1") trieInctiveShardId := uint32(0) inactiveList := string(common.InactiveList) @@ -312,9 +314,12 @@ func TestValidatorsProvider_aggregatePType_equal(t *testing.T) { trieLeavingShardId := uint32(2) leavingList := string(common.LeavingList) - encodedEligible := pubKeyConverter.Encode(pkEligible) - encondedInactive := pubKeyConverter.Encode(pkInactive) - encodedLeaving := pubKeyConverter.Encode(pkLeaving) + encodedEligible, err := pubKeyConverter.Encode(pkEligible) + assert.Nil(t, err) + encondedInactive, err := pubKeyConverter.Encode(pkInactive) + assert.Nil(t, err) + encodedLeaving, err := pubKeyConverter.Encode(pkLeaving) + assert.Nil(t, err) cache := make(map[string]*state.ValidatorApiResponse) cache[encondedInactive] = &state.ValidatorApiResponse{ValidatorStatus: inactiveList, ShardId: trieInctiveShardId} cache[encodedEligible] = &state.ValidatorApiResponse{ValidatorStatus: eligibleList, ShardId: trieEligibleShardId} @@ -399,7 +404,7 @@ func TestValidatorsProvider_createCache(t *testing.T) { }, } arg := createDefaultValidatorsProviderArg() - pubKeyConverter := mock.NewPubkeyConverterMock(32) + pubKeyConverter := testscommon.NewPubkeyConverterMock(32) vsp := validatorsProvider{ nodesCoordinator: arg.NodesCoordinator, validatorStatistics: arg.ValidatorStatistics, @@ -413,22 +418,26 @@ func TestValidatorsProvider_createCache(t *testing.T) { assert.NotNil(t, cache) - encodedPkEligible := pubKeyConverter.Encode(pkEligible) + encodedPkEligible, err := pubKeyConverter.Encode(pkEligible) + assert.Nil(t, err) assert.NotNil(t, cache[encodedPkEligible]) assert.Equal(t, eligibleList, cache[encodedPkEligible].ValidatorStatus) assert.Equal(t, eligibleShardId, cache[encodedPkEligible].ShardId) - encodedPkWaiting := pubKeyConverter.Encode(pkWaiting) + encodedPkWaiting, err := pubKeyConverter.Encode(pkWaiting) + assert.Nil(t, err) assert.NotNil(t, cache[encodedPkWaiting]) assert.Equal(t, waitingList, cache[encodedPkWaiting].ValidatorStatus) assert.Equal(t, waitingShardId, cache[encodedPkWaiting].ShardId) - encodedPkLeaving := pubKeyConverter.Encode(pkLeaving) + encodedPkLeaving, err := pubKeyConverter.Encode(pkLeaving) + assert.Nil(t, err) assert.NotNil(t, cache[encodedPkLeaving]) assert.Equal(t, leavingList, cache[encodedPkLeaving].ValidatorStatus) assert.Equal(t, leavingShardId, cache[encodedPkLeaving].ShardId) - encodedPkNew := pubKeyConverter.Encode(pkNew) + encodedPkNew, err := pubKeyConverter.Encode(pkNew) + assert.Nil(t, err) assert.NotNil(t, cache[encodedPkNew]) assert.Equal(t, newList, cache[encodedPkNew].ValidatorStatus) assert.Equal(t, newShardId, cache[encodedPkNew].ShardId) @@ -489,12 +498,14 @@ func TestValidatorsProvider_createCache_combined(t *testing.T) { cache := vsp.createNewCache(0, validatorsMap) - encodedPkEligible := arg.PubKeyConverter.Encode(pkEligibleInTrie) + encodedPkEligible, err := arg.PubKeyConverter.Encode(pkEligibleInTrie) + assert.Nil(t, err) assert.NotNil(t, cache[encodedPkEligible]) assert.Equal(t, eligibleList, cache[encodedPkEligible].ValidatorStatus) assert.Equal(t, nodesCoordinatorEligibleShardId, cache[encodedPkEligible].ShardId) - encodedPkLeavingInTrie := arg.PubKeyConverter.Encode(pkLeavingInTrie) + encodedPkLeavingInTrie, err := arg.PubKeyConverter.Encode(pkLeavingInTrie) + assert.Nil(t, err) computedPeerType := fmt.Sprintf(common.CombinedPeerType, common.EligibleList, common.LeavingList) assert.NotNil(t, cache[encodedPkLeavingInTrie]) assert.Equal(t, computedPeerType, cache[encodedPkLeavingInTrie].ValidatorStatus) @@ -571,7 +582,8 @@ func TestValidatorsProvider_CallsUpdateCacheOnEpochChange(t *testing.T) { arg.ValidatorStatistics = validatorStatisticsProcessor vsp, _ := NewValidatorsProvider(arg) - encodedEligible := arg.PubKeyConverter.Encode(pkEligibleInTrie) + encodedEligible, err := arg.PubKeyConverter.Encode(pkEligibleInTrie) + assert.Nil(t, err) assert.Equal(t, 0, len(vsp.GetCache())) // nothing in cache epochStartNotifier.NotifyAll(&block.Header{Nonce: 1, ShardID: 2, Round: 3}) time.Sleep(arg.CacheRefreshIntervalDurationInSec) @@ -610,7 +622,8 @@ func TestValidatorsProvider_DoesntCallUpdateUpdateCacheWithoutRequests(t *testin arg.ValidatorStatistics = validatorStatisticsProcessor vsp, _ := NewValidatorsProvider(arg) - encodedEligible := arg.PubKeyConverter.Encode(pkEligibleInTrie) + encodedEligible, err := arg.PubKeyConverter.Encode(pkEligibleInTrie) + assert.Nil(t, err) assert.Equal(t, 0, len(vsp.GetCache())) // nothing in cache time.Sleep(arg.CacheRefreshIntervalDurationInSec) assert.Equal(t, 0, len(vsp.GetCache())) // nothing in cache @@ -668,6 +681,6 @@ func createDefaultValidatorsProviderArg() ArgValidatorsProvider { }, }, MaxRating: 100, - PubKeyConverter: mock.NewPubkeyConverterMock(32), + PubKeyConverter: testscommon.NewPubkeyConverterMock(32), } } diff --git a/process/rewardTransaction/interceptedRewardTransaction_test.go b/process/rewardTransaction/interceptedRewardTransaction_test.go index 1fe5c3d1412..de27f51a130 100644 --- a/process/rewardTransaction/interceptedRewardTransaction_test.go +++ b/process/rewardTransaction/interceptedRewardTransaction_test.go @@ -10,13 +10,14 @@ import ( "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/mock" "github.com/multiversx/mx-chain-go/process/rewardTransaction" + "github.com/multiversx/mx-chain-go/testscommon" "github.com/multiversx/mx-chain-go/testscommon/hashingMocks" logger "github.com/multiversx/mx-chain-logger-go" "github.com/stretchr/testify/assert" ) -func createMockPubkeyConverter() *mock.PubkeyConverterMock { - return mock.NewPubkeyConverterMock(32) +func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { + return testscommon.NewPubkeyConverterMock(32) } func TestNewInterceptedRewardTransaction_NilTxBuffShouldErr(t *testing.T) { diff --git a/process/scToProtocol/stakingToPeer_test.go b/process/scToProtocol/stakingToPeer_test.go index 5a81eec805f..b32ffeddcf0 100644 --- a/process/scToProtocol/stakingToPeer_test.go +++ b/process/scToProtocol/stakingToPeer_test.go @@ -29,7 +29,7 @@ import ( func createMockArgumentsNewStakingToPeer() ArgStakingToPeer { return ArgStakingToPeer{ - PubkeyConv: mock.NewPubkeyConverterMock(32), + PubkeyConv: testscommon.NewPubkeyConverterMock(32), Hasher: &hashingMocks.HasherMock{}, Marshalizer: &mock.MarshalizerStub{}, PeerState: &stateMock.AccountsStub{}, diff --git a/process/smartContract/hooks/blockChainHook_test.go b/process/smartContract/hooks/blockChainHook_test.go index a201c4b5c1c..ad04afc1f7a 100644 --- a/process/smartContract/hooks/blockChainHook_test.go +++ b/process/smartContract/hooks/blockChainHook_test.go @@ -46,7 +46,7 @@ func createMockBlockChainHookArgs() hooks.ArgBlockChainHook { return &stateMock.AccountWrapMock{}, nil }, }, - PubkeyConv: mock.NewPubkeyConverterMock(32), + PubkeyConv: testscommon.NewPubkeyConverterMock(32), StorageService: &storageStubs.ChainStorerStub{}, BlockChain: &testscommon.ChainHandlerStub{}, ShardCoordinator: mock.NewOneShardCoordinatorMock(), diff --git a/process/smartContract/process.go b/process/smartContract/process.go index 7fd952a00bb..990095a617a 100644 --- a/process/smartContract/process.go +++ b/process/smartContract/process.go @@ -432,8 +432,8 @@ func (sc *scProcessor) printBlockchainHookCounters(tx data.TransactionHandler) { logCounters.Trace("blockchain hook counters", "counters", sc.getBlockchainHookCountersString(), "tx hash", sc.computeTxHashUnsafe(tx), - "receiver", sc.pubkeyConv.Encode(tx.GetRcvAddr()), - "sender", sc.pubkeyConv.Encode(tx.GetSndAddr()), + "receiver", sc.pubkeyConv.SilentEncode(tx.GetRcvAddr(), log), + "sender", sc.pubkeyConv.SilentEncode(tx.GetSndAddr(), log), "value", tx.GetValue().String(), "data", tx.GetData(), ) @@ -1800,11 +1800,14 @@ func (sc *scProcessor) printScDeployed(vmOutput *vmcommon.VMOutput, tx data.Tran continue } - scGenerated = append(scGenerated, sc.pubkeyConv.Encode(addr)) + scAddress := sc.pubkeyConv.SilentEncode(addr, log) + scGenerated = append(scGenerated, scAddress) } + ownerAddress := sc.pubkeyConv.SilentEncode(tx.GetSndAddr(), log) + log.Debug("SmartContract deployed", - "owner", sc.pubkeyConv.Encode(tx.GetSndAddr()), + "owner", ownerAddress, "SC address(es)", strings.Join(scGenerated, ", ")) } @@ -2610,12 +2613,14 @@ func (sc *scProcessor) updateSmartContractCode( }, } + encodedOutputAccountAddr := sc.pubkeyConv.SilentEncode(outputAccount.Address, log) + if isDeployment { // At this point, we are under the condition "noExistingOwner" stateAccount.SetOwnerAddress(outputAccount.CodeDeployerAddress) stateAccount.SetCodeMetadata(outputAccountCodeMetadataBytes) stateAccount.SetCode(outputAccount.Code) - log.Debug("updateSmartContractCode(): created", "address", sc.pubkeyConv.Encode(outputAccount.Address), "upgradeable", newCodeMetadata.Upgradeable) + log.Debug("updateSmartContractCode(): created", "address", encodedOutputAccountAddr, "upgradeable", newCodeMetadata.Upgradeable) entry.Identifier = []byte(core.SCDeployIdentifier) vmOutput.Logs = append(vmOutput.Logs, entry) @@ -2625,7 +2630,7 @@ func (sc *scProcessor) updateSmartContractCode( if isUpgrade { stateAccount.SetCodeMetadata(outputAccountCodeMetadataBytes) stateAccount.SetCode(outputAccount.Code) - log.Debug("updateSmartContractCode(): upgraded", "address", sc.pubkeyConv.Encode(outputAccount.Address), "upgradeable", newCodeMetadata.Upgradeable) + log.Debug("updateSmartContractCode(): upgraded", "address", encodedOutputAccountAddr, "upgradeable", newCodeMetadata.Upgradeable) entry.Identifier = []byte(core.SCUpgradeIdentifier) vmOutput.Logs = append(vmOutput.Logs, entry) diff --git a/process/smartContract/process_test.go b/process/smartContract/process_test.go index 24263d2c765..768f452bf51 100644 --- a/process/smartContract/process_test.go +++ b/process/smartContract/process_test.go @@ -44,8 +44,8 @@ func generateEmptyByteSlice(size int) []byte { return buff } -func createMockPubkeyConverter() *mock.PubkeyConverterMock { - return mock.NewPubkeyConverterMock(32) +func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { + return testscommon.NewPubkeyConverterMock(32) } func createAccounts(tx data.TransactionHandler) (state.UserAccountHandler, state.UserAccountHandler) { @@ -917,7 +917,7 @@ func TestScProcessor_DeploySmartContractNotEmptyDestinationAddress(t *testing.T) arguments := createMockSmartContractProcessorArguments() arguments.VmContainer = vm arguments.ArgsParser = argParser - arguments.PubkeyConv = mock.NewPubkeyConverterMock(3) + arguments.PubkeyConv = testscommon.NewPubkeyConverterMock(3) sc, _ := NewSmartContractProcessor(arguments) tx := &transaction.Transaction{} diff --git a/process/transaction/interceptedTransaction_test.go b/process/transaction/interceptedTransaction_test.go index 92a658ffaa3..d1d525fde4b 100644 --- a/process/transaction/interceptedTransaction_test.go +++ b/process/transaction/interceptedTransaction_test.go @@ -36,8 +36,8 @@ var recvAddress = []byte("23456789012345678901234567890123") var sigBad = []byte("bad-signature") var sigOk = []byte("signature") -func createMockPubkeyConverter() *mock.PubkeyConverterMock { - return mock.NewPubkeyConverterMock(32) +func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { + return testscommon.NewPubkeyConverterMock(32) } func createDummySigner() crypto.SingleSigner { @@ -98,7 +98,7 @@ func createInterceptedTxFromPlainTx(tx *dataTransaction.Transaction, txFeeHandle &hashingMocks.HasherMock{}, createKeyGenMock(), createDummySigner(), - &mock.PubkeyConverterStub{ + &testscommon.PubkeyConverterStub{ LenCalled: func() int { return 32 }, @@ -141,7 +141,7 @@ func createInterceptedTxFromPlainTxWithArgParser(tx *dataTransaction.Transaction &hashingMocks.HasherMock{}, createKeyGenMock(), createDummySigner(), - &mock.PubkeyConverterStub{ + &testscommon.PubkeyConverterStub{ LenCalled: func() int { return 32 }, @@ -991,7 +991,7 @@ func TestInterceptedTransaction_CheckValiditySignedWithHashButNotEnabled(t *test &hashingMocks.HasherMock{}, createKeyGenMock(), createDummySigner(), - &mock.PubkeyConverterStub{ + &testscommon.PubkeyConverterStub{ LenCalled: func() int { return 32 }, @@ -1051,7 +1051,7 @@ func TestInterceptedTransaction_CheckValiditySignedWithHashShoudWork(t *testing. &hashingMocks.HasherMock{}, createKeyGenMock(), createDummySigner(), - &mock.PubkeyConverterStub{ + &testscommon.PubkeyConverterStub{ LenCalled: func() int { return 32 }, @@ -1140,7 +1140,7 @@ func TestInterceptedTransaction_ScTxDeployRecvShardIdShouldBeSendersShardId(t *t &hashingMocks.HasherMock{}, createKeyGenMock(), createDummySigner(), - &mock.PubkeyConverterStub{}, + &testscommon.PubkeyConverterStub{}, shardCoordinator, createFreeTxFeeHandler(), &testscommon.WhiteListHandlerStub{}, @@ -1275,7 +1275,7 @@ func TestInterceptedTransaction_CheckValiditySecondTimeDoesNotVerifySig(t *testi &hashingMocks.HasherMock{}, createKeyGenMock(), signer, - &mock.PubkeyConverterStub{ + &testscommon.PubkeyConverterStub{ LenCalled: func() int { return 32 }, @@ -1570,7 +1570,7 @@ func TestInterceptedTransaction_Fee(t *testing.T) { &hashingMocks.HasherMock{}, createKeyGenMock(), createDummySigner(), - &mock.PubkeyConverterStub{}, + &testscommon.PubkeyConverterStub{}, shardCoordinator, createFreeTxFeeHandler(), &testscommon.WhiteListHandlerStub{}, @@ -1613,7 +1613,7 @@ func TestInterceptedTransaction_String(t *testing.T) { &hashingMocks.HasherMock{}, createKeyGenMock(), createDummySigner(), - &mock.PubkeyConverterStub{}, + &testscommon.PubkeyConverterStub{}, shardCoordinator, createFreeTxFeeHandler(), &testscommon.WhiteListHandlerStub{}, diff --git a/process/transaction/shardProcess_test.go b/process/transaction/shardProcess_test.go index 8a881499a4b..e90df69d19b 100644 --- a/process/transaction/shardProcess_test.go +++ b/process/transaction/shardProcess_test.go @@ -1284,7 +1284,7 @@ func TestTxProcessor_ProcessTransactionScTxShouldNotBeCalledWhenAdrDstIsNotInNod esdtTransferParser, _ := parsers.NewESDTTransferParser(&mock.MarshalizerMock{}) argsTxTypeHandler := coordinator.ArgNewTxTypeHandler{ - PubkeyConverter: mock.NewPubkeyConverterMock(32), + PubkeyConverter: testscommon.NewPubkeyConverterMock(32), ShardCoordinator: shardCoordinator, BuiltInFunctions: builtInFunctions.NewBuiltInFunctionContainer(), ArgumentParser: parsers.NewCallArgsParser(), @@ -1620,7 +1620,7 @@ func TestTxProcessor_ProcessTransactionShouldTreatAsInvalidTxIfTxTypeIsWrong(t * func TestTxProcessor_ProcessRelayedTransactionV2NotActiveShouldErr(t *testing.T) { t.Parallel() - pubKeyConverter := mock.NewPubkeyConverterMock(4) + pubKeyConverter := testscommon.NewPubkeyConverterMock(4) userAddr := []byte("user") tx := transaction.Transaction{} @@ -1702,7 +1702,7 @@ func TestTxProcessor_ProcessRelayedTransactionV2NotActiveShouldErr(t *testing.T) func TestTxProcessor_ProcessRelayedTransactionV2WithValueShouldErr(t *testing.T) { t.Parallel() - pubKeyConverter := mock.NewPubkeyConverterMock(4) + pubKeyConverter := testscommon.NewPubkeyConverterMock(4) userAddr := []byte("user") tx := transaction.Transaction{} @@ -1784,7 +1784,7 @@ func TestTxProcessor_ProcessRelayedTransactionV2WithValueShouldErr(t *testing.T) func TestTxProcessor_ProcessRelayedTransactionV2ArgsParserShouldErr(t *testing.T) { t.Parallel() - pubKeyConverter := mock.NewPubkeyConverterMock(4) + pubKeyConverter := testscommon.NewPubkeyConverterMock(4) userAddr := []byte("user") tx := transaction.Transaction{} @@ -1871,7 +1871,7 @@ func TestTxProcessor_ProcessRelayedTransactionV2ArgsParserShouldErr(t *testing.T func TestTxProcessor_ProcessRelayedTransactionV2InvalidParamCountShouldErr(t *testing.T) { t.Parallel() - pubKeyConverter := mock.NewPubkeyConverterMock(4) + pubKeyConverter := testscommon.NewPubkeyConverterMock(4) userAddr := []byte("user") tx := transaction.Transaction{} @@ -1955,7 +1955,7 @@ func TestTxProcessor_ProcessRelayedTransactionV2InvalidParamCountShouldErr(t *te func TestTxProcessor_ProcessRelayedTransactionV2(t *testing.T) { t.Parallel() - pubKeyConverter := mock.NewPubkeyConverterMock(4) + pubKeyConverter := testscommon.NewPubkeyConverterMock(4) userAddr := []byte("user") tx := transaction.Transaction{} @@ -2040,7 +2040,7 @@ func TestTxProcessor_ProcessRelayedTransactionV2(t *testing.T) { func TestTxProcessor_ProcessRelayedTransaction(t *testing.T) { t.Parallel() - pubKeyConverter := mock.NewPubkeyConverterMock(4) + pubKeyConverter := testscommon.NewPubkeyConverterMock(4) userAddr := []byte("user") tx := transaction.Transaction{} @@ -2573,7 +2573,7 @@ func TestTxProcessor_ProcessRelayedTransactionGasLimitMismatchShouldError(t *tes func TestTxProcessor_ProcessRelayedTransactionDisabled(t *testing.T) { t.Parallel() - pubKeyConverter := mock.NewPubkeyConverterMock(4) + pubKeyConverter := testscommon.NewPubkeyConverterMock(4) userAddr := []byte("user") tx := transaction.Transaction{} diff --git a/process/txsimulator/txSimulator.go b/process/txsimulator/txSimulator.go index f2c53e86dc5..0fd72e6a5db 100644 --- a/process/txsimulator/txSimulator.go +++ b/process/txsimulator/txSimulator.go @@ -16,9 +16,12 @@ import ( txSimData "github.com/multiversx/mx-chain-go/process/txsimulator/data" "github.com/multiversx/mx-chain-go/sharding" "github.com/multiversx/mx-chain-go/storage" + logger "github.com/multiversx/mx-chain-logger-go" vmcommon "github.com/multiversx/mx-chain-vm-common-go" ) +var log = logger.GetOrCreate("process/txSimulator") + // ArgsTxSimulator holds the arguments required for creating a new transaction simulator type ArgsTxSimulator struct { TransactionProcessor TransactionProcessor @@ -184,11 +187,14 @@ func (ts *transactionSimulator) addIntermediateTxsToResult(result *txSimData.Sim } func (ts *transactionSimulator) adaptSmartContractResult(scr *smartContractResult.SmartContractResult) *transaction.ApiSmartContractResult { + rcvAddress := ts.addressPubKeyConverter.SilentEncode(scr.RcvAddr, log) + sndAddress := ts.addressPubKeyConverter.SilentEncode(scr.SndAddr, log) + resScr := &transaction.ApiSmartContractResult{ Nonce: scr.Nonce, Value: scr.Value, - RcvAddr: ts.addressPubKeyConverter.Encode(scr.RcvAddr), - SndAddr: ts.addressPubKeyConverter.Encode(scr.SndAddr), + RcvAddr: rcvAddress, + SndAddr: sndAddress, RelayedValue: scr.RelayedValue, Code: string(scr.Code), Data: string(scr.Data), @@ -202,19 +208,22 @@ func (ts *transactionSimulator) adaptSmartContractResult(scr *smartContractResul } if scr.OriginalSender != nil { - resScr.OriginalSender = ts.addressPubKeyConverter.Encode(scr.OriginalSender) + resScr.OriginalSender = ts.addressPubKeyConverter.SilentEncode(scr.OriginalSender, log) } + if scr.RelayerAddr != nil { - resScr.RelayerAddr = ts.addressPubKeyConverter.Encode(scr.RelayerAddr) + resScr.RelayerAddr = ts.addressPubKeyConverter.SilentEncode(scr.RelayerAddr, log) } return resScr } func (ts *transactionSimulator) adaptReceipt(rcpt *receipt.Receipt) *transaction.ApiReceipt { + receiptSenderAddress := ts.addressPubKeyConverter.SilentEncode(rcpt.SndAddr, log) + return &transaction.ApiReceipt{ Value: rcpt.Value, - SndAddr: ts.addressPubKeyConverter.Encode(rcpt.SndAddr), + SndAddr: receiptSenderAddress, Data: string(rcpt.Data), TxHash: hex.EncodeToString(rcpt.TxHash), } diff --git a/process/txsimulator/txSimulator_test.go b/process/txsimulator/txSimulator_test.go index d8a67538096..ea6f3276d22 100644 --- a/process/txsimulator/txSimulator_test.go +++ b/process/txsimulator/txSimulator_test.go @@ -224,7 +224,7 @@ func getTxSimulatorArgs() ArgsTxSimulator { return ArgsTxSimulator{ TransactionProcessor: &testscommon.TxProcessorStub{}, IntermediateProcContainer: &mock.IntermProcessorContainerStub{}, - AddressPubKeyConverter: &mock.PubkeyConverterMock{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterMock{}, ShardCoordinator: mock.NewMultiShardsCoordinatorMock(2), VMOutputCacher: txcache.NewDisabledCache(), Marshalizer: &mock.MarshalizerMock{}, diff --git a/process/unsigned/interceptedUnsignedTransaction_test.go b/process/unsigned/interceptedUnsignedTransaction_test.go index 7ba285869d5..b0c00e4982e 100644 --- a/process/unsigned/interceptedUnsignedTransaction_test.go +++ b/process/unsigned/interceptedUnsignedTransaction_test.go @@ -14,6 +14,7 @@ import ( "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/mock" "github.com/multiversx/mx-chain-go/process/unsigned" + "github.com/multiversx/mx-chain-go/testscommon" "github.com/multiversx/mx-chain-go/testscommon/hashingMocks" logger "github.com/multiversx/mx-chain-logger-go" "github.com/stretchr/testify/assert" @@ -45,13 +46,13 @@ func createInterceptedScrFromPlainScr(scr *smartContractResult.SmartContractResu txBuff, marshalizer, &hashingMocks.HasherMock{}, - &mock.PubkeyConverterStub{}, + &testscommon.PubkeyConverterStub{}, shardCoordinator, ) } -func createMockPubkeyConverter() *mock.PubkeyConverterMock { - return mock.NewPubkeyConverterMock(32) +func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { + return testscommon.NewPubkeyConverterMock(32) } // ------- NewInterceptedUnsignedTransaction diff --git a/sharding/mock/pubkeyConverterMock.go b/sharding/mock/pubkeyConverterMock.go index 2495757f430..e81d21ff4f6 100644 --- a/sharding/mock/pubkeyConverterMock.go +++ b/sharding/mock/pubkeyConverterMock.go @@ -2,6 +2,8 @@ package mock import ( "encoding/hex" + + "github.com/multiversx/mx-chain-core-go/core" ) // PubkeyConverterMock - @@ -22,7 +24,23 @@ func (pcm *PubkeyConverterMock) Decode(humanReadable string) ([]byte, error) { } // Encode - -func (pcm *PubkeyConverterMock) Encode(pkBytes []byte) string { +func (pcm *PubkeyConverterMock) Encode(pkBytes []byte) (string, error) { + return hex.EncodeToString(pkBytes), nil +} + +// EncodeSlice - +func (pcm *PubkeyConverterMock) EncodeSlice(pkBytesSlice [][]byte) ([]string, error) { + encodedSlice := make([]string, 0) + + for _, pkBytes := range pkBytesSlice { + encodedSlice = append(encodedSlice, hex.EncodeToString(pkBytes)) + } + + return encodedSlice, nil +} + +// SilentEncode - +func (pcm *PubkeyConverterMock) SilentEncode(pkBytes []byte, log core.Logger) string { return hex.EncodeToString(pkBytes) } diff --git a/state/accountsDB.go b/state/accountsDB.go index 534e94d703c..b5b452c99d7 100644 --- a/state/accountsDB.go +++ b/state/accountsDB.go @@ -1346,7 +1346,7 @@ func (adb *AccountsDB) snapshotUserAccountDataTrie( ErrChan: iteratorChannels.ErrChan, } if isSnapshot { - address := adb.addressConverter.Encode(account.Address) + address := adb.addressConverter.SilentEncode(account.Address, log) adb.mainTrie.GetStorageManager().TakeSnapshot(address, account.RootHash, mainTrieRootHash, iteratorChannelsForDataTries, missingNodesChannel, stats, epoch) continue } @@ -1455,8 +1455,12 @@ func (adb *AccountsDB) GetStatsForRootHash(rootHash []byte) (common.TriesStatist continue } - address := adb.addressConverter.Encode(account.Address) - collectStats(tr, stats, account.RootHash, address) + accountAddress, err := adb.addressConverter.Encode(account.Address) + if err != nil { + return nil, err + } + + collectStats(tr, stats, account.RootHash, accountAddress) } err = common.GetErrorFromChanNonBlocking(iteratorChannels.ErrChan) diff --git a/state/syncer/userAccountsSyncer.go b/state/syncer/userAccountsSyncer.go index ca2e1142266..0170af9d17e 100644 --- a/state/syncer/userAccountsSyncer.go +++ b/state/syncer/userAccountsSyncer.go @@ -288,7 +288,7 @@ func (u *userAccountsSyncer) printDataTrieStatistics() { }) for _, trieStat := range u.largeTries { - address := u.pubkeyCoverter.Encode(trieStat.address) + address := u.pubkeyCoverter.SilentEncode(trieStat.address, log) log.Debug("datatrie for "+address, "num trie nodes", trieStat.numTrieNodes, diff --git a/testscommon/addresses.go b/testscommon/addresses.go index c7744d29889..79d5b53d4ec 100644 --- a/testscommon/addresses.go +++ b/testscommon/addresses.go @@ -4,11 +4,10 @@ import ( "encoding/hex" "github.com/multiversx/mx-chain-core-go/core/pubkeyConverter" - logger "github.com/multiversx/mx-chain-logger-go" ) // RealWorldBech32PubkeyConverter is a bech32 converter, to be used in tests -var RealWorldBech32PubkeyConverter, _ = pubkeyConverter.NewBech32PubkeyConverter(32, logger.GetOrCreate("testscommon")) +var RealWorldBech32PubkeyConverter, _ = pubkeyConverter.NewBech32PubkeyConverter(32, "erd") var ( // TestAddressAlice is a test address diff --git a/testscommon/components/components.go b/testscommon/components/components.go index 85e27f38e48..c451d18df21 100644 --- a/testscommon/components/components.go +++ b/testscommon/components/components.go @@ -453,6 +453,7 @@ func GetProcessArgs( Length: 32, Type: "bech32", SignatureLength: 0, + Hrp: "erd", }) balance := big.NewInt(0) acc1 := data.InitialAccount{ diff --git a/testscommon/components/configs.go b/testscommon/components/configs.go index 26640cdbdce..f07b8b21bb3 100644 --- a/testscommon/components/configs.go +++ b/testscommon/components/configs.go @@ -11,6 +11,7 @@ func GetGeneralConfig() config.Config { Length: 32, Type: "bech32", SignatureLength: 0, + Hrp: "erd", }, ValidatorPubkeyConverter: config.PubkeyConfig{ Length: 96, diff --git a/testscommon/generalConfig.go b/testscommon/generalConfig.go index e71b517837f..132effecc4e 100644 --- a/testscommon/generalConfig.go +++ b/testscommon/generalConfig.go @@ -36,6 +36,7 @@ func GetGeneralConfig() config.Config { Length: 32, Type: "bech32", SignatureLength: 0, + Hrp: "erd", }, ValidatorPubkeyConverter: config.PubkeyConfig{ Length: 96, diff --git a/testscommon/integrationtests/stringers.go b/testscommon/integrationtests/stringers.go index 3a0d31dc765..f3d26bf61c6 100644 --- a/testscommon/integrationtests/stringers.go +++ b/testscommon/integrationtests/stringers.go @@ -10,6 +10,7 @@ import ( "github.com/multiversx/mx-chain-core-go/core" "github.com/multiversx/mx-chain-core-go/data" "github.com/multiversx/mx-chain-core-go/data/smartContractResult" + logger "github.com/multiversx/mx-chain-logger-go" ) const asciiSpace = byte(' ') @@ -17,6 +18,8 @@ const asciiTab = byte('\t') const asciiLineFeed = byte('\r') const asciiNewLine = byte('\n') +var log = logger.GetOrCreate("stringers") + // TransactionHandlerToString will convert the transaction data slice provided to string func TransactionHandlerToString(pubKeyConverter core.PubkeyConverter, txHandlers ...data.TransactionHandler) string { builder := &strings.Builder{} @@ -90,7 +93,7 @@ func putAddressInBuilder(builder *strings.Builder, name string, indent string, p // can not encode with the provided address address = hex.EncodeToString(slice) + " (!)" } else { - address = pubKeyConverter.Encode(slice) + address = pubKeyConverter.SilentEncode(slice, log) } } diff --git a/testscommon/integrationtests/stringers_test.go b/testscommon/integrationtests/stringers_test.go index aa4f46986ba..6fc458cbbc0 100644 --- a/testscommon/integrationtests/stringers_test.go +++ b/testscommon/integrationtests/stringers_test.go @@ -6,17 +6,16 @@ import ( "math/big" "testing" - "github.com/multiversx/mx-chain-core-go/core/pubkeyConverter" "github.com/multiversx/mx-chain-core-go/data/smartContractResult" "github.com/multiversx/mx-chain-core-go/data/vm" - logger "github.com/multiversx/mx-chain-logger-go" + "github.com/multiversx/mx-chain-go/testscommon" "github.com/stretchr/testify/assert" ) const addressSize = 32 const hashSize = 32 -var pkConv, _ = pubkeyConverter.NewBech32PubkeyConverter(addressSize, logger.GetOrCreate("test")) +var pkConv = testscommon.RealWorldBech32PubkeyConverter func TestSmartContractResultsToString(t *testing.T) { t.Parallel() diff --git a/testscommon/pubkeyConverterMock.go b/testscommon/pubkeyConverterMock.go index dab0ed1b5bc..88e09085528 100644 --- a/testscommon/pubkeyConverterMock.go +++ b/testscommon/pubkeyConverterMock.go @@ -2,6 +2,8 @@ package testscommon import ( "encoding/hex" + + "github.com/multiversx/mx-chain-core-go/core" ) // PubkeyConverterMock - @@ -22,10 +24,26 @@ func (pcm *PubkeyConverterMock) Decode(humanReadable string) ([]byte, error) { } // Encode - -func (pcm *PubkeyConverterMock) Encode(pkBytes []byte) string { +func (pcm *PubkeyConverterMock) Encode(pkBytes []byte) (string, error) { + return hex.EncodeToString(pkBytes), nil +} + +// SilentEncode - +func (pcm *PubkeyConverterMock) SilentEncode(pkBytes []byte, log core.Logger) string { return hex.EncodeToString(pkBytes) } +// EncodeSlice - +func (pcm *PubkeyConverterMock) EncodeSlice(pkBytesSlice [][]byte) ([]string, error) { + encodedSlice := make([]string, 0) + + for _, pkBytes := range pkBytesSlice { + encodedSlice = append(encodedSlice, hex.EncodeToString(pkBytes)) + } + + return encodedSlice, nil +} + // Len - func (pcm *PubkeyConverterMock) Len() int { return pcm.len diff --git a/testscommon/pubkeyConverterStub.go b/testscommon/pubkeyConverterStub.go new file mode 100644 index 00000000000..cee0de968f7 --- /dev/null +++ b/testscommon/pubkeyConverterStub.go @@ -0,0 +1,62 @@ +package testscommon + +import "github.com/multiversx/mx-chain-core-go/core" + +// PubkeyConverterStub - +type PubkeyConverterStub struct { + LenCalled func() int + DecodeCalled func(humanReadable string) ([]byte, error) + EncodeCalled func(pkBytes []byte) (string, error) + SilentEncodeCalled func(pkBytes []byte, log core.Logger) string + EncodeSliceCalled func(pkBytesSlice [][]byte) ([]string, error) +} + +// Len - +func (pcs *PubkeyConverterStub) Len() int { + if pcs.LenCalled != nil { + return pcs.LenCalled() + } + + return 0 +} + +// Decode - +func (pcs *PubkeyConverterStub) Decode(humanReadable string) ([]byte, error) { + if pcs.DecodeCalled != nil { + return pcs.DecodeCalled(humanReadable) + } + + return make([]byte, 0), nil +} + +// Encode - +func (pcs *PubkeyConverterStub) Encode(pkBytes []byte) (string, error) { + if pcs.EncodeCalled != nil { + return pcs.EncodeCalled(pkBytes) + } + + return "", nil +} + +// EncodeSlice - +func (pcs *PubkeyConverterStub) EncodeSlice(pkBytesSlice [][]byte) ([]string, error) { + if pcs.EncodeSliceCalled != nil { + return pcs.EncodeSliceCalled(pkBytesSlice) + } + + return make([]string, 0), nil +} + +// SilentEncode - +func (pcs *PubkeyConverterStub) SilentEncode(pkBytes []byte, log core.Logger) string { + if pcs.SilentEncodeCalled != nil { + return pcs.SilentEncodeCalled(pkBytes, log) + } + + return "" +} + +// IsInterfaceNil - +func (pcs *PubkeyConverterStub) IsInterfaceNil() bool { + return pcs == nil +} diff --git a/update/genesis/export.go b/update/genesis/export.go index f885c9cf55c..115b6f92a91 100644 --- a/update/genesis/export.go +++ b/update/genesis/export.go @@ -442,9 +442,20 @@ func (se *stateExport) exportNodesSetupJson(validators map[uint32][]*state.Valid for _, validatorsInShard := range validators { for _, validator := range validatorsInShard { if shouldExportValidator(validator, acceptedListsForExport) { + + pubKey, err := se.validatorPubKeyConverter.Encode(validator.GetPublicKey()) + if err != nil { + return nil + } + + rewardAddress, err := se.addressPubKeyConverter.Encode(validator.GetRewardAddress()) + if err != nil { + return nil + } + initialNodes = append(initialNodes, &sharding.InitialNode{ - PubKey: se.validatorPubKeyConverter.Encode(validator.GetPublicKey()), - Address: se.addressPubKeyConverter.Encode(validator.GetRewardAddress()), + PubKey: pubKey, + Address: rewardAddress, InitialRating: validator.GetRating(), }) } diff --git a/update/genesis/export_test.go b/update/genesis/export_test.go index 44800205606..ec8fbca7a02 100644 --- a/update/genesis/export_test.go +++ b/update/genesis/export_test.go @@ -19,6 +19,7 @@ import ( "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/sharding" "github.com/multiversx/mx-chain-go/state" + "github.com/multiversx/mx-chain-go/testscommon" "github.com/multiversx/mx-chain-go/testscommon/hashingMocks" trieMock "github.com/multiversx/mx-chain-go/testscommon/trie" "github.com/multiversx/mx-chain-go/update" @@ -42,8 +43,8 @@ func TestNewStateExporter(t *testing.T) { Hasher: &mock.HasherStub{}, StateSyncer: &mock.StateSyncStub{}, HardforkStorer: &mock.HardforkStorerStub{}, - AddressPubKeyConverter: &mock.PubkeyConverterStub{}, - ValidatorPubKeyConverter: &mock.PubkeyConverterStub{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterStub{}, + ValidatorPubKeyConverter: &testscommon.PubkeyConverterStub{}, GenesisNodesSetupHandler: &mock.GenesisNodesSetupHandlerStub{}, ExportFolder: "test", }, @@ -57,8 +58,8 @@ func TestNewStateExporter(t *testing.T) { StateSyncer: nil, HardforkStorer: &mock.HardforkStorerStub{}, Hasher: &mock.HasherStub{}, - AddressPubKeyConverter: &mock.PubkeyConverterStub{}, - ValidatorPubKeyConverter: &mock.PubkeyConverterStub{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterStub{}, + ValidatorPubKeyConverter: &testscommon.PubkeyConverterStub{}, GenesisNodesSetupHandler: &mock.GenesisNodesSetupHandlerStub{}, ExportFolder: "test", }, @@ -72,8 +73,8 @@ func TestNewStateExporter(t *testing.T) { StateSyncer: &mock.StateSyncStub{}, HardforkStorer: &mock.HardforkStorerStub{}, Hasher: &mock.HasherStub{}, - AddressPubKeyConverter: &mock.PubkeyConverterStub{}, - ValidatorPubKeyConverter: &mock.PubkeyConverterStub{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterStub{}, + ValidatorPubKeyConverter: &testscommon.PubkeyConverterStub{}, GenesisNodesSetupHandler: &mock.GenesisNodesSetupHandlerStub{}, ExportFolder: "test", }, @@ -87,8 +88,8 @@ func TestNewStateExporter(t *testing.T) { StateSyncer: &mock.StateSyncStub{}, HardforkStorer: nil, Hasher: &mock.HasherStub{}, - AddressPubKeyConverter: &mock.PubkeyConverterStub{}, - ValidatorPubKeyConverter: &mock.PubkeyConverterStub{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterStub{}, + ValidatorPubKeyConverter: &testscommon.PubkeyConverterStub{}, GenesisNodesSetupHandler: &mock.GenesisNodesSetupHandlerStub{}, ExportFolder: "test", }, @@ -102,8 +103,8 @@ func TestNewStateExporter(t *testing.T) { StateSyncer: &mock.StateSyncStub{}, HardforkStorer: &mock.HardforkStorerStub{}, Hasher: nil, - AddressPubKeyConverter: &mock.PubkeyConverterStub{}, - ValidatorPubKeyConverter: &mock.PubkeyConverterStub{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterStub{}, + ValidatorPubKeyConverter: &testscommon.PubkeyConverterStub{}, GenesisNodesSetupHandler: &mock.GenesisNodesSetupHandlerStub{}, ExportFolder: "test", }, @@ -119,7 +120,7 @@ func TestNewStateExporter(t *testing.T) { HardforkStorer: &mock.HardforkStorerStub{}, Hasher: &mock.HasherStub{}, AddressPubKeyConverter: nil, - ValidatorPubKeyConverter: &mock.PubkeyConverterStub{}, + ValidatorPubKeyConverter: &testscommon.PubkeyConverterStub{}, GenesisNodesSetupHandler: &mock.GenesisNodesSetupHandlerStub{}, ExportFolder: "test", }, @@ -134,7 +135,7 @@ func TestNewStateExporter(t *testing.T) { StateSyncer: &mock.StateSyncStub{}, HardforkStorer: &mock.HardforkStorerStub{}, Hasher: &mock.HasherStub{}, - AddressPubKeyConverter: &mock.PubkeyConverterStub{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterStub{}, ValidatorPubKeyConverter: nil, GenesisNodesSetupHandler: &mock.GenesisNodesSetupHandlerStub{}, ExportFolder: "test", @@ -149,8 +150,8 @@ func TestNewStateExporter(t *testing.T) { StateSyncer: &mock.StateSyncStub{}, HardforkStorer: &mock.HardforkStorerStub{}, Hasher: &mock.HasherStub{}, - AddressPubKeyConverter: &mock.PubkeyConverterStub{}, - ValidatorPubKeyConverter: &mock.PubkeyConverterStub{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterStub{}, + ValidatorPubKeyConverter: &testscommon.PubkeyConverterStub{}, GenesisNodesSetupHandler: nil, ExportFolder: "test", }, @@ -164,8 +165,8 @@ func TestNewStateExporter(t *testing.T) { StateSyncer: &mock.StateSyncStub{}, HardforkStorer: &mock.HardforkStorerStub{}, Hasher: &mock.HasherStub{}, - AddressPubKeyConverter: &mock.PubkeyConverterStub{}, - ValidatorPubKeyConverter: &mock.PubkeyConverterStub{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterStub{}, + ValidatorPubKeyConverter: &testscommon.PubkeyConverterStub{}, GenesisNodesSetupHandler: &mock.GenesisNodesSetupHandlerStub{}, ExportFolder: "", }, @@ -179,8 +180,8 @@ func TestNewStateExporter(t *testing.T) { StateSyncer: &mock.StateSyncStub{}, HardforkStorer: &mock.HardforkStorerStub{}, Hasher: &mock.HasherStub{}, - AddressPubKeyConverter: &mock.PubkeyConverterStub{}, - ValidatorPubKeyConverter: &mock.PubkeyConverterStub{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterStub{}, + ValidatorPubKeyConverter: &testscommon.PubkeyConverterStub{}, ExportFolder: "test", GenesisNodesSetupHandler: &mock.GenesisNodesSetupHandlerStub{}, }, @@ -320,9 +321,9 @@ func TestStateExport_ExportTrieShouldExportNodesSetupJson(t *testing.T) { }, } - pubKeyConv := &mock.PubkeyConverterStub{ - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + pubKeyConv := &testscommon.PubkeyConverterStub{ + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, } @@ -372,9 +373,9 @@ func TestStateExport_ExportNodesSetupJsonShouldExportKeysInAlphabeticalOrder(t * }, } - pubKeyConv := &mock.PubkeyConverterStub{ - EncodeCalled: func(pkBytes []byte) string { - return string(pkBytes) + pubKeyConv := &testscommon.PubkeyConverterStub{ + EncodeCalled: func(pkBytes []byte) (string, error) { + return string(pkBytes), nil }, } @@ -567,8 +568,8 @@ func getDefaultStateExporterArgs() ArgsNewStateExporter { StateSyncer: &mock.StateSyncStub{}, HardforkStorer: &mock.HardforkStorerStub{}, Hasher: &hashingMocks.HasherMock{}, - AddressPubKeyConverter: &mock.PubkeyConverterStub{}, - ValidatorPubKeyConverter: &mock.PubkeyConverterStub{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterStub{}, + ValidatorPubKeyConverter: &testscommon.PubkeyConverterStub{}, ExportFolder: "test", GenesisNodesSetupHandler: &mock.GenesisNodesSetupHandlerStub{}, } diff --git a/update/mock/pubkeyConverterStub.go b/update/mock/pubkeyConverterStub.go deleted file mode 100644 index f8ef5507235..00000000000 --- a/update/mock/pubkeyConverterStub.go +++ /dev/null @@ -1,40 +0,0 @@ -package mock - -// PubkeyConverterStub - -type PubkeyConverterStub struct { - LenCalled func() int - DecodeCalled func(humanReadable string) ([]byte, error) - EncodeCalled func(pkBytes []byte) string -} - -// Len - -func (pcs *PubkeyConverterStub) Len() int { - if pcs.LenCalled != nil { - return pcs.LenCalled() - } - - return 0 -} - -// Decode - -func (pcs *PubkeyConverterStub) Decode(humanReadable string) ([]byte, error) { - if pcs.DecodeCalled != nil { - return pcs.DecodeCalled(humanReadable) - } - - return make([]byte, 0), nil -} - -// Encode - -func (pcs *PubkeyConverterStub) Encode(pkBytes []byte) string { - if pcs.EncodeCalled != nil { - return pcs.EncodeCalled(pkBytes) - } - - return "" -} - -// IsInterfaceNil - -func (pcs *PubkeyConverterStub) IsInterfaceNil() bool { - return pcs == nil -} diff --git a/update/process/processPending_test.go b/update/process/processPending_test.go index 0d2ce54a881..834b50fbfa0 100644 --- a/update/process/processPending_test.go +++ b/update/process/processPending_test.go @@ -21,7 +21,7 @@ func createMockArgsPendingTransactionProcessor() ArgsPendingTransactionProcessor TxProcessor: &testscommon.TxProcessorMock{}, RwdTxProcessor: &testscommon.RewardTxProcessorMock{}, ScrTxProcessor: &testscommon.SCProcessorMock{}, - PubKeyConv: &mock.PubkeyConverterStub{}, + PubKeyConv: &testscommon.PubkeyConverterStub{}, ShardCoordinator: mock.NewOneShardCoordinatorMock(), } } @@ -45,7 +45,7 @@ func TestPendingTransactionProcessor_ProcessTransactionsDstMe(t *testing.T) { addr4 := []byte("addr4") addr5 := []byte("addr5") args := createMockArgsPendingTransactionProcessor() - args.PubKeyConv = &mock.PubkeyConverterStub{} + args.PubKeyConv = &testscommon.PubkeyConverterStub{} shardCoordinator := mock.NewOneShardCoordinatorMock() shardCoordinator.ComputeIdCalled = func(address []byte) uint32 { diff --git a/vm/factory/systemSCFactory_test.go b/vm/factory/systemSCFactory_test.go index 321f2253c8b..921931f1b5d 100644 --- a/vm/factory/systemSCFactory_test.go +++ b/vm/factory/systemSCFactory_test.go @@ -67,7 +67,7 @@ func createMockNewSystemScFactoryArgs() ArgsNewSystemSCFactory { ConfigChangeAddress: "3132333435363738393031323334353637383930313233343536373839303234", }, }, - AddressPubKeyConverter: &mock.PubkeyConverterMock{}, + AddressPubKeyConverter: &testscommon.PubkeyConverterMock{}, ShardCoordinator: &mock.ShardCoordinatorStub{}, EnableEpochsHandler: &testscommon.EnableEpochsHandlerStub{}, } diff --git a/vm/mock/pubkeyConverterMock.go b/vm/mock/pubkeyConverterMock.go deleted file mode 100644 index 2495757f430..00000000000 --- a/vm/mock/pubkeyConverterMock.go +++ /dev/null @@ -1,37 +0,0 @@ -package mock - -import ( - "encoding/hex" -) - -// PubkeyConverterMock - -type PubkeyConverterMock struct { - len int -} - -// NewPubkeyConverterMock - -func NewPubkeyConverterMock(addressLen int) *PubkeyConverterMock { - return &PubkeyConverterMock{ - len: addressLen, - } -} - -// Decode - -func (pcm *PubkeyConverterMock) Decode(humanReadable string) ([]byte, error) { - return hex.DecodeString(humanReadable) -} - -// Encode - -func (pcm *PubkeyConverterMock) Encode(pkBytes []byte) string { - return hex.EncodeToString(pkBytes) -} - -// Len - -func (pcm *PubkeyConverterMock) Len() int { - return pcm.len -} - -// IsInterfaceNil - -func (pcm *PubkeyConverterMock) IsInterfaceNil() bool { - return pcm == nil -} diff --git a/vm/systemSmartContracts/esdt.go b/vm/systemSmartContracts/esdt.go index 89a8ad39772..7b48d2c6912 100644 --- a/vm/systemSmartContracts/esdt.go +++ b/vm/systemSmartContracts/esdt.go @@ -1309,8 +1309,11 @@ func (e *esdt) getSpecialRoles(args *vmcommon.ContractCallInput) vmcommon.Return for _, role := range specialRole.Roles { rolesAsString = append(rolesAsString, string(role)) } + + specialRoleAddress := e.addressPubKeyConverter.SilentEncode(specialRole.Address, log) + roles := strings.Join(rolesAsString, ",") - message := fmt.Sprintf("%s:%s", e.addressPubKeyConverter.Encode(specialRole.Address), roles) + message := fmt.Sprintf("%s:%s", specialRoleAddress, roles) e.eei.Finish([]byte(message)) } @@ -2212,7 +2215,7 @@ func (e *esdt) isAddressValid(addressBytes []byte) bool { return false } - encodedAddress := e.addressPubKeyConverter.Encode(addressBytes) + encodedAddress := e.addressPubKeyConverter.SilentEncode(addressBytes, log) return encodedAddress != "" } diff --git a/vm/systemSmartContracts/esdt_test.go b/vm/systemSmartContracts/esdt_test.go index 861fd7a695c..e21d1c6302b 100644 --- a/vm/systemSmartContracts/esdt_test.go +++ b/vm/systemSmartContracts/esdt_test.go @@ -11,8 +11,6 @@ import ( "testing" "github.com/multiversx/mx-chain-core-go/core" - coreMock "github.com/multiversx/mx-chain-core-go/core/mock" - "github.com/multiversx/mx-chain-core-go/core/pubkeyConverter" vmData "github.com/multiversx/mx-chain-core-go/data/vm" "github.com/multiversx/mx-chain-go/config" "github.com/multiversx/mx-chain-go/testscommon" @@ -34,7 +32,7 @@ func createMockArgumentsForESDT() ArgsNewESDTSmartContract { ESDTSCAddress: []byte("address"), Marshalizer: &mock.MarshalizerMock{}, Hasher: &hashingMocks.HasherMock{}, - AddressPubKeyConverter: mock.NewPubkeyConverterMock(32), + AddressPubKeyConverter: testscommon.NewPubkeyConverterMock(32), EndOfEpochSCAddress: vm.EndOfEpochAddress, EnableEpochsHandler: &testscommon.EnableEpochsHandlerStub{ IsESDTFlagEnabledField: true, @@ -1113,8 +1111,7 @@ func TestEsdt_ExecuteToggleFreezeShouldWorkWithRealBech32Address(t *testing.T) { args := createMockArgumentsForESDT() eei := createDefaultEei() - bech32C, _ := pubkeyConverter.NewBech32PubkeyConverter(32, &coreMock.LoggerMock{}) - args.AddressPubKeyConverter = bech32C + args.AddressPubKeyConverter = testscommon.RealWorldBech32PubkeyConverter tokensMap := map[string][]byte{} marshalizedData, _ := args.Marshalizer.Marshal(ESDTDataV2{ @@ -1127,7 +1124,7 @@ func TestEsdt_ExecuteToggleFreezeShouldWorkWithRealBech32Address(t *testing.T) { args.Eei = eei addressToFreezeBech32 := "erd158tgst07d6rt93td6nh5cd2mmpfhtp7hr24l4wfgtlggqpnp6kjsnpvdqj" - addressToFreeze, err := bech32C.Decode(addressToFreezeBech32) + addressToFreeze, err := args.AddressPubKeyConverter.Decode(addressToFreezeBech32) assert.NoError(t, err) e, _ := NewESDTSmartContract(args) @@ -1161,8 +1158,7 @@ func TestEsdt_ExecuteToggleFreezeShouldFailWithBech32Converter(t *testing.T) { args := createMockArgumentsForESDT() eei := createDefaultEei() - bech32C, _ := pubkeyConverter.NewBech32PubkeyConverter(32, &coreMock.LoggerMock{}) - args.AddressPubKeyConverter = bech32C + args.AddressPubKeyConverter = testscommon.RealWorldBech32PubkeyConverter tokensMap := map[string][]byte{} marshalizedData, _ := args.Marshalizer.Marshal(ESDTDataV2{ @@ -2488,13 +2484,11 @@ func TestEsdt_GetSpecialRolesShouldWork(t *testing.T) { eei := createDefaultEei() args.Eei = eei - bech32C, _ := pubkeyConverter.NewBech32PubkeyConverter(32, &coreMock.LoggerMock{}) - addr1 := "erd1kzzv2uw97q5k9mt458qk3q9u3cwhwqykvyk598q2f6wwx7gvrd9s8kszxk" - addr1Bytes, _ := bech32C.Decode(addr1) + addr1Bytes, _ := testscommon.RealWorldBech32PubkeyConverter.Decode(addr1) addr2 := "erd1e7n8rzxdtl2n2fl6mrsg4l7stp2elxhfy6l9p7eeafspjhhrjq7qk05usw" - addr2Bytes, _ := bech32C.Decode(addr2) + addr2Bytes, _ := testscommon.RealWorldBech32PubkeyConverter.Decode(addr2) specialRoles := []*ESDTRoles{ { @@ -2521,7 +2515,7 @@ func TestEsdt_GetSpecialRolesShouldWork(t *testing.T) { eei.storageUpdate[string(eei.scAddress)] = tokensMap args.Eei = eei - args.AddressPubKeyConverter = bech32C + args.AddressPubKeyConverter = testscommon.RealWorldBech32PubkeyConverter e, _ := NewESDTSmartContract(args) @@ -2543,16 +2537,14 @@ func TestEsdt_UnsetSpecialRoleWithRemoveEntryFromSpecialRoles(t *testing.T) { eei := createDefaultEei() args.Eei = eei - bech32C, _ := pubkeyConverter.NewBech32PubkeyConverter(32, &coreMock.LoggerMock{}) - owner := "erd1e7n8rzxdtl2n2fl6mrsg4l7stp2elxhfy6l9p7eeafspjhhrjq7qk05usw" - ownerBytes, _ := bech32C.Decode(owner) + ownerBytes, _ := testscommon.RealWorldBech32PubkeyConverter.Decode(owner) addr1 := "erd1kzzv2uw97q5k9mt458qk3q9u3cwhwqykvyk598q2f6wwx7gvrd9s8kszxk" - addr1Bytes, _ := bech32C.Decode(addr1) + addr1Bytes, _ := testscommon.RealWorldBech32PubkeyConverter.Decode(addr1) addr2 := "erd1rsq30t33aqeg8cuc3q4kfnx0jukzsx52yfua92r233zhhmndl3uszcs5qj" - addr2Bytes, _ := bech32C.Decode(addr2) + addr2Bytes, _ := testscommon.RealWorldBech32PubkeyConverter.Decode(addr2) specialRoles := []*ESDTRoles{ { @@ -2580,7 +2572,7 @@ func TestEsdt_UnsetSpecialRoleWithRemoveEntryFromSpecialRoles(t *testing.T) { eei.storageUpdate[string(eei.scAddress)] = tokensMap args.Eei = eei - args.AddressPubKeyConverter = bech32C + args.AddressPubKeyConverter = testscommon.RealWorldBech32PubkeyConverter e, _ := NewESDTSmartContract(args)