From 88f2fb20745d40cc178c23a4422d9df0bec2f706 Mon Sep 17 00:00:00 2001 From: BeniaminDrasovean Date: Wed, 31 Jan 2024 16:09:44 +0200 Subject: [PATCH] add integration tests --- integrationTests/vm/txsFee/common.go | 157 ++++++++++++++++++ .../vm/txsFee/esdtMetaDataRecreate_test.go | 99 +++++++++++ .../vm/txsFee/esdtMetaDataUpdate_test.go | 100 +++++++++++ .../vm/txsFee/esdtModifyCreator_test.go | 97 +++++++++++ .../vm/txsFee/esdtModifyRoyalties_test.go | 92 ++++++++++ .../vm/txsFee/esdtSetNewURIs_test.go | 95 +++++++++++ .../vm/txsFee/moveBalance_test.go | 2 - 7 files changed, 640 insertions(+), 2 deletions(-) create mode 100644 integrationTests/vm/txsFee/esdtMetaDataRecreate_test.go create mode 100644 integrationTests/vm/txsFee/esdtMetaDataUpdate_test.go create mode 100644 integrationTests/vm/txsFee/esdtModifyCreator_test.go create mode 100644 integrationTests/vm/txsFee/esdtModifyRoyalties_test.go create mode 100644 integrationTests/vm/txsFee/esdtSetNewURIs_test.go diff --git a/integrationTests/vm/txsFee/common.go b/integrationTests/vm/txsFee/common.go index 02e69b5260d..5e5fab10e1c 100644 --- a/integrationTests/vm/txsFee/common.go +++ b/integrationTests/vm/txsFee/common.go @@ -1,14 +1,153 @@ package txsFee import ( + "bytes" + "encoding/hex" + "math/big" "testing" + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-core-go/data/esdt" + "github.com/multiversx/mx-chain-core-go/data/transaction" "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/integrationTests/vm" "github.com/multiversx/mx-chain-go/state" "github.com/stretchr/testify/require" ) +const gasPrice = uint64(10) + +type metaData struct { + tokenId []byte + nonce []byte + name []byte + royalties []byte + hash []byte + attributes []byte + uris [][]byte +} + +func getDefaultMetaData() *metaData { + return &metaData{ + tokenId: []byte(hex.EncodeToString([]byte("tokenId"))), + nonce: []byte(hex.EncodeToString(big.NewInt(0).Bytes())), + name: []byte(hex.EncodeToString([]byte("name"))), + royalties: []byte(hex.EncodeToString(big.NewInt(10).Bytes())), + hash: []byte(hex.EncodeToString([]byte("hash"))), + attributes: []byte(hex.EncodeToString([]byte("attributes"))), + uris: [][]byte{[]byte(hex.EncodeToString([]byte("uri1"))), []byte(hex.EncodeToString([]byte("uri2"))), []byte(hex.EncodeToString([]byte("uri3")))}, + } +} + +func getMetaDataFromAcc(t *testing.T, testContext *vm.VMTestContext, accWithMetaData []byte, token []byte) *esdt.MetaData { + account, err := testContext.Accounts.LoadAccount(accWithMetaData) + require.Nil(t, err) + userAccount, ok := account.(state.UserAccountHandler) + require.True(t, ok) + + key := append(token, big.NewInt(0).SetUint64(1).Bytes()...) + esdtDataBytes, _, err := userAccount.RetrieveValue(key) + require.Nil(t, err) + esdtData := &esdt.ESDigitalToken{} + err = testContext.Marshalizer.Unmarshal(esdtData, esdtDataBytes) + require.Nil(t, err) + + return esdtData.TokenMetaData +} + +func checkMetaData(t *testing.T, testContext *vm.VMTestContext, accWithMetaData []byte, token []byte, expectedMetaData *metaData) { + retrievedMetaData := getMetaDataFromAcc(t, testContext, accWithMetaData, token) + + require.Equal(t, expectedMetaData.nonce, []byte(hex.EncodeToString(big.NewInt(int64(retrievedMetaData.Nonce)).Bytes()))) + require.Equal(t, expectedMetaData.name, []byte(hex.EncodeToString(retrievedMetaData.Name))) + require.Equal(t, expectedMetaData.royalties, []byte(hex.EncodeToString(big.NewInt(int64(retrievedMetaData.Royalties)).Bytes()))) + require.Equal(t, expectedMetaData.hash, []byte(hex.EncodeToString(retrievedMetaData.Hash))) + for i, uri := range expectedMetaData.uris { + require.Equal(t, uri, []byte(hex.EncodeToString(retrievedMetaData.URIs[i]))) + } + require.Equal(t, expectedMetaData.attributes, []byte(hex.EncodeToString(retrievedMetaData.Attributes))) +} + +func getDynamicTokenTypes() []string { + return []string{ + core.DynamicNFTESDT, + core.DynamicSFTESDT, + core.DynamicMetaESDT, + } +} + +func getTokenTypes() []string { + return []string{ + core.FungibleESDT, + core.NonFungibleESDT, + core.NonFungibleESDTv2, + core.MetaESDT, + core.SemiFungibleESDT, + core.DynamicNFTESDT, + core.DynamicSFTESDT, + core.DynamicMetaESDT, + } +} + +func createTokenTx( + sndAddr []byte, + rcvAddr []byte, + gasLimit uint64, + quantity int64, + metaData *metaData, +) *transaction.Transaction { + txDataField := bytes.Join( + [][]byte{ + []byte(core.BuiltInFunctionESDTNFTCreate), + metaData.tokenId, + []byte(hex.EncodeToString(big.NewInt(quantity).Bytes())), // quantity + metaData.name, + metaData.royalties, + metaData.hash, + metaData.attributes, + []byte(hex.EncodeToString([]byte("uri"))), + }, + []byte("@"), + ) + + return &transaction.Transaction{ + Nonce: 0, + SndAddr: sndAddr, + RcvAddr: rcvAddr, + GasLimit: gasLimit, + GasPrice: gasPrice, + Data: txDataField, + Value: big.NewInt(0), + } +} + +func setTokenTypeTx( + sndAddr []byte, + gasLimit uint64, + tokenId []byte, + tokenType string, +) *transaction.Transaction { + txDataField := bytes.Join( + [][]byte{ + []byte(core.ESDTSetTokenType), + []byte(hex.EncodeToString(tokenId)), + []byte(hex.EncodeToString([]byte(tokenType))), + }, + []byte("@"), + ) + + return &transaction.Transaction{ + Nonce: 0, + SndAddr: sndAddr, + RcvAddr: core.SystemAccountAddress, + GasLimit: gasLimit, + GasPrice: gasPrice, + + Data: txDataField, + Value: big.NewInt(0), + } +} + func getAccount(tb testing.TB, testContext *vm.VMTestContext, scAddress []byte) state.UserAccountHandler { scAcc, err := testContext.Accounts.LoadAccount(scAddress) require.Nil(tb, err) @@ -25,3 +164,21 @@ func getAccountDataTrie(tb testing.TB, testContext *vm.VMTestContext, address [] return dataTrieInstance } + +func createAccWithBalance(t *testing.T, accnts state.AccountsAdapter, pubKey []byte, egldValue *big.Int) { + account, err := accnts.LoadAccount(pubKey) + require.Nil(t, err) + + userAccount, ok := account.(state.UserAccountHandler) + require.True(t, ok) + + userAccount.IncreaseNonce(0) + err = userAccount.AddToBalance(egldValue) + require.Nil(t, err) + + err = accnts.SaveAccount(userAccount) + require.Nil(t, err) + + _, err = accnts.Commit() + require.Nil(t, err) +} diff --git a/integrationTests/vm/txsFee/esdtMetaDataRecreate_test.go b/integrationTests/vm/txsFee/esdtMetaDataRecreate_test.go new file mode 100644 index 00000000000..ac0a7902f14 --- /dev/null +++ b/integrationTests/vm/txsFee/esdtMetaDataRecreate_test.go @@ -0,0 +1,99 @@ +package txsFee + +import ( + "bytes" + "encoding/hex" + "math/big" + "testing" + + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-core-go/data/transaction" + "github.com/multiversx/mx-chain-go/config" + "github.com/multiversx/mx-chain-go/integrationTests/vm" + "github.com/multiversx/mx-chain-go/integrationTests/vm/txsFee/utils" + vmcommon "github.com/multiversx/mx-chain-vm-common-go" + "github.com/stretchr/testify/require" +) + +func TestESDTMetaDataRecreate(t *testing.T) { + tokenTypes := getDynamicTokenTypes() + for _, tokenType := range tokenTypes { + testName := "metaDataRecreate for " + tokenType + t.Run(testName, func(t *testing.T) { + runEsdtMetaDataRecreateTest(t, tokenType) + }) + } +} + +func runEsdtMetaDataRecreateTest(t *testing.T, tokenType string) { + sndAddr := []byte("12345678901234567890123456789012") + token := []byte("tokenId") + roles := [][]byte{[]byte(core.ESDTMetaDataRecreate), []byte(core.ESDTRoleNFTCreate)} + baseEsdtKeyPrefix := core.ProtectedKeyPrefix + core.ESDTKeyIdentifier + key := append([]byte(baseEsdtKeyPrefix), token...) + + testContext, err := vm.CreatePreparedTxProcessorWithVMs(config.EnableEpochs{}) + require.Nil(t, err) + defer testContext.Close() + + createAccWithBalance(t, testContext.Accounts, sndAddr, big.NewInt(100000000)) + createAccWithBalance(t, testContext.Accounts, core.ESDTSCAddress, big.NewInt(100000000)) + utils.SetESDTRoles(t, testContext.Accounts, sndAddr, token, roles) + + tx := setTokenTypeTx(core.ESDTSCAddress, 100000, token, tokenType) + retCode, err := testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + defaultMetaData := getDefaultMetaData() + tx = createTokenTx(sndAddr, sndAddr, 100000, 1, defaultMetaData) + retCode, err = testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + // TODO change default metadata + defaultMetaData.nonce = []byte(hex.EncodeToString(big.NewInt(1).Bytes())) + tx = esdtMetaDataRecreateTx(sndAddr, sndAddr, 100000, defaultMetaData) + retCode, err = testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + _, err = testContext.Accounts.Commit() + require.Nil(t, err) + + checkMetaData(t, testContext, core.SystemAccountAddress, key, defaultMetaData) +} + +func esdtMetaDataRecreateTx( + sndAddr []byte, + rcvAddr []byte, + gasLimit uint64, + metaData *metaData, +) *transaction.Transaction { + txDataField := bytes.Join( + [][]byte{ + []byte(core.ESDTMetaDataRecreate), + metaData.tokenId, + metaData.nonce, + metaData.name, + metaData.royalties, + metaData.hash, + metaData.attributes, + metaData.uris[0], + metaData.uris[1], + metaData.uris[2], + }, + []byte("@"), + ) + + return &transaction.Transaction{ + Nonce: 1, + SndAddr: sndAddr, + RcvAddr: rcvAddr, + GasLimit: gasLimit, + GasPrice: gasPrice, + + Data: txDataField, + Value: big.NewInt(0), + } +} diff --git a/integrationTests/vm/txsFee/esdtMetaDataUpdate_test.go b/integrationTests/vm/txsFee/esdtMetaDataUpdate_test.go new file mode 100644 index 00000000000..33aece1aacc --- /dev/null +++ b/integrationTests/vm/txsFee/esdtMetaDataUpdate_test.go @@ -0,0 +1,100 @@ +package txsFee + +import ( + "bytes" + "encoding/hex" + "math/big" + "testing" + + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-core-go/data/transaction" + "github.com/multiversx/mx-chain-go/config" + "github.com/multiversx/mx-chain-go/integrationTests/vm" + "github.com/multiversx/mx-chain-go/integrationTests/vm/txsFee/utils" + vmcommon "github.com/multiversx/mx-chain-vm-common-go" + "github.com/stretchr/testify/require" +) + +func TestESDTMetaDataUpdate(t *testing.T) { + tokenTypes := getDynamicTokenTypes() + for _, tokenType := range tokenTypes { + testName := "metaDataUpdate for " + tokenType + t.Run(testName, func(t *testing.T) { + runEsdtMetaDataUpdateTest(t, tokenType) + }) + } +} + +func runEsdtMetaDataUpdateTest(t *testing.T, tokenType string) { + sndAddr := []byte("12345678901234567890123456789012") + token := []byte("tokenId") + roles := [][]byte{[]byte(core.ESDTRoleNFTUpdate), []byte(core.ESDTRoleNFTCreate)} + baseEsdtKeyPrefix := core.ProtectedKeyPrefix + core.ESDTKeyIdentifier + key := append([]byte(baseEsdtKeyPrefix), token...) + + testContext, err := vm.CreatePreparedTxProcessorWithVMs(config.EnableEpochs{}) + require.Nil(t, err) + defer testContext.Close() + + createAccWithBalance(t, testContext.Accounts, sndAddr, big.NewInt(100000000)) + createAccWithBalance(t, testContext.Accounts, core.ESDTSCAddress, big.NewInt(100000000)) + utils.SetESDTRoles(t, testContext.Accounts, sndAddr, token, roles) + + tx := setTokenTypeTx(core.ESDTSCAddress, 100000, token, tokenType) + retCode, err := testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + defaultMetaData := getDefaultMetaData() + tx = createTokenTx(sndAddr, sndAddr, 100000, 1, defaultMetaData) + retCode, err = testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + // TODO change default metadata + defaultMetaData.nonce = []byte(hex.EncodeToString(big.NewInt(1).Bytes())) + defaultMetaData.name = []byte(hex.EncodeToString([]byte("newName"))) + defaultMetaData.hash = []byte(hex.EncodeToString([]byte("newHash"))) + defaultMetaData.uris = [][]byte{defaultMetaData.uris[1]} + tx = esdtMetaDataUpdateTx(sndAddr, sndAddr, 100000, defaultMetaData) + retCode, err = testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + _, err = testContext.Accounts.Commit() + require.Nil(t, err) + + checkMetaData(t, testContext, core.SystemAccountAddress, key, defaultMetaData) +} + +func esdtMetaDataUpdateTx( + sndAddr []byte, + rcvAddr []byte, + gasLimit uint64, + metaData *metaData, +) *transaction.Transaction { + txDataField := bytes.Join( + [][]byte{ + []byte(core.ESDTMetaDataUpdate), + metaData.tokenId, + metaData.nonce, + metaData.name, + metaData.royalties, + metaData.hash, + metaData.attributes, + metaData.uris[0], + }, + []byte("@"), + ) + + return &transaction.Transaction{ + Nonce: 1, + SndAddr: sndAddr, + RcvAddr: rcvAddr, + GasLimit: gasLimit, + GasPrice: gasPrice, + + Data: txDataField, + Value: big.NewInt(0), + } +} diff --git a/integrationTests/vm/txsFee/esdtModifyCreator_test.go b/integrationTests/vm/txsFee/esdtModifyCreator_test.go new file mode 100644 index 00000000000..f800268602b --- /dev/null +++ b/integrationTests/vm/txsFee/esdtModifyCreator_test.go @@ -0,0 +1,97 @@ +package txsFee + +import ( + "bytes" + "encoding/hex" + "math/big" + "testing" + + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-core-go/data/transaction" + "github.com/multiversx/mx-chain-go/config" + "github.com/multiversx/mx-chain-go/integrationTests/vm" + "github.com/multiversx/mx-chain-go/integrationTests/vm/txsFee/utils" + vmcommon "github.com/multiversx/mx-chain-vm-common-go" + "github.com/stretchr/testify/require" +) + +func TestESDTModifyCreator(t *testing.T) { + tokenTypes := getDynamicTokenTypes() + for _, tokenType := range tokenTypes { + esdtType, _ := core.ConvertESDTTypeToUint32(tokenType) + if !core.IsDynamicESDT(esdtType) { + continue + } + testName := "esdtModifyCreator for " + tokenType + t.Run(testName, func(t *testing.T) { + runEsdtModifyCreatorTest(t, tokenType) + }) + } +} + +func runEsdtModifyCreatorTest(t *testing.T, tokenType string) { + newCreator := []byte("12345678901234567890123456789012") + creatorAddr := []byte("12345678901234567890123456789013") + token := []byte("tokenId") + baseEsdtKeyPrefix := core.ProtectedKeyPrefix + core.ESDTKeyIdentifier + key := append([]byte(baseEsdtKeyPrefix), token...) + + testContext, err := vm.CreatePreparedTxProcessorWithVMs(config.EnableEpochs{}) + require.Nil(t, err) + defer testContext.Close() + + createAccWithBalance(t, testContext.Accounts, newCreator, big.NewInt(100000000)) + createAccWithBalance(t, testContext.Accounts, creatorAddr, big.NewInt(100000000)) + createAccWithBalance(t, testContext.Accounts, core.ESDTSCAddress, big.NewInt(100000000)) + utils.SetESDTRoles(t, testContext.Accounts, creatorAddr, token, [][]byte{[]byte(core.ESDTRoleNFTCreate)}) + utils.SetESDTRoles(t, testContext.Accounts, newCreator, token, [][]byte{[]byte(core.ESDTRoleModifyCreator)}) + + tx := setTokenTypeTx(core.ESDTSCAddress, 100000, token, tokenType) + retCode, err := testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + defaultMetaData := getDefaultMetaData() + defaultMetaData.nonce = []byte(hex.EncodeToString(big.NewInt(1).Bytes())) + tx = createTokenTx(creatorAddr, creatorAddr, 100000, 1, defaultMetaData) + retCode, err = testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + tx = esdtModifyCreatorTx(newCreator, newCreator, 100000, defaultMetaData) + retCode, err = testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + _, err = testContext.Accounts.Commit() + require.Nil(t, err) + + retrievedMetaData := getMetaDataFromAcc(t, testContext, core.SystemAccountAddress, key) + require.Equal(t, newCreator, retrievedMetaData.Creator) +} + +func esdtModifyCreatorTx( + sndAddr []byte, + rcvAddr []byte, + gasLimit uint64, + metaData *metaData, +) *transaction.Transaction { + txDataField := bytes.Join( + [][]byte{ + []byte(core.ESDTModifyCreator), + metaData.tokenId, + metaData.nonce, + }, + []byte("@"), + ) + return &transaction.Transaction{ + Nonce: 0, + SndAddr: sndAddr, + RcvAddr: rcvAddr, + GasLimit: gasLimit, + GasPrice: gasPrice, + + Data: txDataField, + Value: big.NewInt(0), + } +} diff --git a/integrationTests/vm/txsFee/esdtModifyRoyalties_test.go b/integrationTests/vm/txsFee/esdtModifyRoyalties_test.go new file mode 100644 index 00000000000..aa13bdf3ef6 --- /dev/null +++ b/integrationTests/vm/txsFee/esdtModifyRoyalties_test.go @@ -0,0 +1,92 @@ +package txsFee + +import ( + "bytes" + "encoding/hex" + "math/big" + "testing" + + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-core-go/data/transaction" + "github.com/multiversx/mx-chain-go/config" + "github.com/multiversx/mx-chain-go/integrationTests/vm" + "github.com/multiversx/mx-chain-go/integrationTests/vm/txsFee/utils" + vmcommon "github.com/multiversx/mx-chain-vm-common-go" + "github.com/stretchr/testify/require" +) + +func TestESDTModifyRoyalties(t *testing.T) { + tokenTypes := getDynamicTokenTypes() + for _, tokenType := range tokenTypes { + testName := "esdtModifyRoyalties for " + tokenType + t.Run(testName, func(t *testing.T) { + runEsdtModifyRoyaltiesTest(t, tokenType) + }) + } +} + +func runEsdtModifyRoyaltiesTest(t *testing.T, tokenType string) { + creatorAddr := []byte("12345678901234567890123456789013") + token := []byte("tokenId") + baseEsdtKeyPrefix := core.ProtectedKeyPrefix + core.ESDTKeyIdentifier + key := append([]byte(baseEsdtKeyPrefix), token...) + + testContext, err := vm.CreatePreparedTxProcessorWithVMs(config.EnableEpochs{}) + require.Nil(t, err) + defer testContext.Close() + + createAccWithBalance(t, testContext.Accounts, creatorAddr, big.NewInt(100000000)) + createAccWithBalance(t, testContext.Accounts, core.ESDTSCAddress, big.NewInt(100000000)) + utils.SetESDTRoles(t, testContext.Accounts, creatorAddr, token, [][]byte{[]byte(core.ESDTRoleModifyRoyalties), []byte(core.ESDTRoleNFTCreate)}) + + tx := setTokenTypeTx(core.ESDTSCAddress, 100000, token, tokenType) + retCode, err := testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + defaultMetaData := getDefaultMetaData() + tx = createTokenTx(creatorAddr, creatorAddr, 100000, 1, defaultMetaData) + retCode, err = testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + defaultMetaData.nonce = []byte(hex.EncodeToString(big.NewInt(1).Bytes())) + defaultMetaData.royalties = []byte(hex.EncodeToString(big.NewInt(20).Bytes())) + tx = esdtModifyRoyaltiesTx(creatorAddr, creatorAddr, 100000, defaultMetaData) + retCode, err = testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + _, err = testContext.Accounts.Commit() + require.Nil(t, err) + + retrievedMetaData := getMetaDataFromAcc(t, testContext, core.SystemAccountAddress, key) + require.Equal(t, uint32(big.NewInt(20).Uint64()), retrievedMetaData.Royalties) +} + +func esdtModifyRoyaltiesTx( + sndAddr []byte, + rcvAddr []byte, + gasLimit uint64, + metaData *metaData, +) *transaction.Transaction { + txDataField := bytes.Join( + [][]byte{ + []byte(core.ESDTModifyRoyalties), + metaData.tokenId, + metaData.nonce, + metaData.royalties, + }, + []byte("@"), + ) + return &transaction.Transaction{ + Nonce: 1, + SndAddr: sndAddr, + RcvAddr: rcvAddr, + GasLimit: gasLimit, + GasPrice: gasPrice, + + Data: txDataField, + Value: big.NewInt(0), + } +} diff --git a/integrationTests/vm/txsFee/esdtSetNewURIs_test.go b/integrationTests/vm/txsFee/esdtSetNewURIs_test.go new file mode 100644 index 00000000000..d7b89d5445b --- /dev/null +++ b/integrationTests/vm/txsFee/esdtSetNewURIs_test.go @@ -0,0 +1,95 @@ +package txsFee + +import ( + "bytes" + "encoding/hex" + "math/big" + "testing" + + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-core-go/data/transaction" + "github.com/multiversx/mx-chain-go/config" + "github.com/multiversx/mx-chain-go/integrationTests/vm" + "github.com/multiversx/mx-chain-go/integrationTests/vm/txsFee/utils" + vmcommon "github.com/multiversx/mx-chain-vm-common-go" + "github.com/stretchr/testify/require" +) + +func TestESDTSetNewURIs(t *testing.T) { + tokenTypes := getDynamicTokenTypes() + for _, tokenType := range tokenTypes { + testName := "ESDTsetNewURIs for " + tokenType + t.Run(testName, func(t *testing.T) { + runEsdtSetNewURIsTest(t, tokenType) + }) + } +} + +func runEsdtSetNewURIsTest(t *testing.T, tokenType string) { + sndAddr := []byte("12345678901234567890123456789012") + token := []byte("tokenId") + roles := [][]byte{[]byte(core.ESDTRoleSetNewURI), []byte(core.ESDTRoleNFTCreate)} + baseEsdtKeyPrefix := core.ProtectedKeyPrefix + core.ESDTKeyIdentifier + key := append([]byte(baseEsdtKeyPrefix), token...) + + testContext, err := vm.CreatePreparedTxProcessorWithVMs(config.EnableEpochs{}) + require.Nil(t, err) + defer testContext.Close() + + createAccWithBalance(t, testContext.Accounts, sndAddr, big.NewInt(100000000)) + createAccWithBalance(t, testContext.Accounts, core.ESDTSCAddress, big.NewInt(100000000)) + utils.SetESDTRoles(t, testContext.Accounts, sndAddr, token, roles) + + tx := setTokenTypeTx(core.ESDTSCAddress, 100000, token, tokenType) + retCode, err := testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + defaultMetaData := getDefaultMetaData() + tx = createTokenTx(sndAddr, sndAddr, 100000, 1, defaultMetaData) + retCode, err = testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + defaultMetaData.uris = [][]byte{[]byte(hex.EncodeToString([]byte("newUri1"))), []byte(hex.EncodeToString([]byte("newUri2")))} + defaultMetaData.nonce = []byte(hex.EncodeToString(big.NewInt(1).Bytes())) + tx = esdtSetNewUrisTx(sndAddr, sndAddr, 100000, defaultMetaData) + retCode, err = testContext.TxProcessor.ProcessTransaction(tx) + require.Equal(t, vmcommon.Ok, retCode) + require.Nil(t, err) + + _, err = testContext.Accounts.Commit() + require.Nil(t, err) + + retrievedMetaData := getMetaDataFromAcc(t, testContext, core.SystemAccountAddress, key) + require.Equal(t, [][]byte{[]byte("newUri1"), []byte("newUri2")}, retrievedMetaData.URIs) +} + +func esdtSetNewUrisTx( + sndAddr []byte, + rcvAddr []byte, + gasLimit uint64, + metaData *metaData, +) *transaction.Transaction { + txDataField := bytes.Join( + [][]byte{ + []byte(core.ESDTSetNewURIs), + metaData.tokenId, + metaData.nonce, + metaData.uris[0], + metaData.uris[1], + }, + []byte("@"), + ) + + return &transaction.Transaction{ + Nonce: 1, + SndAddr: sndAddr, + RcvAddr: rcvAddr, + GasLimit: gasLimit, + GasPrice: gasPrice, + + Data: txDataField, + Value: big.NewInt(0), + } +} diff --git a/integrationTests/vm/txsFee/moveBalance_test.go b/integrationTests/vm/txsFee/moveBalance_test.go index 78646813825..8a119084cff 100644 --- a/integrationTests/vm/txsFee/moveBalance_test.go +++ b/integrationTests/vm/txsFee/moveBalance_test.go @@ -16,8 +16,6 @@ import ( "github.com/stretchr/testify/require" ) -const gasPrice = uint64(10) - // minGasPrice = 1, gasPerDataByte = 1, minGasLimit = 1 func TestMoveBalanceSelfShouldWorkAndConsumeTxFee(t *testing.T) { testContext, err := vm.CreatePreparedTxProcessorWithVMs(config.EnableEpochs{})