Repository: oceanprotocol/ocean.py (language: python)

Issue:
Discussion: possible renaming of ERC20Token, ERC721NFT, more
I refactored all the uses of `ERC20Token(web3, get_address_of_type(config, "Ocean"))` to instead use `ocean.OCEAN_token` or a new `OCEAN_token` fixture I added.

I did not rename `ERC20Token`, `ERC721NFT`, or `BTokenBase`.  I'll leave these possible refactors for a future issue.

_Originally posted by @DMats in https://github.com/oceanprotocol/ocean.py/pull/763#discussion_r878443229_


Discussion / hints:
Currently we have two classes `ERC20Token` and `ERC721NFT`.  Both contain methods that are outside the basic ERC20 and ERC721 specs. I propose we rename them to `Datatoken` and `DataNFT`.

I think the new name better describes what the classes are, and it's closer to what ocean.js uses `Datatoken` and `NFT`.

Fix patch:
diff --git a/READMEs/c2d-flow.md b/READMEs/c2d-flow.md
index 79e0380c2..193cbf26b 100644
--- a/READMEs/c2d-flow.md
+++ b/READMEs/c2d-flow.md
@@ -57,7 +57,7 @@ In the same python console:
 
 ```python
 # Publish the datatoken
-DATA_datatoken = erc721_nft.create_datatoken("DATA 1", "D1", from_wallet=alice_wallet)
+DATA_datatoken = data_nft.create_datatoken("DATA 1", "D1", from_wallet=alice_wallet)
 print(f"DATA_datatoken address = '{DATA_datatoken.address}'")
 
 # Specify metadata and services, using the Branin test dataset
@@ -107,8 +107,8 @@ DATA_asset = ocean.assets.create(
     publisher_wallet=alice_wallet,
     encrypted_files=DATA_encrypted_files,
     services=[DATA_compute_service],
-    erc721_address=erc721_nft.address,
-    deployed_erc20_tokens=[DATA_datatoken],
+    erc721_address=data_nft.address,
+    deployed_datatokens=[DATA_datatoken],
 )
 
 print(f"DATA_asset did = '{DATA_asset.did}'")
@@ -120,7 +120,7 @@ In the same Python console:
 
 ```python
 # Publish the algorithm NFT token
-ALGO_nft_token = ocean.create_erc721_nft("NFTToken1", "NFT1", alice_wallet)
+ALGO_nft_token = ocean.create_data_nft("NFTToken1", "NFT1", alice_wallet)
 print(f"ALGO_nft_token address = '{ALGO_nft_token.address}'")
 
 # Publish the datatoken
@@ -167,7 +167,7 @@ ALGO_asset = ocean.assets.create(
     publisher_wallet=alice_wallet,
     encrypted_files=ALGO_encrypted_files,
     erc721_address=ALGO_nft_token.address,
-    deployed_erc20_tokens=[ALGO_datatoken],
+    deployed_datatokens=[ALGO_datatoken],
 )
 
 print(f"ALGO_asset did = '{ALGO_asset.did}'")
diff --git a/READMEs/consume-flow.md b/READMEs/consume-flow.md
index db39596b2..c1d6d6113 100644
--- a/READMEs/consume-flow.md
+++ b/READMEs/consume-flow.md
@@ -61,8 +61,8 @@ OCEAN_token = ocean.OCEAN_token
 assert OCEAN_token.balanceOf(bob_wallet.address) > 0, "need ganache OCEAN"
 
 # Mint 1 ERC20 token in consumer wallet from publisher
-erc20_token = ocean.get_datatoken(asset.datatokens[0]["address"])
-erc20_token.mint(
+datatoken = ocean.get_datatoken(asset.datatokens[0]["address"])
+datatoken.mint(
     account_address=bob_wallet.address,
     value=ocean.to_wei("1"),
     from_wallet=alice_wallet,
@@ -78,7 +78,7 @@ order_tx_id = ocean.assets.pay_for_access_service(
     asset,
     service,
     consume_market_order_fee_address=bob_wallet.address,
-    consume_market_order_fee_token=erc20_token.address,
+    consume_market_order_fee_token=datatoken.address,
     consume_market_order_fee_amount=0,
     wallet=bob_wallet,
 )
diff --git a/READMEs/data-nfts-and-datatokens-flow.md b/READMEs/data-nfts-and-datatokens-flow.md
index d0d78d9c1..f1ad88b2e 100644
--- a/READMEs/data-nfts-and-datatokens-flow.md
+++ b/READMEs/data-nfts-and-datatokens-flow.md
@@ -98,8 +98,8 @@ alice_private_key = os.getenv('TEST_PRIVATE_KEY1')
 alice_wallet = Wallet(ocean.web3, alice_private_key, config.block_confirmations, config.transaction_timeout)
 
 # Publish an NFT token
-erc721_nft = ocean.create_erc721_nft('NFTToken1', 'NFT1', alice_wallet)
-print(f"Created ERC721 data NFT. Its address is {erc721_nft.address}")
+data_nft = ocean.create_data_nft('NFTToken1', 'NFT1', alice_wallet)
+print(f"Created ERC721 data NFT. Its address is {data_nft.address}")
 ```
 
 Congrats, you've created your first Ocean data NFT!
@@ -110,8 +110,8 @@ In the same python console:
 ```python
 # Create ERC20 token related to the above NFT.
 
-erc20_token = erc721_nft.create_datatoken("Datatoken 1", "DT1", from_wallet=alice_wallet)
-print(f"Created ERC20 datatoken. Its address is {erc20_token.address}")
+datatoken = data_nft.create_datatoken("Datatoken 1", "DT1", from_wallet=alice_wallet)
+print(f"Created ERC20 datatoken. Its address is {datatoken.address}")
 ```
 
 Congrats, you've created your first Ocean datatoken! 🐋
@@ -132,10 +132,10 @@ print(f"config.provider_url = '{config.provider_url}'")
 print(f"alice_wallet.address = '{alice_wallet.address}'")
 
 # data NFT
-print(f"data NFT token name: {erc721_nft.token_name()}")
-print(f"data NFT token symbol: {erc721_nft.symbol()}")
+print(f"data NFT token name: {data_nft.token_name()}")
+print(f"data NFT token symbol: {data_nft.symbol()}")
 
 # datatoken
-print(f"datatoken name: {erc20_token.token_name()}")
-print(f"datatoken symbol: {erc20_token.symbol()}")
+print(f"datatoken name: {datatoken.token_name()}")
+print(f"datatoken symbol: {datatoken.symbol()}")
 ```
diff --git a/READMEs/erc20-enterprise.md b/READMEs/datatoken-enterprise.md
similarity index 79%
rename from READMEs/erc20-enterprise.md
rename to READMEs/datatoken-enterprise.md
index 629ba7137..07f2e84c4 100644
--- a/READMEs/erc20-enterprise.md
+++ b/READMEs/datatoken-enterprise.md
@@ -3,10 +3,10 @@ Copyright 2022 Ocean Protocol Foundation
 SPDX-License-Identifier: Apache-2.0
 -->
 
-# Quickstart: Using ERC20 Enterprise
+# Quickstart: Using Datatoken Enterprise
 
 This quickstart describes a batteries-included flow including using a new template of ERC20,
-called ERC20 Enterprise.
+called Datatoken Enterprise.
 
 For dispenser & FRE, it is used as base token, OCEAN token.
 The base token can be changed into something else, such as USDC, DAI etc., but
@@ -51,25 +51,25 @@ In the Python console:
 ```python
 from ocean_lib.web3_internal.constants import ZERO_ADDRESS
 
-erc20_enterprise_token = erc721_nft.create_datatoken(
+datatoken_enterprise_token = data_nft.create_datatoken(
     name="ERC20DT1",  # name for ERC20 token
     symbol="ERC20DT1Symbol",  # symbol for ERC20 token
-    template_index=2,  # this is the value for ERC20 Enterprise token
+    template_index=2,  # this is the value for Datatoken Enterprise token
     from_wallet=alice_wallet,
     datatoken_cap=ocean.to_wei(50)
 )
-print(f"ERC20 Enterprise address: {erc20_enterprise_token.address}")
+print(f"Datatoken Enterprise address: {datatoken_enterprise_token.address}")
 
 ```
 Then, please refer to [publish-flow](publish-flow.md) to generate your metadata and encrypted files.
-Asset creation will be based on the deployment of ERC20 Enterprise token like this:
+Asset creation will be based on the deployment of Datatoken Enterprise token like this:
 
 ```python
 asset = ocean.assets.create(
     metadata,
     alice_wallet,
     encrypted_files,
-    deployed_erc20_tokens=[erc20_enterprise_token]
+    deployed_datatokens=[datatoken_enterprise_token]
 )
 access_service = asset.services[0]
 
@@ -86,7 +86,7 @@ assert ocean.web3.eth.get_balance(bob_wallet.address) > 0, "need ganache ETH"
 
 # Create & activate dispenser
 dispenser = ocean.dispenser
-tx = erc20_enterprise_token.create_dispenser(
+tx = datatoken_enterprise_token.create_dispenser(
     dispenser_address=dispenser.address,
     allowed_swapper=ZERO_ADDRESS,
     max_balance=ocean.to_wei(50),
@@ -98,7 +98,7 @@ assert tx, "Dispenser not created!"
 
 OCEAN_token = ocean.OCEAN_token
 consume_fee_amount = ocean.to_wei(2)
-erc20_enterprise_token.set_publishing_market_fee(
+datatoken_enterprise_token.set_publishing_market_fee(
     publish_market_order_fee_address=bob_wallet.address,
     publish_market_order_fee_token=OCEAN_token.address,  # can be also USDC, DAI
     publish_market_order_fee_amount=consume_fee_amount,
@@ -107,7 +107,7 @@ erc20_enterprise_token.set_publishing_market_fee(
 
 # Approve tokens
 OCEAN_token.approve(
-    spender=erc20_enterprise_token.address,
+    spender=datatoken_enterprise_token.address,
     amount=consume_fee_amount,
     from_wallet=alice_wallet,
 )
@@ -133,7 +133,7 @@ OCEAN_token.approve(
 initial_bob_balance = OCEAN_token.balanceOf(bob_wallet.address)
 
 # Bob gets 1 DT from dispenser and then startsOrder, while burning that DT
-erc20_enterprise_token.buy_from_dispenser_and_order(
+datatoken_enterprise_token.buy_from_dispenser_and_order(
     consumer=bob_wallet.address,
     service_index=1,
     provider_fee_address=provider_fee_address,
@@ -145,7 +145,7 @@ erc20_enterprise_token.buy_from_dispenser_and_order(
     valid_until=valid_until,
     provider_data=provider_data,
     consume_market_order_fee_address=bob_wallet.address,
-    consume_market_order_fee_token=erc20_enterprise_token.address,
+    consume_market_order_fee_token=datatoken_enterprise_token.address,
     consume_market_order_fee_amount=0,
     dispenser_address=dispenser.address,
     from_wallet=alice_wallet,
@@ -160,25 +160,25 @@ In the Python console:
 ```python
 from ocean_lib.web3_internal.constants import ZERO_ADDRESS
 
-erc20_enterprise_token = erc721_nft.create_datatoken(
+datatoken_enterprise_token = data_nft.create_datatoken(
     name="ERC20DT1",  # name for ERC20 token
     symbol="ERC20DT1Symbol",  # symbol for ERC20 token
-    template_index=2,  # this is the value for ERC20 Enterprise token
+    template_index=2,  # this is the value for Datatoken Enterprise token
     from_wallet=alice_wallet,
     datatoken_cap=ocean.to_wei(50)
 )
-print(f"ERC20 Enterprise address: {erc20_enterprise_token.address}")
+print(f"Datatoken Enterprise address: {datatoken_enterprise_token.address}")
 
 ```
 Then, please refer to [publish-flow](publish-flow.md) to generate your metadata and encrypted files.
-Asset creation will be based on the deployment of ERC20 Enterprise token like this:
+Asset creation will be based on the deployment of Datatoken Enterprise token like this:
 
 ```python
 asset = ocean.assets.create(
     metadata,
     alice_wallet,
     encrypted_files,
-    deployed_erc20_tokens=[erc20_enterprise_token]
+    deployed_datatokens=[datatoken_enterprise_token]
 )
 access_service = asset.services[0]
 
@@ -198,7 +198,7 @@ fixed_rate_exchange = ocean.fixed_rate_exchange
 OCEAN_token = ocean.OCEAN_token
 
 exchange_id = ocean.create_fixed_rate(
-    erc20_token=erc20_enterprise_token,
+    datatoken=datatoken_enterprise_token,
     base_token=OCEAN_token,
     amount=ocean.to_wei(25),
     from_wallet=alice_wallet,
@@ -221,30 +221,30 @@ exchange_id = ocean.create_fixed_rate(
     publisher_wallet=alice_wallet
 )
 
-erc20_enterprise_token.mint(alice_wallet.address, ocean.to_wei(20), alice_wallet)
+datatoken_enterprise_token.mint(alice_wallet.address, ocean.to_wei(20), alice_wallet)
 
 # Approve tokens
 OCEAN_token.approve(
-    spender=erc20_enterprise_token.address,
+    spender=datatoken_enterprise_token.address,
     amount=ocean.to_wei(1000),
     from_wallet=alice_wallet,
 )
 # Approve consume market fee tokens before starting order.
-erc20_enterprise_token.approve(
-    spender=erc20_enterprise_token.address,
+datatoken_enterprise_token.approve(
+    spender=datatoken_enterprise_token.address,
     amount=ocean.to_wei(1000),
     from_wallet=alice_wallet
 )
 
-# Transfer some ERC20 Enterprise tokens to Bob for buying from the FRE
-erc20_enterprise_token.transfer(bob_wallet.address, ocean.to_wei(15), alice_wallet)
+# Transfer some Datatoken Enterprise tokens to Bob for buying from the FRE
+datatoken_enterprise_token.transfer(bob_wallet.address, ocean.to_wei(15), alice_wallet)
 OCEAN_token.approve(
-    spender=erc20_enterprise_token.address,
+    spender=datatoken_enterprise_token.address,
     amount=ocean.to_wei(1000),
     from_wallet=bob_wallet,
 )
 
-tx_id = erc20_enterprise_token.buy_from_fre_and_order(
+tx_id = datatoken_enterprise_token.buy_from_fre_and_order(
     consumer=bob_wallet.address,
     service_index=1,
     provider_fee_address=provider_fee_address,
@@ -256,7 +256,7 @@ tx_id = erc20_enterprise_token.buy_from_fre_and_order(
     valid_until=valid_until,
     provider_data=provider_data,
     consume_market_order_fee_address=bob_wallet.address,
-    consume_market_order_fee_token=erc20_enterprise_token.address,
+    consume_market_order_fee_token=datatoken_enterprise_token.address,
     consume_market_order_fee_amount=0,
     exchange_contract=fixed_rate_exchange.address,
     exchange_id=exchange_id,
diff --git a/READMEs/developers.md b/READMEs/developers.md
index 16c4f17ce..5632519c2 100644
--- a/READMEs/developers.md
+++ b/READMEs/developers.md
@@ -83,10 +83,10 @@ export FACTORY_DEPLOYER_PRIVATE_KEY=0xc594c6e5def4bab63ac29eed19a134c130388f74f0
 In work console:
 ```console
 #run a single test
-pytest ocean_lib/models/test/test_erc721_factory.py::test_start_multiple_order
+pytest ocean_lib/models/test/test_data_nft_factory.py::test_start_multiple_order
 
 #run all tests in a file
-pytest ocean_lib/models/test/test_erc721_factory.py
+pytest ocean_lib/models/test/test_data_nft_factory.py
 
 #run all regular tests; see details on pytest markers to select specific suites
 pytest -m "not slow"
diff --git a/READMEs/dispenser-flow.md b/READMEs/dispenser-flow.md
index 7561c3655..5bcfc86a7 100644
--- a/READMEs/dispenser-flow.md
+++ b/READMEs/dispenser-flow.md
@@ -51,7 +51,7 @@ dispenser = ocean.dispenser
 
 max_amount = ocean.to_wei(50)
 # Create dispenser
-erc20_token.create_dispenser(
+datatoken.create_dispenser(
     dispenser_address=dispenser.address,
     max_balance=max_amount,
     max_tokens=max_amount,
@@ -60,17 +60,17 @@ erc20_token.create_dispenser(
     from_wallet=alice_wallet,
 )
 
-dispenser_status = dispenser.status(erc20_token.address)
+dispenser_status = dispenser.status(datatoken.address)
 assert dispenser_status[0] is True
 assert dispenser_status[1] == alice_wallet.address
 assert dispenser_status[2] is True
 
-initial_balance = erc20_token.balanceOf(alice_wallet.address)
+initial_balance = datatoken.balanceOf(alice_wallet.address)
 assert initial_balance == 0
 dispenser.dispense_tokens(
-    erc20_token=erc20_token, amount=max_amount, consumer_wallet=alice_wallet
+    datatoken=datatoken, amount=max_amount, consumer_wallet=alice_wallet
 )
-assert erc20_token.balanceOf(alice_wallet.address) == max_amount
+assert datatoken.balanceOf(alice_wallet.address) == max_amount
 ```
 
 As an alternative for publishing a NFT, a datatoken and a dispenser at once, you can use `create_nft_erc20_with_dispenser`.
diff --git a/READMEs/fixed-rate-exchange-flow.md b/READMEs/fixed-rate-exchange-flow.md
index 8e073f589..153407b0d 100644
--- a/READMEs/fixed-rate-exchange-flow.md
+++ b/READMEs/fixed-rate-exchange-flow.md
@@ -47,7 +47,7 @@ Please refer to [data-nfts-and-datatokens-flow](data-nfts-and-datatokens-flow.md
 In the same python console:
 ```python
 # Mint the datatokens
-erc20_token.mint(alice_wallet.address, ocean.to_wei(100), alice_wallet)
+datatoken.mint(alice_wallet.address, ocean.to_wei(100), alice_wallet)
 ```
 
 ## 4. Bob buys at fixed rate datatokens
@@ -64,7 +64,7 @@ assert ocean.web3.eth.get_balance(bob_wallet.address) > 0, "need ganache ETH"
 OCEAN_token = ocean.OCEAN_token
 # Create exchange_id for a new exchange
 exchange_id = ocean.create_fixed_rate(
-    erc20_token=erc20_token,
+    datatoken=datatoken,
     base_token=OCEAN_token,
     amount=ocean.to_wei(100),
     from_wallet=alice_wallet,
@@ -77,7 +77,7 @@ Use the `exchange_id` for buying at fixed rate.
 # Approve tokens for Bob
 from ocean_lib.web3_internal.constants import ZERO_ADDRESS
 fixed_price_address = ocean.fixed_rate_exchange.address
-erc20_token.approve(fixed_price_address, ocean.to_wei(100), bob_wallet)
+datatoken.approve(fixed_price_address, ocean.to_wei(100), bob_wallet)
 OCEAN_token.approve(fixed_price_address, ocean.to_wei(100), bob_wallet)
 
 tx_result = ocean.fixed_rate_exchange.buy_dt(
@@ -99,7 +99,7 @@ exchanges for a certain datatoken, it can be searched by
 providing the datatoken address.
 ```python
 # Get a list exchange addresses and ids with a given datatoken and exchange owner.
-datatoken_address = erc20_token.address
+datatoken_address = datatoken.address
 nft_factory = ocean.get_nft_factory()
 exchange_addresses_and_ids = nft_factory.search_exchange_by_datatoken(ocean.fixed_rate_exchange, datatoken_address)
 # Optional: Filtering by the exchange owner.
diff --git a/READMEs/key-value-flow.md b/READMEs/key-value-flow.md
index e06539f42..d2a8a56cd 100644
--- a/READMEs/key-value-flow.md
+++ b/READMEs/key-value-flow.md
@@ -47,13 +47,13 @@ key_hash = ocean.web3.keccak(text=key)  # Contract/ERC725 requires keccak256 has
 value_hex = value.encode('utf-8').hex()  # set_new_data() needs hex
 
 # set
-erc721_nft.set_new_data(key_hash, value_hex, alice_wallet)
+data_nft.set_new_data(key_hash, value_hex, alice_wallet)
 ```
 
 ## 4. Retrieve value from data NFT
 
 ```python
-value2_hex = erc721_nft.get_data(key_hash)
+value2_hex = data_nft.get_data(key_hash)
 value2 = value2_hex.decode('ascii')
 print(f"Found that {key} = {value2}")
 ```
diff --git a/READMEs/marketplace-flow.md b/READMEs/marketplace-flow.md
index 3d60bfbb0..71b6852b8 100644
--- a/READMEs/marketplace-flow.md
+++ b/READMEs/marketplace-flow.md
@@ -73,11 +73,11 @@ to order this access token.
 from ocean_lib.ocean.mint_fake_ocean import mint_fake_OCEAN
 mint_fake_OCEAN(config)
 
-erc20_token = ocean.get_datatoken(asset.services[0].datatoken)
+datatoken = ocean.get_datatoken(asset.services[0].datatoken)
 OCEAN_token = ocean.OCEAN_token
 
 bpool = ocean.create_pool(
-    erc20_token=erc20_token,
+    datatoken=datatoken,
     base_token=OCEAN_token,
     rate=ocean.to_wei(1),
     base_token_amount=ocean.to_wei(2000),
@@ -97,12 +97,12 @@ In the same Python console as before:
 
 ```python
 prices = bpool.get_amount_in_exact_out(
-    OCEAN_token.address, erc20_token.address, ocean.to_wei(1), ocean.to_wei("0.01")
+    OCEAN_token.address, datatoken.address, ocean.to_wei(1), ocean.to_wei("0.01")
 )
 price_in_OCEAN = prices[0]
 
 from ocean_lib.web3_internal.currency import pretty_ether_and_wei
-print(f"Price of 1 {erc20_token.symbol()} is {pretty_ether_and_wei(price_in_OCEAN, 'OCEAN')}")
+print(f"Price of 1 {datatoken.symbol()} is {pretty_ether_and_wei(price_in_OCEAN, 'OCEAN')}")
 ```
 
 ## 5. Bob buys data asset
@@ -127,7 +127,7 @@ OCEAN_token.approve(bpool.address, ocean.to_wei("10000"), from_wallet=bob_wallet
 
 bpool.swap_exact_amount_out(
     token_in=OCEAN_token.address,
-    token_out=erc20_token.address,
+    token_out=datatoken.address,
     consume_market_swap_fee_address=ZERO_ADDRESS,
     max_amount_in=ocean.to_wei(10),
     token_amount_out=ocean.to_wei(1),
@@ -135,7 +135,7 @@ bpool.swap_exact_amount_out(
     consume_market_swap_fee_amount=0,
     from_wallet=bob_wallet,
 )
-assert erc20_token.balanceOf(bob_wallet.address) >= ocean.to_wei(
+assert datatoken.balanceOf(bob_wallet.address) >= ocean.to_wei(
     1
 ), "Bob didn't get 1.0 datatokens"
 
@@ -150,7 +150,7 @@ order_tx_id = ocean.assets.pay_for_access_service(
     asset,
     service,
     consume_market_order_fee_address=bob_wallet.address,
-    consume_market_order_fee_token=erc20_token.address,
+    consume_market_order_fee_token=datatoken.address,
     consume_market_order_fee_amount=0,
     wallet=bob_wallet,
 )
diff --git a/READMEs/profile-nfts-flow.md b/READMEs/profile-nfts-flow.md
index 4ca149b31..9c54c0e25 100644
--- a/READMEs/profile-nfts-flow.md
+++ b/READMEs/profile-nfts-flow.md
@@ -50,7 +50,7 @@ alice_private_key = os.getenv('TEST_PRIVATE_KEY1')
 alice_wallet = Wallet(ocean.web3, alice_private_key, config.block_confirmations, config.transaction_timeout)
 
 # Publish an NFT token. Note "transferable=False"
-erc721_nft = ocean.create_erc721_nft('NFTToken1', 'NFT1', alice_wallet, transferable=False)
+data_nft = ocean.create_data_nft('NFTToken1', 'NFT1', alice_wallet, transferable=False)
 ```
 
 ## 3. Alice adds key-value pair to data NFT. 'value' encrypted with a symmetric key 'symkey'
@@ -74,7 +74,7 @@ profiledata_name_hash = web3.keccak(text=profiledata_name)
 # - sharing it unlocks only this field: make unique to this data nft & field
 # - only Alice can compute it: make it a function of her private key
 # - is hardware wallet friendly: uses Alice's digital signature not private key
-preimage = erc721_nft.address + profiledata_name
+preimage = data_nft.address + profiledata_name
 msg = encode_defunct(text=sha256(preimage.encode('utf-8')).hexdigest())
 signed_msg = web3.eth.account.sign_message(msg, private_key=alice_wallet.private_key)
 symkey = b64encode(signed_msg.signature.hex().encode('ascii'))[:43] + b'='  # bytes
@@ -83,7 +83,7 @@ symkey = b64encode(signed_msg.signature.hex().encode('ascii'))[:43] + b'='  # by
 profiledata_val_encr_hex = Fernet(symkey).encrypt(profiledata_val.encode('utf-8')).hex()
 
 # set
-erc721_nft.set_new_data(profiledata_name_hash, profiledata_val_encr_hex, alice_wallet)
+data_nft.set_new_data(profiledata_name_hash, profiledata_val_encr_hex, alice_wallet)
 ```
 
 ## 4. Alice gets Dapp's public_key
@@ -115,7 +115,7 @@ symkey_val_encr = asymmetric_encrypt(dapp_public_key, symkey)  # bytes
 symkey_val_encr_hex = symkey_val_encr.hex()  # hex
 
 # arg types: key=bytes32, value=bytes, wallet=wallet
-erc721_nft.set_new_data(symkey_name_hash, symkey_val_encr_hex, alice_wallet)
+data_nft.set_new_data(symkey_name_hash, symkey_val_encr_hex, alice_wallet)
 ```
 
 ## 6. Dapp gets & decrypts symkey, then gets & decrypts original 'value'
@@ -124,11 +124,11 @@ erc721_nft.set_new_data(symkey_name_hash, symkey_val_encr_hex, alice_wallet)
 from ecies import decrypt as asymmetric_decrypt
 
 # symkey_name_hash = <Dapp would set like above>
-symkey_val_encr2 = erc721_nft.get_data(symkey_name_hash)
+symkey_val_encr2 = data_nft.get_data(symkey_name_hash)
 symkey2 = asymmetric_decrypt(dapp_private_key, symkey_val_encr2)
 
 # profiledata_name_hash = <Dapp would set like above>
-profiledata_val_encr_hex2 = erc721_nft.get_data(profiledata_name_hash)
+profiledata_val_encr_hex2 = data_nft.get_data(profiledata_name_hash)
 profiledata_val2_bytes = Fernet(symkey).decrypt(profiledata_val_encr_hex2)
 profiledata_val2 = profiledata_val2_bytes.decode('utf-8')
 
diff --git a/ocean_lib/models/erc721_nft.py b/ocean_lib/models/data_nft.py
similarity index 95%
rename from ocean_lib/models/erc721_nft.py
rename to ocean_lib/models/data_nft.py
index ae29cdbcf..bbb599a23 100644
--- a/ocean_lib/models/erc721_nft.py
+++ b/ocean_lib/models/data_nft.py
@@ -7,17 +7,17 @@
 
 from enforce_typing import enforce_types
 
-from ocean_lib.models.erc20_enterprise import ERC20Enterprise
-from ocean_lib.models.erc20_token import ERC20Token
+from ocean_lib.models.datatoken import Datatoken
+from ocean_lib.models.datatoken_enterprise import DatatokenEnterprise
 from ocean_lib.structures.abi_tuples import MetadataProof
 from ocean_lib.web3_internal.constants import MAX_UINT256, ZERO_ADDRESS
 from ocean_lib.web3_internal.contract_base import ContractBase
 from ocean_lib.web3_internal.wallet import Wallet
 
 
-class ERC721Permissions(IntEnum):
+class DataNFTPermissions(IntEnum):
     MANAGER = 0
-    DEPLOY_ERC20 = 1
+    DEPLOY_DATATOKEN = 1
     UPDATE_METADATA = 2
     STORE = 3
 
@@ -40,7 +40,7 @@ def to_byte(self):
 
 
 @enforce_types
-class ERC721NFT(ContractBase):
+class DataNFT(ContractBase):
     CONTRACT_NAME = "ERC721Template"
 
     EVENT_TOKEN_CREATED = "TokenCreated"
@@ -151,7 +151,7 @@ def create_erc20(
         datatoken_cap: Optional[int] = None,
     ) -> str:
         if template_index == 2 and not datatoken_cap:
-            raise Exception("Cap is needed for ERC20 Enterprise token deployment.")
+            raise Exception("Cap is needed for Datatoken Enterprise token deployment.")
         datatoken_cap = datatoken_cap if template_index == 2 else MAX_UINT256
         return self.send_transaction(
             "createERC20",
@@ -224,7 +224,7 @@ def remove_manager(self, manager_address: str, from_wallet: Wallet) -> str:
 
     @enforce_types
     def add_multiple_users_to_roles(
-        self, addresses: List[str], roles: List[ERC721Permissions], from_wallet: Wallet
+        self, addresses: List[str], roles: List[DataNFTPermissions], from_wallet: Wallet
     ) -> str:
         return self.send_transaction(
             "addMultipleUsersToRoles",
@@ -348,7 +348,7 @@ def create_datatoken(
         publish_market_order_fee_amount: Optional[int] = 0,
         bytess: Optional[List[bytes]] = None,
         datatoken_cap: Optional[int] = None,
-    ) -> ERC20Token:
+    ) -> Datatoken:
         initial_list = self.get_tokens_list()
 
         local_values = locals().copy()
@@ -383,7 +383,7 @@ def create_datatoken(
             create_args["bytess"] = [b""]
 
         if template_index == 2 and not datatoken_cap:
-            raise Exception("Cap is needed for ERC20 Enterprise token deployment.")
+            raise Exception("Cap is needed for Datatoken Enterprise token deployment.")
 
         if template_index == 2:
             create_args["datatoken_cap"] = datatoken_cap
@@ -397,7 +397,7 @@ def create_datatoken(
         assert len(new_elements) == 1, "new data token has no address"
 
         return (
-            ERC20Token(self.web3, new_elements[0])
+            Datatoken(self.web3, new_elements[0])
             if template_index == 1
-            else ERC20Enterprise(self.web3, new_elements[0])
+            else DatatokenEnterprise(self.web3, new_elements[0])
         )
diff --git a/ocean_lib/models/erc721_factory.py b/ocean_lib/models/data_nft_factory.py
similarity index 95%
rename from ocean_lib/models/erc721_factory.py
rename to ocean_lib/models/data_nft_factory.py
index a2643027f..69eebeeaf 100644
--- a/ocean_lib/models/erc721_factory.py
+++ b/ocean_lib/models/data_nft_factory.py
@@ -7,16 +7,16 @@
 from enforce_typing import enforce_types
 from web3.exceptions import BadFunctionCallOutput
 
-from ocean_lib.models.erc20_token import ERC20Token
-from ocean_lib.models.erc721_nft import ERC721NFT
-from ocean_lib.models.erc_token_factory_base import ERCTokenFactoryBase
+from ocean_lib.models.data_nft import DataNFT
+from ocean_lib.models.datatoken import Datatoken
+from ocean_lib.models.erc721_token_factory_base import ERC721TokenFactoryBase
 from ocean_lib.models.fixed_rate_exchange import FixedRateExchange
 from ocean_lib.structures.abi_tuples import MetadataProof, OrderData
 from ocean_lib.web3_internal.constants import MAX_UINT256
 from ocean_lib.web3_internal.wallet import Wallet
 
 
-class ERC721FactoryContract(ERCTokenFactoryBase):
+class DataNFTFactoryContract(ERC721TokenFactoryBase):
     CONTRACT_NAME = "ERC721Factory"
     EVENT_NFT_CREATED = "NFTCreated"
     EVENT_TOKEN_CREATED = "TokenCreated"
@@ -62,7 +62,7 @@ def event_Transfer(self):
     @enforce_types
     def verify_nft(self, nft_address: str) -> bool:
         """Checks that a token was registered."""
-        data_nft_contract = ERC721NFT(self.web3, nft_address)
+        data_nft_contract = DataNFT(self.web3, nft_address)
         try:
             data_nft_contract.get_id()
             return True
@@ -170,7 +170,7 @@ def create_nft_with_erc20(
         datatoken_cap: Optional[int] = None,
     ) -> str:
         if datatoken_template == 2 and not datatoken_cap:
-            raise Exception("Cap is needed for ERC20 Enterprise token deployment.")
+            raise Exception("Cap is needed for Datatoken Enterprise token deployment.")
         datatoken_cap = datatoken_cap if datatoken_template == 2 else MAX_UINT256
         return self.send_transaction(
             "createNftWithErc20",
@@ -232,7 +232,7 @@ def create_nft_erc20_with_pool(
         datatoken_cap: Optional[int] = None,
     ) -> str:
         if datatoken_template == 2 and not datatoken_cap:
-            raise Exception("Cap is needed for ERC20 Enterprise token deployment.")
+            raise Exception("Cap is needed for Datatoken Enterprise token deployment.")
         datatoken_cap = datatoken_cap if datatoken_template == 2 else MAX_UINT256
         return self.send_transaction(
             "createNftWithErc20WithPool",
@@ -316,7 +316,7 @@ def create_nft_erc20_with_fixed_rate(
         datatoken_cap: Optional[int] = None,
     ) -> str:
         if datatoken_template == 2 and not datatoken_cap:
-            raise Exception("Cap is needed for ERC20 Enterprise token deployment.")
+            raise Exception("Cap is needed for Datatoken Enterprise token deployment.")
         datatoken_cap = datatoken_cap if datatoken_template == 2 else MAX_UINT256
         return self.send_transaction(
             "createNftWithErc20WithFixedRate",
@@ -388,7 +388,7 @@ def create_nft_erc20_with_dispenser(
         datatoken_cap: Optional[int] = None,
     ) -> str:
         if datatoken_template == 2 and not datatoken_cap:
-            raise Exception("Cap is needed for ERC20 Enterprise token deployment.")
+            raise Exception("Cap is needed for Datatoken Enterprise token deployment.")
         datatoken_cap = datatoken_cap if datatoken_template == 2 else MAX_UINT256
         return self.send_transaction(
             "createNftWithErc20WithDispenser",
@@ -473,7 +473,7 @@ def search_exchange_by_datatoken(
         datatoken: str,
         exchange_owner: Optional[str] = None,
     ) -> list:
-        datatoken_contract = ERC20Token(self.web3, datatoken)
+        datatoken_contract = Datatoken(self.web3, datatoken)
         exchange_addresses_and_ids = datatoken_contract.get_fixed_rates()
         return (
             exchange_addresses_and_ids
@@ -490,7 +490,7 @@ def search_exchange_by_datatoken(
     def get_token_address(self, tx_id: Union[str, bytes]):
         tx_receipt = self.web3.eth.wait_for_transaction_receipt(tx_id)
         registered_event = self.get_event_log(
-            event_name=ERC721FactoryContract.EVENT_NFT_CREATED,
+            event_name=DataNFTFactoryContract.EVENT_NFT_CREATED,
             from_block=tx_receipt.blockNumber,
             to_block=self.web3.eth.block_number,
             filters=None,
diff --git a/ocean_lib/models/erc20_token.py b/ocean_lib/models/datatoken.py
similarity index 99%
rename from ocean_lib/models/erc20_token.py
rename to ocean_lib/models/datatoken.py
index 2f2de5040..d46bd62af 100644
--- a/ocean_lib/models/erc20_token.py
+++ b/ocean_lib/models/datatoken.py
@@ -11,12 +11,12 @@
 from ocean_lib.web3_internal.wallet import Wallet
 
 
-class RolesERC20(IntEnum):
+class DatatokenRoles(IntEnum):
     MINTER = 0
     PAYMENT_MANAGER = 1
 
 
-class ERC20Token(ContractBase):
+class Datatoken(ContractBase):
     CONTRACT_NAME = "ERC20Template"
 
     BASE = 10**18
@@ -518,9 +518,9 @@ def get_start_order_logs(
         return logs
 
 
-class MockERC20(ERC20Token):
+class MockERC20(Datatoken):
     CONTRACT_NAME = "MockERC20"
 
 
-class MockOcean(ERC20Token):
+class MockOcean(Datatoken):
     CONTRACT_NAME = "MockOcean"
diff --git a/ocean_lib/models/erc20_enterprise.py b/ocean_lib/models/datatoken_enterprise.py
similarity index 97%
rename from ocean_lib/models/erc20_enterprise.py
rename to ocean_lib/models/datatoken_enterprise.py
index 4de1f802c..0a24e80ec 100644
--- a/ocean_lib/models/erc20_enterprise.py
+++ b/ocean_lib/models/datatoken_enterprise.py
@@ -6,11 +6,11 @@
 
 from enforce_typing import enforce_types
 
-from ocean_lib.models.erc20_token import ERC20Token
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.web3_internal.wallet import Wallet
 
 
-class ERC20Enterprise(ERC20Token):
+class DatatokenEnterprise(Datatoken):
     CONTRACT_NAME = "ERC20TemplateEnterprise"
 
     @enforce_types
diff --git a/ocean_lib/models/dispenser.py b/ocean_lib/models/dispenser.py
index 16592b3cd..313f76daf 100644
--- a/ocean_lib/models/dispenser.py
+++ b/ocean_lib/models/dispenser.py
@@ -4,7 +4,7 @@
 #
 from enforce_typing import enforce_types
 
-from ocean_lib.models.erc20_token import ERC20Token
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.web3_internal.contract_base import ContractBase
 from ocean_lib.web3_internal.wallet import Wallet
 
@@ -79,10 +79,10 @@ def owner_withdraw(self, datatoken: str, from_wallet: Wallet) -> str:
 
     @enforce_types
     def dispense_tokens(
-        self, erc20_token: ERC20Token, amount: int, consumer_wallet: Wallet
+        self, datatoken: Datatoken, amount: int, consumer_wallet: Wallet
     ):
         self.dispense(
-            datatoken=erc20_token.address,
+            datatoken=datatoken.address,
             amount=amount,
             destination=consumer_wallet.address,
             from_wallet=consumer_wallet,
diff --git a/ocean_lib/models/erc_token_factory_base.py b/ocean_lib/models/erc721_token_factory_base.py
similarity index 96%
rename from ocean_lib/models/erc_token_factory_base.py
rename to ocean_lib/models/erc721_token_factory_base.py
index 27e78e6b2..793fa5a03 100644
--- a/ocean_lib/models/erc_token_factory_base.py
+++ b/ocean_lib/models/erc721_token_factory_base.py
@@ -9,7 +9,7 @@
 from ocean_lib.web3_internal.contract_base import ContractBase
 
 
-class ERCTokenFactoryBase(ABC, ContractBase):
+class ERC721TokenFactoryBase(ABC, ContractBase):
     @enforce_types
     def get_current_token_count(self) -> int:
         return self.contract.caller.getCurrentTokenCount()
diff --git a/ocean_lib/models/side_staking.py b/ocean_lib/models/side_staking.py
index b7834a122..311955764 100644
--- a/ocean_lib/models/side_staking.py
+++ b/ocean_lib/models/side_staking.py
@@ -3,9 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 from enforce_typing import enforce_types
-from eth_typing import HexStr
 
-from ocean_lib.models.erc20_token import ERC20Token
 from ocean_lib.web3_internal.contract_base import ContractBase
 from ocean_lib.web3_internal.wallet import Wallet
 
diff --git a/ocean_lib/ocean/mint_fake_ocean.py b/ocean_lib/ocean/mint_fake_ocean.py
index 0bf3d2147..bfe45dddd 100644
--- a/ocean_lib/ocean/mint_fake_ocean.py
+++ b/ocean_lib/ocean/mint_fake_ocean.py
@@ -6,7 +6,7 @@
 import os
 
 from ocean_lib.config import Config
-from ocean_lib.models.erc20_token import ERC20Token
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.ocean.util import get_web3
 from ocean_lib.web3_internal.currency import to_wei
 from ocean_lib.web3_internal.transactions import send_ether
@@ -33,7 +33,7 @@ def mint_fake_OCEAN(config: Config) -> None:
         transaction_timeout=config.transaction_timeout,
     )
 
-    OCEAN_token = ERC20Token(web3, address=network_addresses["development"]["Ocean"])
+    OCEAN_token = Datatoken(web3, address=network_addresses["development"]["Ocean"])
     amt_distribute = to_wei("2000")
 
     for key_label in ["TEST_PRIVATE_KEY1", "TEST_PRIVATE_KEY2", "TEST_PRIVATE_KEY3"]:
diff --git a/ocean_lib/ocean/ocean.py b/ocean_lib/ocean/ocean.py
index aef447822..998483881 100644
--- a/ocean_lib/ocean/ocean.py
+++ b/ocean_lib/ocean/ocean.py
@@ -16,10 +16,10 @@
 from ocean_lib.data_provider.data_service_provider import DataServiceProvider
 from ocean_lib.models.bpool import BPool
 from ocean_lib.models.compute_input import ComputeInput
+from ocean_lib.models.data_nft import DataNFT
+from ocean_lib.models.data_nft_factory import DataNFTFactoryContract
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.models.dispenser import Dispenser
-from ocean_lib.models.erc20_token import ERC20Token
-from ocean_lib.models.erc721_factory import ERC721FactoryContract
-from ocean_lib.models.erc721_nft import ERC721NFT
 from ocean_lib.models.factory_router import FactoryRouter
 from ocean_lib.models.fixed_rate_exchange import FixedRateExchange
 from ocean_lib.models.side_staking import SideStaking
@@ -107,8 +107,8 @@ def OCEAN_address(self) -> str:
 
     @property
     @enforce_types
-    def OCEAN_token(self) -> ERC20Token:
-        return ERC20Token(self.web3, self.OCEAN_address)
+    def OCEAN_token(self) -> Datatoken:
+        return Datatoken(self.web3, self.OCEAN_address)
 
     @enforce_types
     def to_wei(self, amount_in_ether: Union[Decimal, str, int]):
@@ -127,7 +127,7 @@ def format_units(self, amount: Union[Decimal, str, int], units: int = DECIMALS_1
         return _format_units(amount, units)
 
     @enforce_types
-    def create_erc721_nft(
+    def create_data_nft(
         self,
         name: str,
         symbol: str,
@@ -138,7 +138,7 @@ def create_erc721_nft(
         additional_metadata_updater: Optional[str] = None,
         transferable: bool = True,
         owner: Optional[str] = None,
-    ) -> ERC721NFT:
+    ) -> DataNFT:
         """
         This method deploys a ERC721 token contract on the blockchain.
         Usage:
@@ -151,16 +151,16 @@ def create_erc721_nft(
                 block_confirmations=config.block_confirmations,
                 transaction_timeout=config.transaction_timeout,
             )
-            erc721_nft = ocean.create_erc721_nft("Dataset name", "dtsymbol", from_wallet=wallet)
+            data_nft = ocean.create_data_nft("Dataset name", "dtsymbol", from_wallet=wallet)
         ```
-        :param name: ERC721 token name, str
-        :param symbol: ERC721 token symbol, str
+        :param name: data NFT token name, str
+        :param symbol: data NFT token symbol, str
         :param from_wallet: wallet instance, wallet
         :param template_index: Template type of the token, int
         :param additional_erc20_deployer: Address of another ERC20 deployer, str
-        :param token_uri: URL for ERC721 token, str
+        :param token_uri: URL for the data NFT token, str
 
-        :return: `ERC721NFT` instance
+        :return: `DataNFT` instance
         """
 
         if not additional_erc20_deployer:
@@ -185,40 +185,40 @@ def create_erc721_nft(
 
         address = nft_factory.get_token_address(tx_id)
         assert address, "new NFT token has no address"
-        token = ERC721NFT(self.web3, address)
+        token = DataNFT(self.web3, address)
         return token
 
     @enforce_types
-    def get_nft_token(self, token_address: str) -> ERC721NFT:
+    def get_nft_token(self, token_address: str) -> DataNFT:
         """
         :param token_address: Token contract address, str
-        :return: `ERC721NFT` instance
+        :return: `DataNFT` instance
         """
 
-        return ERC721NFT(self.web3, token_address)
+        return DataNFT(self.web3, token_address)
 
     @enforce_types
-    def get_datatoken(self, token_address: str) -> ERC20Token:
+    def get_datatoken(self, token_address: str) -> Datatoken:
         """
         :param token_address: Token contract address, str
-        :return: `ERC20Token` instance
+        :return: `Datatoken` instance
         """
 
-        return ERC20Token(self.web3, token_address)
+        return Datatoken(self.web3, token_address)
 
     @enforce_types
-    def get_nft_factory(self, nft_factory_address: str = "") -> ERC721FactoryContract:
+    def get_nft_factory(self, nft_factory_address: str = "") -> DataNFTFactoryContract:
         """
         :param nft_factory_address: contract address, str
 
-        :return: `ERC721FactoryContract` instance
+        :return: `DataNFTFactoryContract` instance
         """
         if not nft_factory_address:
             nft_factory_address = get_address_of_type(
-                self.config, ERC721FactoryContract.CONTRACT_NAME
+                self.config, DataNFTFactoryContract.CONTRACT_NAME
             )
 
-        return ERC721FactoryContract(self.web3, nft_factory_address)
+        return DataNFTFactoryContract(self.web3, nft_factory_address)
 
     @enforce_types
     def get_user_orders(
@@ -227,7 +227,7 @@ def get_user_orders(
         """
         :return: List of orders `[Order]`
         """
-        dt = ERC20Token(self.web3, datatoken)
+        dt = Datatoken(self.web3, datatoken)
         _orders = []
         for log in dt.get_start_order_logs(
             address, from_all_tokens=not bool(datatoken)
@@ -262,30 +262,30 @@ def side_staking(self):
     @enforce_types
     def create_fixed_rate(
         self,
-        erc20_token: ERC20Token,
-        base_token: ERC20Token,
+        datatoken: Datatoken,
+        base_token: Datatoken,
         amount: int,
         from_wallet: Wallet,
     ) -> bytes:
         fixed_price_address = get_address_of_type(self.config, "FixedPrice")
-        erc20_token.approve(fixed_price_address, amount, from_wallet)
+        datatoken.approve(fixed_price_address, amount, from_wallet)
 
-        tx = erc20_token.create_fixed_rate(
+        tx = datatoken.create_fixed_rate(
             fixed_price_address=fixed_price_address,
             base_token_address=base_token.address,
             owner=from_wallet.address,
             publish_market_swap_fee_collector=from_wallet.address,
             allowed_swapper=ZERO_ADDRESS,
             base_token_decimals=base_token.decimals(),
-            datatoken_decimals=erc20_token.decimals(),
+            datatoken_decimals=datatoken.decimals(),
             fixed_rate=self.to_wei(1),
             publish_market_swap_fee_amount=int(1e15),
             with_mint=0,
             from_wallet=from_wallet,
         )
         tx_receipt = self.web3.eth.wait_for_transaction_receipt(tx)
-        fixed_rate_event = erc20_token.get_event_log(
-            ERC721FactoryContract.EVENT_NEW_FIXED_RATE,
+        fixed_rate_event = datatoken.get_event_log(
+            DataNFTFactoryContract.EVENT_NEW_FIXED_RATE,
             tx_receipt.blockNumber,
             self.web3.eth.block_number,
             None,
@@ -307,8 +307,8 @@ def pool_template_address(self) -> str:
     @enforce_types
     def create_pool(
         self,
-        erc20_token: ERC20Token,
-        base_token: ERC20Token,
+        datatoken: Datatoken,
+        base_token: Datatoken,
         rate: int,
         base_token_amount: int,
         lp_swap_fee_amount: int,
@@ -320,7 +320,7 @@ def create_pool(
             get_address_of_type(self.config, "Router"), self.to_wei("2000"), from_wallet
         )
 
-        tx = erc20_token.deploy_pool(
+        tx = datatoken.deploy_pool(
             rate=rate,
             base_token_decimals=base_token.decimals(),
             base_token_amount=base_token_amount,
@@ -336,7 +336,7 @@ def create_pool(
         )
         tx_receipt = self.web3.eth.wait_for_transaction_receipt(tx)
         pool_event = self.factory_router.get_event_log(
-            ERC721FactoryContract.EVENT_NEW_POOL,
+            DataNFTFactoryContract.EVENT_NEW_POOL,
             tx_receipt.blockNumber,
             self.web3.eth.block_number,
             None,
diff --git a/ocean_lib/ocean/ocean_assets.py b/ocean_lib/ocean/ocean_assets.py
index b921a396b..c2f665c43 100644
--- a/ocean_lib/ocean/ocean_assets.py
+++ b/ocean_lib/ocean/ocean_assets.py
@@ -22,9 +22,9 @@
 from ocean_lib.data_provider.data_service_provider import DataServiceProvider
 from ocean_lib.exceptions import AquariusError, ContractNotFound, InsufficientBalance
 from ocean_lib.models.compute_input import ComputeInput
-from ocean_lib.models.erc20_token import ERC20Token
-from ocean_lib.models.erc721_factory import ERC721FactoryContract
-from ocean_lib.models.erc721_nft import ERC721NFT
+from ocean_lib.models.data_nft import DataNFT
+from ocean_lib.models.data_nft_factory import DataNFTFactoryContract
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.ocean.util import get_address_of_type
 from ocean_lib.services.service import Service
 from ocean_lib.structures.algorithm_metadata import AlgorithmMetadata
@@ -120,8 +120,8 @@ def build_access_service(
     @enforce_types
     def deploy_datatoken(
         self,
-        erc721_factory: ERC721FactoryContract,
-        erc721_nft: ERC721NFT,
+        data_nft_factory: DataNFTFactoryContract,
+        data_nft: DataNFT,
         template_index: int,
         name: str,
         symbol: str,
@@ -133,7 +133,7 @@ def deploy_datatoken(
         bytess: List[bytes],
         from_wallet: Wallet,
     ) -> str:
-        tx_result = erc721_nft.create_erc20(
+        tx_result = data_nft.create_erc20(
             template_index=template_index,
             name=name,
             symbol=symbol,
@@ -148,8 +148,8 @@ def deploy_datatoken(
         assert tx_result, "Failed to create ERC20 token."
 
         tx_receipt = self._web3.eth.wait_for_transaction_receipt(tx_result)
-        registered_token_event = erc721_factory.get_event_log(
-            ERC721FactoryContract.EVENT_TOKEN_CREATED,
+        registered_token_event = data_nft_factory.get_event_log(
+            DataNFTFactoryContract.EVENT_TOKEN_CREATED,
             tx_receipt.blockNumber,
             self._web3.eth.block_number,
             None,
@@ -165,21 +165,19 @@ def find_service_by_datatoken(self, datatoken: str, services: list) -> str:
         )
 
     @enforce_types
-    def build_datatokens_list(
-        self, services: list, deployed_erc20_tokens: list
-    ) -> list:
+    def build_datatokens_list(self, services: list, deployed_datatokens: list) -> list:
         datatokens = []
         # (1-n) service per datatoken, 1 datatoken per service
-        for erc20_token in deployed_erc20_tokens:
+        for datatoken in deployed_datatokens:
             datatokens = datatokens + [
                 {
-                    "address": erc20_token.address,
-                    "name": erc20_token.contract.caller.name(),
-                    "symbol": erc20_token.symbol(),
+                    "address": datatoken.address,
+                    "name": datatoken.contract.caller.name(),
+                    "symbol": datatoken.symbol(),
                     "serviceId": service.id,
                 }
                 for service in services
-                if service.datatoken == erc20_token.address
+                if service.datatoken == datatoken.address
             ]
 
         return datatokens
@@ -279,13 +277,13 @@ def create(
         erc20_publish_market_order_fee_tokens: Optional[List[str]] = None,
         erc20_publish_market_order_fee_amounts: Optional[List[int]] = None,
         erc20_bytess: Optional[List[List[bytes]]] = None,
-        deployed_erc20_tokens: Optional[List[ERC20Token]] = None,
+        deployed_datatokens: Optional[List[Datatoken]] = None,
         encrypt_flag: Optional[bool] = True,
         compress_flag: Optional[bool] = True,
     ) -> Optional[Asset]:
         """Register an asset on-chain.
 
-        Creating/deploying a ERC721NFT contract and in the Metadata store (Aquarius).
+        Creating/deploying a DataNFT contract and in the Metadata store (Aquarius).
 
         :param metadata: dict conforming to the Metadata accepted by Ocean Protocol.
         :param publisher_wallet: Wallet of the publisher registering this asset.
@@ -302,16 +300,16 @@ def create(
         :param erc721_additional_erc_deployer: str address of an additional ERC20 deployer.
         :param erc721_additional_metadata_updater: str address of an additional metadata updater.
         :param erc721_uri: str URL of the ERC721 token.
-        :param erc20_templates: list of templates indexes for deploying ERC20 tokens if deployed_erc20_tokens is None.
-        :param erc20_names: list of names for ERC20 tokens if deployed_erc20_tokens is None.
-        :param erc20_symbols: list of symbols for ERC20 tokens if deployed_erc20_tokens is None.
-        :param erc20_minters: list of minters for ERC20 tokens if deployed_erc20_tokens is None.
-        :param erc20_fee_managers: list of fee managers for ERC20 tokens if deployed_erc20_tokens is None.
-        :param erc20_publish_market_order_fee_addresses: list of publishing market addresses for ERC20 tokens if deployed_erc20_tokens is None.
-        :param erc20_publish_market_order_fee_tokens: list of fee tokens for ERC20 tokens if deployed_erc20_tokens is None.
-        :param erc20_publish_market_order_fee_amounts: list of fee values for ERC20 tokens if deployed_erc20_tokens is None.
-        :param erc20_bytess: list of arrays of bytes for deploying ERC20 tokens, default empty (currently not used, useful for future) if deployed_erc20_tokens is None.
-        :param deployed_erc20_tokens: list of ERC20 tokens which are already deployed.
+        :param erc20_templates: list of templates indexes for deploying ERC20 tokens if deployed_datatokens is None.
+        :param erc20_names: list of names for ERC20 tokens if deployed_datatokens is None.
+        :param erc20_symbols: list of symbols for ERC20 tokens if deployed_datatokens is None.
+        :param erc20_minters: list of minters for ERC20 tokens if deployed_datatokens is None.
+        :param erc20_fee_managers: list of fee managers for ERC20 tokens if deployed_datatokens is None.
+        :param erc20_publish_market_order_fee_addresses: list of publishing market addresses for ERC20 tokens if deployed_datatokens is None.
+        :param erc20_publish_market_order_fee_tokens: list of fee tokens for ERC20 tokens if deployed_datatokens is None.
+        :param erc20_publish_market_order_fee_amounts: list of fee values for ERC20 tokens if deployed_datatokens is None.
+        :param erc20_bytess: list of arrays of bytes for deploying ERC20 tokens, default empty (currently not used, useful for future) if deployed_datatokens is None.
+        :param deployed_datatokens: list of ERC20 tokens which are already deployed.
         :param encrypt_flag: bool for encryption of the DDO.
         :param compress_flag: bool for compression of the DDO.
         :return: DDO instance
@@ -321,8 +319,10 @@ def create(
         if not provider_uri:
             provider_uri = DataServiceProvider.get_url(self._config)
 
-        address = get_address_of_type(self._config, ERC721FactoryContract.CONTRACT_NAME)
-        erc721_factory = ERC721FactoryContract(self._web3, address)
+        address = get_address_of_type(
+            self._config, DataNFTFactoryContract.CONTRACT_NAME
+        )
+        data_nft_factory = DataNFTFactoryContract(self._web3, address)
 
         if not erc721_address:
             name = erc721_name or metadata["name"]
@@ -335,7 +335,7 @@ def create(
             transferable = erc721_transferable or True
             owner = erc721_owner or publisher_wallet.address
             # register on-chain
-            tx_id = erc721_factory.deploy_erc721_contract(
+            tx_id = data_nft_factory.deploy_erc721_contract(
                 name=name,
                 symbol=symbol,
                 template_index=erc721_template_index,
@@ -347,35 +347,37 @@ def create(
                 from_wallet=publisher_wallet,
             )
             tx_receipt = self._web3.eth.wait_for_transaction_receipt(tx_id)
-            registered_event = erc721_factory.get_event_log(
-                ERC721FactoryContract.EVENT_NFT_CREATED,
+            registered_event = data_nft_factory.get_event_log(
+                DataNFTFactoryContract.EVENT_NFT_CREATED,
                 tx_receipt.blockNumber,
                 self._web3.eth.block_number,
                 None,
             )
             erc721_address = registered_event[0].args.newTokenAddress
-            erc721_nft = ERC721NFT(self._web3, erc721_address)
-            if not erc721_nft:
+            data_nft = DataNFT(self._web3, erc721_address)
+            if not data_nft:
                 logger.warning("Creating new NFT failed.")
                 return None
             logger.info(
-                f"Successfully created NFT with address " f"{erc721_nft.address}."
+                f"Successfully created NFT with address " f"{data_nft.address}."
             )
         else:
             # verify nft address
-            if not erc721_factory.verify_nft(erc721_address):
+            if not data_nft_factory.verify_nft(erc721_address):
                 raise ContractNotFound(
-                    f"NFT address {erc721_address} is not found in the ERC721Factory events."
+                    f"NFT address {erc721_address} is not found in the DataNFTFactory events."
                 )
 
         assert erc721_address, "nft_address is required for publishing a dataset asset."
-        erc721_nft = ERC721NFT(self._web3, erc721_address)
+        data_nft = DataNFT(self._web3, erc721_address)
 
         # Create a DDO object
         asset = Asset()
 
         # Generating the did and adding to the ddo.
-        did = f"did:op:{create_checksum(erc721_nft.address + str(self._web3.eth.chain_id))}"
+        did = (
+            f"did:op:{create_checksum(data_nft.address + str(self._web3.eth.chain_id))}"
+        )
         asset.did = did
         # Check if it's already registered first!
         if self._aquarius.ddo_exists(did):
@@ -389,13 +391,13 @@ def create(
 
         erc20_addresses = []
         services = services or []
-        deployed_erc20_tokens = deployed_erc20_tokens or []
-        if not deployed_erc20_tokens:
+        deployed_datatokens = deployed_datatokens or []
+        if not deployed_datatokens:
             for erc20_data_counter in range(len(erc20_templates)):
                 erc20_addresses.append(
                     self.deploy_datatoken(
-                        erc721_factory=erc721_factory,
-                        erc721_nft=erc721_nft,
+                        data_nft_factory=data_nft_factory,
+                        data_nft=data_nft,
                         template_index=erc20_templates[erc20_data_counter],
                         name=erc20_names[erc20_data_counter],
                         symbol=erc20_symbols[erc20_data_counter],
@@ -423,23 +425,21 @@ def create(
                     services = self._add_defaults(
                         services, erc20_address, encrypted_files, provider_uri
                     )
-            for erc20_token_address in erc20_addresses:
-                deployed_erc20_tokens.append(
-                    ERC20Token(self._web3, erc20_token_address)
-                )
+            for datatoken_address in erc20_addresses:
+                deployed_datatokens.append(Datatoken(self._web3, datatoken_address))
 
             datatokens = self.build_datatokens_list(
-                services=services, deployed_erc20_tokens=deployed_erc20_tokens
+                services=services, deployed_datatokens=deployed_datatokens
             )
         else:
             if not services:
-                for erc20_token in deployed_erc20_tokens:
+                for datatoken in deployed_datatokens:
                     services = self._add_defaults(
-                        services, erc20_token.address, encrypted_files, provider_uri
+                        services, datatoken.address, encrypted_files, provider_uri
                     )
 
             datatokens = self.build_datatokens_list(
-                services=services, deployed_erc20_tokens=deployed_erc20_tokens
+                services=services, deployed_datatokens=deployed_datatokens
             )
 
         asset.nft_address = erc721_address
@@ -455,7 +455,7 @@ def create(
             asset, provider_uri, encrypt_flag, compress_flag
         )
 
-        erc721_nft.set_metadata(
+        data_nft.set_metadata(
             metadata_state=0,
             metadata_decryptor_url=provider_uri,
             metadata_decryptor_address=publisher_wallet.address,
@@ -495,18 +495,20 @@ def update(
         if not provider_uri:
             provider_uri = DataServiceProvider.get_url(self._config)
 
-        address = get_address_of_type(self._config, ERC721FactoryContract.CONTRACT_NAME)
-        erc721_factory = ERC721FactoryContract(self._web3, address)
+        address = get_address_of_type(
+            self._config, DataNFTFactoryContract.CONTRACT_NAME
+        )
+        data_nft_factory = DataNFTFactoryContract(self._web3, address)
         erc721_address = asset.nft_address
 
         # Verify nft address
-        if not erc721_factory.verify_nft(erc721_address):
+        if not data_nft_factory.verify_nft(erc721_address):
             raise ContractNotFound(
-                f"NFT address {erc721_address} is not found in the ERC721Factory events."
+                f"NFT address {erc721_address} is not found in the DataNFTFactory events."
             )
 
         assert erc721_address, "nft_address is required for publishing a dataset asset."
-        erc721_nft = ERC721NFT(self._web3, erc721_address)
+        data_nft = DataNFT(self._web3, erc721_address)
 
         assert asset.chain_id == self._web3.eth.chain_id, "Chain id mismatch."
 
@@ -521,7 +523,7 @@ def update(
             asset, provider_uri, encrypt_flag, compress_flag
         )
 
-        tx_result = erc721_nft.set_metadata(
+        tx_result = data_nft.set_metadata(
             metadata_state=0,
             metadata_decryptor_url=provider_uri,
             metadata_decryptor_address=publisher_wallet.address,
@@ -610,7 +612,7 @@ def pay_for_access_service(
         wallet: Wallet,
         consumer_address: Optional[str] = None,
     ):
-        dt = ERC20Token(self._web3, service.datatoken)
+        dt = Datatoken(self._web3, service.datatoken)
         balance = dt.balanceOf(wallet.address)
 
         if not consumer_address:
@@ -730,7 +732,7 @@ def _start_or_reuse_order_based_on_initialize_response(
             return
 
         service = asset_compute_input.service
-        dt = ERC20Token(self._web3, service.datatoken)
+        dt = Datatoken(self._web3, service.datatoken)
 
         if valid_order and provider_fees:
             asset_compute_input.transfer_tx_id = dt.reuse_order(


Test patch:
diff --git a/conftest.py b/conftest.py
index a56dc9cb1..7c75446b7 100644
--- a/conftest.py
+++ b/conftest.py
@@ -7,10 +7,10 @@
 import pytest
 
 from ocean_lib.aquarius.aquarius import Aquarius
-from ocean_lib.models.erc20_enterprise import ERC20Enterprise
-from ocean_lib.models.erc20_token import ERC20Token
-from ocean_lib.models.erc721_factory import ERC721FactoryContract
-from ocean_lib.models.erc721_nft import ERC721NFT
+from ocean_lib.models.data_nft import DataNFT
+from ocean_lib.models.datatoken import Datatoken
+from ocean_lib.models.datatoken_enterprise import DatatokenEnterprise
+from ocean_lib.models.data_nft_factory import DataNFTFactoryContract
 from ocean_lib.models.factory_router import FactoryRouter
 from ocean_lib.models.side_staking import SideStaking
 from ocean_lib.web3_internal.constants import ZERO_ADDRESS
@@ -133,8 +133,8 @@ def ocean_address(config) -> str:
 
 
 @pytest.fixture
-def ocean_token(web3, ocean_address) -> ERC20Token:
-    return ERC20Token(web3, ocean_address)
+def ocean_token(web3, ocean_address) -> Datatoken:
+    return Datatoken(web3, ocean_address)
 
 
 @pytest.fixture
@@ -148,8 +148,8 @@ def side_staking(web3, config):
 
 
 @pytest.fixture
-def erc721_factory(web3, config):
-    return ERC721FactoryContract(web3, get_address_of_type(config, "ERC721Factory"))
+def data_nft_factory(web3, config):
+    return DataNFTFactoryContract(web3, get_address_of_type(config, "ERC721Factory"))
 
 
 @pytest.fixture
@@ -158,8 +158,8 @@ def provider_wallet():
 
 
 @pytest.fixture
-def erc721_nft(web3, publisher_wallet, erc721_factory):
-    tx = erc721_factory.deploy_erc721_contract(
+def data_nft(web3, publisher_wallet, data_nft_factory):
+    tx = data_nft_factory.deploy_erc721_contract(
         name="NFT",
         symbol="NFTSYMBOL",
         template_index=1,
@@ -170,13 +170,13 @@ def erc721_nft(web3, publisher_wallet, erc721_factory):
         owner=publisher_wallet.address,
         from_wallet=publisher_wallet,
     )
-    token_address = erc721_factory.get_token_address(tx)
-    return ERC721NFT(web3, token_address)
+    token_address = data_nft_factory.get_token_address(tx)
+    return DataNFT(web3, token_address)
 
 
 @pytest.fixture
-def erc20_token(web3, erc721_nft, publisher_wallet, erc721_factory):
-    tx_result = erc721_nft.create_erc20(
+def datatoken(web3, data_nft, publisher_wallet, data_nft_factory):
+    tx_result = data_nft.create_erc20(
         template_index=1,
         name="ERC20DT1",
         symbol="ERC20DT1Symbol",
@@ -190,8 +190,8 @@ def erc20_token(web3, erc721_nft, publisher_wallet, erc721_factory):
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx_result)
 
-    registered_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -199,12 +199,12 @@ def erc20_token(web3, erc721_nft, publisher_wallet, erc721_factory):
 
     erc20_address = registered_event[0].args.newTokenAddress
 
-    return ERC20Token(web3, erc20_address)
+    return Datatoken(web3, erc20_address)
 
 
 @pytest.fixture
-def erc20_enterprise_token(web3, erc721_nft, publisher_wallet, erc721_factory):
-    tx_result = erc721_nft.create_erc20(
+def datatoken_enterprise_token(web3, data_nft, publisher_wallet, data_nft_factory):
+    tx_result = data_nft.create_erc20(
         template_index=2,
         name="ERC20DT1",
         symbol="ERC20DT1Symbol",
@@ -219,8 +219,8 @@ def erc20_enterprise_token(web3, erc721_nft, publisher_wallet, erc721_factory):
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx_result)
 
-    registered_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -228,7 +228,7 @@ def erc20_enterprise_token(web3, erc721_nft, publisher_wallet, erc721_factory):
 
     erc20_address = registered_event[0].args.newTokenAddress
 
-    return ERC20Enterprise(web3, erc20_address)
+    return DatatokenEnterprise(web3, erc20_address)
 
 
 @pytest.fixture
diff --git a/ocean_lib/assets/test/test_asset_downloader.py b/ocean_lib/assets/test/test_asset_downloader.py
index f0a9850a7..ca545decd 100644
--- a/ocean_lib/assets/test/test_asset_downloader.py
+++ b/ocean_lib/assets/test/test_asset_downloader.py
@@ -161,8 +161,8 @@ def test_ocean_assets_download_destination_file(
     tmpdir,
     publisher_wallet,
     publisher_ocean_instance,
-    erc721_nft,
-    erc20_token,
+    data_nft,
+    datatoken,
 ):
     """Convert tmpdir: py._path.local.LocalPath to str, satisfy enforce-typing."""
     ocean_assets_download_destination_file_helper(
@@ -171,8 +171,8 @@ def test_ocean_assets_download_destination_file(
         str(tmpdir),
         publisher_wallet,
         publisher_ocean_instance,
-        erc721_nft,
-        erc20_token,
+        data_nft,
+        datatoken,
     )
 
 
@@ -182,8 +182,8 @@ def ocean_assets_download_destination_file_helper(
     tmpdir,
     publisher_wallet,
     publisher_ocean_instance,
-    erc721_nft,
-    erc20_token,
+    data_nft,
+    datatoken,
 ):
     """Downloading to an existing directory."""
     data_provider = DataServiceProvider
@@ -193,12 +193,12 @@ def ocean_assets_download_destination_file_helper(
         metadata=metadata,
         publisher_wallet=publisher_wallet,
         encrypted_files=encrypted_files,
-        erc721_address=erc721_nft.address,
-        deployed_erc20_tokens=[erc20_token],
+        erc721_address=data_nft.address,
+        deployed_datatokens=[datatoken],
     )
     access_service = get_first_service_by_type(ddo, ServiceTypes.ASSET_ACCESS)
 
-    erc20_token.mint(
+    datatoken.mint(
         account_address=publisher_wallet.address,
         value=to_wei("50"),
         from_wallet=publisher_wallet,
@@ -212,7 +212,7 @@ def ocean_assets_download_destination_file_helper(
 
     provider_fees = initialize_response.json()["providerFee"]
 
-    tx_id = erc20_token.start_order(
+    tx_id = datatoken.start_order(
         consumer=publisher_wallet.address,
         service_index=ddo.get_index_of_service(access_service),
         provider_fee_address=provider_fees["providerFeeAddress"],
@@ -224,13 +224,13 @@ def ocean_assets_download_destination_file_helper(
         valid_until=provider_fees["validUntil"],
         provider_data=provider_fees["providerData"],
         consume_market_order_fee_address=publisher_wallet.address,
-        consume_market_order_fee_token=erc20_token.address,
+        consume_market_order_fee_token=datatoken.address,
         consume_market_order_fee_amount=0,
         from_wallet=publisher_wallet,
     )
 
     orders = publisher_ocean_instance.get_user_orders(publisher_wallet.address)
-    assert erc20_token.address in [order.address for order in orders]
+    assert datatoken.address in [order.address for order in orders]
     assert tx_id in [order.transactionHash.hex() for order in orders]
 
     written_path = download_asset_files(
diff --git a/ocean_lib/data_provider/test/test_data_service_provider.py b/ocean_lib/data_provider/test/test_data_service_provider.py
index 86242c486..5fb39c1af 100644
--- a/ocean_lib/data_provider/test/test_data_service_provider.py
+++ b/ocean_lib/data_provider/test/test_data_service_provider.py
@@ -228,7 +228,7 @@ def test_encrypt(web3, config, provider_wallet, file1, file2):
 
 @pytest.mark.integration
 def test_fileinfo(
-    web3, config, publisher_wallet, publisher_ocean_instance, erc721_nft, erc20_token
+    web3, config, publisher_wallet, publisher_ocean_instance, data_nft, datatoken
 ):
     _, metadata, encrypted_files = create_basics(config, web3, DataSP)
 
@@ -236,8 +236,8 @@ def test_fileinfo(
         metadata=metadata,
         publisher_wallet=publisher_wallet,
         encrypted_files=encrypted_files,
-        erc721_address=erc721_nft.address,
-        deployed_erc20_tokens=[erc20_token],
+        erc721_address=data_nft.address,
+        deployed_datatokens=[datatoken],
     )
     access_service = get_first_service_by_type(ddo, ServiceTypes.ASSET_ACCESS)
 
@@ -259,16 +259,16 @@ def test_initialize(
     publisher_wallet,
     publisher_ocean_instance,
     provider_wallet,
-    erc721_nft,
-    erc20_token,
+    data_nft,
+    datatoken,
 ):
     _, metadata, encrypted_files = create_basics(config, web3, DataSP)
     ddo = publisher_ocean_instance.assets.create(
         metadata=metadata,
         publisher_wallet=publisher_wallet,
         encrypted_files=encrypted_files,
-        erc721_address=erc721_nft.address,
-        deployed_erc20_tokens=[erc20_token],
+        erc721_address=data_nft.address,
+        deployed_datatokens=[datatoken],
     )
     access_service = get_first_service_by_type(ddo, ServiceTypes.ASSET_ACCESS)
 
diff --git a/ocean_lib/models/test/conftest.py b/ocean_lib/models/test/conftest.py
index b70e5e38b..4e0c1a0f1 100644
--- a/ocean_lib/models/test/conftest.py
+++ b/ocean_lib/models/test/conftest.py
@@ -7,7 +7,7 @@
 import pytest
 
 from ocean_lib.example_config import ExampleConfig
-from ocean_lib.models.erc721_factory import ERC721FactoryContract
+from ocean_lib.models.data_nft_factory import DataNFTFactoryContract
 from ocean_lib.ocean.util import get_ocean_token_address
 from ocean_lib.web3_internal.currency import to_wei
 from ocean_lib.web3_internal.transactions import send_ether
@@ -28,7 +28,7 @@ def network():
 
 @pytest.fixture
 def nft_factory_address(config):
-    return ERC721FactoryContract.configured_address(_NETWORK, config.address_file)
+    return DataNFTFactoryContract.configured_address(_NETWORK, config.address_file)
 
 
 @pytest.fixture
diff --git a/ocean_lib/models/test/test_erc721_token.py b/ocean_lib/models/test/test_data_nft.py
similarity index 70%
rename from ocean_lib/models/test/test_erc721_token.py
rename to ocean_lib/models/test/test_data_nft.py
index b13752bf1..5e008d0f5 100644
--- a/ocean_lib/models/test/test_erc721_token.py
+++ b/ocean_lib/models/test/test_data_nft.py
@@ -7,9 +7,9 @@
 
 from ocean_lib.config import Config
 from ocean_lib.models.bpool import BPool
-from ocean_lib.models.erc20_token import ERC20Token
-from ocean_lib.models.erc721_factory import ERC721FactoryContract
-from ocean_lib.models.erc721_nft import ERC721NFT, ERC721Permissions
+from ocean_lib.models.data_nft import DataNFT, DataNFTPermissions
+from ocean_lib.models.data_nft_factory import DataNFTFactoryContract
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.models.fixed_rate_exchange import (
     FixedRateExchange,
     FixedRateExchangeDetails,
@@ -24,24 +24,17 @@
 @pytest.mark.unit
 def test_properties(web3, config):
     """Tests the events' properties."""
-    erc721_token_address = get_address_of_type(
-        config=config, address_type=ERC721NFT.CONTRACT_NAME
+    data_nft_token_address = get_address_of_type(
+        config=config, address_type=DataNFT.CONTRACT_NAME
     )
-    erc721_nft = ERC721NFT(web3=web3, address=erc721_token_address)
+    data_nft = DataNFT(web3=web3, address=data_nft_token_address)
 
-    assert erc721_nft.event_TokenCreated.abi["name"] == ERC721NFT.EVENT_TOKEN_CREATED
+    assert data_nft.event_TokenCreated.abi["name"] == DataNFT.EVENT_TOKEN_CREATED
+    assert data_nft.event_TokenURIUpdate.abi["name"] == DataNFT.EVENT_TOKEN_URI_UPDATED
+    assert data_nft.event_MetadataCreated.abi["name"] == DataNFT.EVENT_METADATA_CREATED
+    assert data_nft.event_MetadataUpdated.abi["name"] == DataNFT.EVENT_METADATA_UPDATED
     assert (
-        erc721_nft.event_TokenURIUpdate.abi["name"] == ERC721NFT.EVENT_TOKEN_URI_UPDATED
-    )
-    assert (
-        erc721_nft.event_MetadataCreated.abi["name"] == ERC721NFT.EVENT_METADATA_CREATED
-    )
-    assert (
-        erc721_nft.event_MetadataUpdated.abi["name"] == ERC721NFT.EVENT_METADATA_UPDATED
-    )
-    assert (
-        erc721_nft.event_MetadataValidated.abi["name"]
-        == ERC721NFT.EVENT_METADATA_VALIDATED
+        data_nft.event_MetadataValidated.abi["name"] == DataNFT.EVENT_METADATA_VALIDATED
     )
 
 
@@ -54,73 +47,75 @@ def test_permissions(
     publisher_addr,
     consumer_addr,
     another_consumer_addr,
-    erc721_nft,
+    data_nft,
 ):
     """Tests permissions' functions."""
-    assert erc721_nft.contract.caller.name() == "NFT"
-    assert erc721_nft.symbol() == "NFTSYMBOL"
-    assert erc721_nft.balance_of(account=publisher_addr) == 1
+    assert data_nft.contract.caller.name() == "NFT"
+    assert data_nft.symbol() == "NFTSYMBOL"
+    assert data_nft.balance_of(account=publisher_addr) == 1
 
     # Tests if the NFT was initialized
-    assert erc721_nft.is_initialized()
+    assert data_nft.is_initialized()
 
     # Tests adding a manager successfully
-    erc721_nft.add_manager(manager_address=consumer_addr, from_wallet=publisher_wallet)
-    assert erc721_nft.get_permissions(user=consumer_addr)[ERC721Permissions.MANAGER]
+    data_nft.add_manager(manager_address=consumer_addr, from_wallet=publisher_wallet)
+    assert data_nft.get_permissions(user=consumer_addr)[DataNFTPermissions.MANAGER]
 
-    assert erc721_nft.token_uri(1) == "https://oceanprotocol.com/nft/"
+    assert data_nft.token_uri(1) == "https://oceanprotocol.com/nft/"
 
     # Tests failing clearing permissions
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.clean_permissions(from_wallet=another_consumer_wallet)
+        data_nft.clean_permissions(from_wallet=another_consumer_wallet)
     assert (
         err.value.args[0]
         == "execution reverted: VM Exception while processing transaction: revert ERC721Template: not NFTOwner"
     )
 
     # Tests clearing permissions
-    erc721_nft.add_to_create_erc20_list(
+    data_nft.add_to_create_erc20_list(
         allowed_address=publisher_addr, from_wallet=publisher_wallet
     )
-    erc721_nft.add_to_create_erc20_list(
+    data_nft.add_to_create_erc20_list(
         allowed_address=another_consumer_addr, from_wallet=publisher_wallet
     )
-    assert erc721_nft.get_permissions(user=publisher_addr)[
-        ERC721Permissions.DEPLOY_ERC20
+    assert data_nft.get_permissions(user=publisher_addr)[
+        DataNFTPermissions.DEPLOY_DATATOKEN
     ]
-    assert erc721_nft.get_permissions(user=another_consumer_addr)[
-        ERC721Permissions.DEPLOY_ERC20
+    assert data_nft.get_permissions(user=another_consumer_addr)[
+        DataNFTPermissions.DEPLOY_DATATOKEN
     ]
     # Still is not the NFT owner, cannot clear permissions then
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.clean_permissions(from_wallet=another_consumer_wallet)
+        data_nft.clean_permissions(from_wallet=another_consumer_wallet)
     assert (
         err.value.args[0]
         == "execution reverted: VM Exception while processing transaction: revert ERC721Template: not NFTOwner"
     )
 
-    erc721_nft.clean_permissions(from_wallet=publisher_wallet)
+    data_nft.clean_permissions(from_wallet=publisher_wallet)
 
     assert not (
-        erc721_nft.get_permissions(user=publisher_addr)[ERC721Permissions.DEPLOY_ERC20]
+        data_nft.get_permissions(user=publisher_addr)[
+            DataNFTPermissions.DEPLOY_DATATOKEN
+        ]
     )
     assert not (
-        erc721_nft.get_permissions(user=consumer_addr)[ERC721Permissions.MANAGER]
+        data_nft.get_permissions(user=consumer_addr)[DataNFTPermissions.MANAGER]
     )
     assert not (
-        erc721_nft.get_permissions(user=another_consumer_addr)[
-            ERC721Permissions.DEPLOY_ERC20
+        data_nft.get_permissions(user=another_consumer_addr)[
+            DataNFTPermissions.DEPLOY_DATATOKEN
         ]
     )
 
     # Tests failing adding a new manager by another user different from the NFT owner
-    erc721_nft.add_manager(manager_address=publisher_addr, from_wallet=publisher_wallet)
-    assert erc721_nft.get_permissions(user=publisher_addr)[ERC721Permissions.MANAGER]
+    data_nft.add_manager(manager_address=publisher_addr, from_wallet=publisher_wallet)
+    assert data_nft.get_permissions(user=publisher_addr)[DataNFTPermissions.MANAGER]
     assert not (
-        erc721_nft.get_permissions(user=consumer_addr)[ERC721Permissions.MANAGER]
+        data_nft.get_permissions(user=consumer_addr)[DataNFTPermissions.MANAGER]
     )
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.add_manager(
+        data_nft.add_manager(
             manager_address=another_consumer_addr, from_wallet=consumer_wallet
         )
     assert (
@@ -128,52 +123,46 @@ def test_permissions(
         == "execution reverted: VM Exception while processing transaction: revert ERC721Template: not NFTOwner"
     )
     assert not (
-        erc721_nft.get_permissions(user=another_consumer_addr)[
-            ERC721Permissions.MANAGER
-        ]
+        data_nft.get_permissions(user=another_consumer_addr)[DataNFTPermissions.MANAGER]
     )
 
     # Tests removing manager
-    erc721_nft.add_manager(manager_address=consumer_addr, from_wallet=publisher_wallet)
-    assert erc721_nft.get_permissions(user=consumer_addr)[ERC721Permissions.MANAGER]
-    erc721_nft.remove_manager(
-        manager_address=consumer_addr, from_wallet=publisher_wallet
-    )
+    data_nft.add_manager(manager_address=consumer_addr, from_wallet=publisher_wallet)
+    assert data_nft.get_permissions(user=consumer_addr)[DataNFTPermissions.MANAGER]
+    data_nft.remove_manager(manager_address=consumer_addr, from_wallet=publisher_wallet)
     assert not (
-        erc721_nft.get_permissions(user=consumer_addr)[ERC721Permissions.MANAGER]
+        data_nft.get_permissions(user=consumer_addr)[DataNFTPermissions.MANAGER]
     )
 
     # Tests failing removing a manager if it has not the NFT owner role
-    erc721_nft.add_manager(manager_address=consumer_addr, from_wallet=publisher_wallet)
-    assert erc721_nft.get_permissions(user=consumer_addr)[ERC721Permissions.MANAGER]
+    data_nft.add_manager(manager_address=consumer_addr, from_wallet=publisher_wallet)
+    assert data_nft.get_permissions(user=consumer_addr)[DataNFTPermissions.MANAGER]
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.remove_manager(
+        data_nft.remove_manager(
             manager_address=publisher_addr, from_wallet=consumer_wallet
         )
     assert (
         err.value.args[0]
         == "execution reverted: VM Exception while processing transaction: revert ERC721Template: not NFTOwner"
     )
-    assert erc721_nft.get_permissions(user=publisher_addr)[ERC721Permissions.MANAGER]
+    assert data_nft.get_permissions(user=publisher_addr)[DataNFTPermissions.MANAGER]
 
     # Tests removing the NFT owner from the manager role
-    erc721_nft.remove_manager(
+    data_nft.remove_manager(
         manager_address=publisher_addr, from_wallet=publisher_wallet
     )
     assert not (
-        erc721_nft.get_permissions(user=publisher_addr)[ERC721Permissions.MANAGER]
+        data_nft.get_permissions(user=publisher_addr)[DataNFTPermissions.MANAGER]
     )
-    erc721_nft.add_manager(manager_address=publisher_addr, from_wallet=publisher_wallet)
-    assert erc721_nft.get_permissions(user=publisher_addr)[ERC721Permissions.MANAGER]
+    data_nft.add_manager(manager_address=publisher_addr, from_wallet=publisher_wallet)
+    assert data_nft.get_permissions(user=publisher_addr)[DataNFTPermissions.MANAGER]
 
     # Tests failing calling execute_call function if the user is not manager
     assert not (
-        erc721_nft.get_permissions(user=another_consumer_addr)[
-            ERC721Permissions.MANAGER
-        ]
+        data_nft.get_permissions(user=another_consumer_addr)[DataNFTPermissions.MANAGER]
     )
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.execute_call(
+        data_nft.execute_call(
             operation=0,
             to=consumer_addr,
             value=10,
@@ -186,8 +175,8 @@ def test_permissions(
     )
 
     # Tests calling execute_call with a manager role
-    assert erc721_nft.get_permissions(user=publisher_addr)[ERC721Permissions.MANAGER]
-    tx = erc721_nft.execute_call(
+    assert data_nft.get_permissions(user=publisher_addr)[DataNFTPermissions.MANAGER]
+    tx = data_nft.execute_call(
         operation=0,
         to=consumer_addr,
         value=10,
@@ -197,23 +186,23 @@ def test_permissions(
     assert tx, "Could not execute call to consumer."
 
     # Tests setting new data
-    erc721_nft.add_to_725_store_list(
+    data_nft.add_to_725_store_list(
         allowed_address=consumer_addr, from_wallet=publisher_wallet
     )
-    assert erc721_nft.get_permissions(user=consumer_addr)[ERC721Permissions.STORE]
-    erc721_nft.set_new_data(
+    assert data_nft.get_permissions(user=consumer_addr)[DataNFTPermissions.STORE]
+    data_nft.set_new_data(
         key=web3.keccak(text="ARBITRARY_KEY"),
         value=web3.toHex(text="SomeData"),
         from_wallet=consumer_wallet,
     )
-    assert erc721_nft.get_data(key=web3.keccak(text="ARBITRARY_KEY")) == b"SomeData"
+    assert data_nft.get_data(key=web3.keccak(text="ARBITRARY_KEY")) == b"SomeData"
 
     # Tests failing setting new data if user has not STORE UPDATER role.
     assert not (
-        erc721_nft.get_permissions(user=another_consumer_addr)[ERC721Permissions.STORE]
+        data_nft.get_permissions(user=another_consumer_addr)[DataNFTPermissions.STORE]
     )
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.set_new_data(
+        data_nft.set_new_data(
             key=web3.keccak(text="ARBITRARY_KEY"),
             value=web3.toHex(text="SomeData"),
             from_wallet=another_consumer_wallet,
@@ -226,7 +215,7 @@ def test_permissions(
 
     # Tests failing setting ERC20 data
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.set_data_erc20(
+        data_nft.set_data_erc20(
             key=web3.keccak(text="FOO_KEY"),
             value=web3.toHex(text="SomeData"),
             from_wallet=consumer_wallet,
@@ -235,44 +224,44 @@ def test_permissions(
         err.value.args[0]
         == "execution reverted: VM Exception while processing transaction: revert ERC721Template: NOT ERC20 Contract"
     )
-    assert erc721_nft.get_data(key=web3.keccak(text="FOO_KEY")) == b""
+    assert data_nft.get_data(key=web3.keccak(text="FOO_KEY")) == b""
 
 
 def test_add_and_remove_permissions(
-    publisher_wallet: Wallet, consumer_wallet: Wallet, erc721_nft: ERC721NFT
+    publisher_wallet: Wallet, consumer_wallet: Wallet, data_nft: DataNFT
 ):
     # Assert consumer has no permissions
-    permissions = erc721_nft.get_permissions(consumer_wallet.address)
-    assert not permissions[ERC721Permissions.MANAGER]
-    assert not permissions[ERC721Permissions.DEPLOY_ERC20]
-    assert not permissions[ERC721Permissions.UPDATE_METADATA]
-    assert not permissions[ERC721Permissions.STORE]
+    permissions = data_nft.get_permissions(consumer_wallet.address)
+    assert not permissions[DataNFTPermissions.MANAGER]
+    assert not permissions[DataNFTPermissions.DEPLOY_DATATOKEN]
+    assert not permissions[DataNFTPermissions.UPDATE_METADATA]
+    assert not permissions[DataNFTPermissions.STORE]
 
     # Grant consumer all permissions, one by one
-    erc721_nft.add_manager(consumer_wallet.address, publisher_wallet)
-    erc721_nft.add_to_create_erc20_list(consumer_wallet.address, publisher_wallet)
-    erc721_nft.add_to_metadata_list(consumer_wallet.address, publisher_wallet)
-    erc721_nft.add_to_725_store_list(consumer_wallet.address, publisher_wallet)
+    data_nft.add_manager(consumer_wallet.address, publisher_wallet)
+    data_nft.add_to_create_erc20_list(consumer_wallet.address, publisher_wallet)
+    data_nft.add_to_metadata_list(consumer_wallet.address, publisher_wallet)
+    data_nft.add_to_725_store_list(consumer_wallet.address, publisher_wallet)
 
     # Assert consumer has all permissions
-    permissions = erc721_nft.get_permissions(consumer_wallet.address)
-    assert permissions[ERC721Permissions.MANAGER]
-    assert permissions[ERC721Permissions.DEPLOY_ERC20]
-    assert permissions[ERC721Permissions.UPDATE_METADATA]
-    assert permissions[ERC721Permissions.STORE]
+    permissions = data_nft.get_permissions(consumer_wallet.address)
+    assert permissions[DataNFTPermissions.MANAGER]
+    assert permissions[DataNFTPermissions.DEPLOY_DATATOKEN]
+    assert permissions[DataNFTPermissions.UPDATE_METADATA]
+    assert permissions[DataNFTPermissions.STORE]
 
     # Revoke all consumer permissions, one by one
-    erc721_nft.remove_manager(consumer_wallet.address, publisher_wallet)
-    erc721_nft.remove_from_create_erc20_list(consumer_wallet.address, publisher_wallet)
-    erc721_nft.remove_from_metadata_list(consumer_wallet.address, publisher_wallet)
-    erc721_nft.remove_from_725_store_list(consumer_wallet.address, publisher_wallet)
+    data_nft.remove_manager(consumer_wallet.address, publisher_wallet)
+    data_nft.remove_from_create_erc20_list(consumer_wallet.address, publisher_wallet)
+    data_nft.remove_from_metadata_list(consumer_wallet.address, publisher_wallet)
+    data_nft.remove_from_725_store_list(consumer_wallet.address, publisher_wallet)
 
     # Assert consumer has no permissions
-    permissions = erc721_nft.get_permissions(consumer_wallet.address)
-    assert not permissions[ERC721Permissions.MANAGER]
-    assert not permissions[ERC721Permissions.DEPLOY_ERC20]
-    assert not permissions[ERC721Permissions.UPDATE_METADATA]
-    assert not permissions[ERC721Permissions.STORE]
+    permissions = data_nft.get_permissions(consumer_wallet.address)
+    assert not permissions[DataNFTPermissions.MANAGER]
+    assert not permissions[DataNFTPermissions.DEPLOY_DATATOKEN]
+    assert not permissions[DataNFTPermissions.UPDATE_METADATA]
+    assert not permissions[DataNFTPermissions.STORE]
 
 
 @pytest.mark.unit
@@ -282,21 +271,19 @@ def test_success_update_metadata(
     consumer_wallet: Wallet,
     publisher_addr: str,
     consumer_addr: str,
-    erc721_nft: ERC721NFT,
+    data_nft: DataNFT,
 ):
     """Tests updating the metadata flow."""
     assert not (
-        erc721_nft.get_permissions(user=consumer_addr)[
-            ERC721Permissions.UPDATE_METADATA
-        ]
+        data_nft.get_permissions(user=consumer_addr)[DataNFTPermissions.UPDATE_METADATA]
     )
-    erc721_nft.add_to_metadata_list(
+    data_nft.add_to_metadata_list(
         allowed_address=consumer_addr, from_wallet=publisher_wallet
     )
-    metadata_info = erc721_nft.get_metadata()
+    metadata_info = data_nft.get_metadata()
     assert not metadata_info[3]
 
-    tx = erc721_nft.set_metadata(
+    tx = data_nft.set_metadata(
         metadata_state=1,
         metadata_decryptor_url="http://myprovider:8030",
         metadata_decryptor_address="0x123",
@@ -307,7 +294,7 @@ def test_success_update_metadata(
         from_wallet=consumer_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    create_metadata_event = erc721_nft.get_event_log(
+    create_metadata_event = data_nft.get_event_log(
         event_name="MetadataCreated",
         from_block=tx_receipt.blockNumber,
         to_block=web3.eth.block_number,
@@ -316,11 +303,11 @@ def test_success_update_metadata(
     assert create_metadata_event, "Cannot find MetadataCreated event."
     assert create_metadata_event[0].args.decryptorUrl == "http://myprovider:8030"
 
-    metadata_info = erc721_nft.get_metadata()
+    metadata_info = data_nft.get_metadata()
     assert metadata_info[3]
     assert metadata_info[0] == "http://myprovider:8030"
 
-    tx = erc721_nft.set_metadata(
+    tx = data_nft.set_metadata(
         metadata_state=1,
         metadata_decryptor_url="http://foourl",
         metadata_decryptor_address="0x123",
@@ -331,7 +318,7 @@ def test_success_update_metadata(
         from_wallet=consumer_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    update_metadata_event = erc721_nft.get_event_log(
+    update_metadata_event = data_nft.get_event_log(
         event_name="MetadataUpdated",
         from_block=tx_receipt.blockNumber,
         to_block=web3.eth.block_number,
@@ -340,12 +327,12 @@ def test_success_update_metadata(
     assert update_metadata_event, "Cannot find MetadataUpdated event."
     assert update_metadata_event[0].args.decryptorUrl == "http://foourl"
 
-    metadata_info = erc721_nft.get_metadata()
+    metadata_info = data_nft.get_metadata()
     assert metadata_info[3]
     assert metadata_info[0] == "http://foourl"
 
     # Update tokenURI and set metadata in one call
-    tx = erc721_nft.set_metadata_token_uri(
+    tx = data_nft.set_metadata_token_uri(
         metadata_state=1,
         metadata_decryptor_url="http://foourl",
         metadata_decryptor_address="0x123",
@@ -359,7 +346,7 @@ def test_success_update_metadata(
     )
 
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    update_token_uri_event = erc721_nft.get_event_log(
+    update_token_uri_event = data_nft.get_event_log(
         event_name="TokenURIUpdate",
         from_block=tx_receipt.blockNumber,
         to_block=web3.eth.block_number,
@@ -369,7 +356,7 @@ def test_success_update_metadata(
     assert update_token_uri_event[0].args.tokenURI == "https://anothernewurl.com/nft/"
     assert update_token_uri_event[0].args.updatedBy == publisher_addr
 
-    update_metadata_event = erc721_nft.get_event_log(
+    update_metadata_event = data_nft.get_event_log(
         event_name="MetadataUpdated",
         from_block=tx_receipt.blockNumber,
         to_block=web3.eth.block_number,
@@ -379,27 +366,25 @@ def test_success_update_metadata(
     assert update_metadata_event, "Cannot find MetadataUpdated event."
     assert update_metadata_event[0].args.decryptorUrl == "http://foourl"
 
-    metadata_info = erc721_nft.get_metadata()
+    metadata_info = data_nft.get_metadata()
     assert metadata_info[3]
     assert metadata_info[0] == "http://foourl"
 
     # Consumer self-revokes permission to update metadata
-    erc721_nft.remove_from_metadata_list(consumer_wallet.address, consumer_wallet)
-    assert not erc721_nft.get_permissions(consumer_wallet.address)[
-        ERC721Permissions.UPDATE_METADATA
+    data_nft.remove_from_metadata_list(consumer_wallet.address, consumer_wallet)
+    assert not data_nft.get_permissions(consumer_wallet.address)[
+        DataNFTPermissions.UPDATE_METADATA
     ]
 
 
-def test_fails_update_metadata(web3, consumer_wallet, consumer_addr, erc721_nft):
+def test_fails_update_metadata(web3, consumer_wallet, consumer_addr, data_nft):
     """Tests failure of calling update metadata function when the role of the user is not METADATA UPDATER."""
     assert not (
-        erc721_nft.get_permissions(user=consumer_addr)[
-            ERC721Permissions.UPDATE_METADATA
-        ]
+        data_nft.get_permissions(user=consumer_addr)[DataNFTPermissions.UPDATE_METADATA]
     )
 
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.set_metadata(
+        data_nft.set_metadata(
             metadata_state=1,
             metadata_decryptor_url="http://myprovider:8030",
             metadata_decryptor_address="0x123",
@@ -422,15 +407,15 @@ def test_create_erc20(
     publisher_wallet: Wallet,
     publisher_addr,
     consumer_addr,
-    erc721_nft: ERC721NFT,
-    erc721_factory: ERC721FactoryContract,
+    data_nft: DataNFT,
+    data_nft_factory: DataNFTFactoryContract,
 ):
     """Tests calling create an ERC20 by the owner."""
-    assert erc721_nft.get_permissions(user=publisher_addr)[
-        ERC721Permissions.DEPLOY_ERC20
+    assert data_nft.get_permissions(user=publisher_addr)[
+        DataNFTPermissions.DEPLOY_DATATOKEN
     ]
 
-    tx = erc721_nft.create_erc20(
+    tx = data_nft.create_erc20(
         template_index=1,
         name="ERC20DT1",
         symbol="ERC20DT1Symbol",
@@ -445,19 +430,19 @@ def test_create_erc20(
     assert tx, "Could not create ERC20."
 
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_token_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_token_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
     )
     assert registered_token_event, "Cannot find TokenCreated event."
 
-    with pytest.raises(Exception, match="Cap is needed for ERC20 Enterprise"):
-        erc721_nft.create_erc20(
+    with pytest.raises(Exception, match="Cap is needed for Datatoken Enterprise"):
+        data_nft.create_erc20(
             template_index=2,
-            name="ERC20EnterpriseDT1",
-            symbol="ERC20EenterpriseDT1Symbol",
+            name="DatatokenEnterpriseDT1",
+            symbol="DatatokenEnterpriseDT1Symbol",
             minter=publisher_addr,
             fee_manager=consumer_addr,
             publish_market_order_fee_address=publisher_addr,
@@ -467,18 +452,18 @@ def test_create_erc20(
             from_wallet=publisher_wallet,
         )
 
-    with pytest.raises(Exception, match="Cap is needed for ERC20 Enterprise"):
-        erc721_nft.create_datatoken(
+    with pytest.raises(Exception, match="Cap is needed for Datatoken Enterprise"):
+        data_nft.create_datatoken(
             template_index=2,
-            name="ERC20EnterpriseDT1",
-            symbol="ERC20EenterpriseDT1Symbol",
+            name="DatatokenEnterpriseDT1",
+            symbol="DatattokenEnterpriseDT1Symbol",
             from_wallet=publisher_wallet,
         )
 
-    tx = erc721_nft.create_erc20(
+    tx = data_nft.create_erc20(
         template_index=2,
-        name="ERC20EnterpriseDT1",
-        symbol="ERC20EnterpriseDT1Symbol",
+        name="DatatokenEnterpriseDT1",
+        symbol="DatatokenEnterpriseDT1Symbol",
         minter=publisher_addr,
         fee_manager=consumer_addr,
         publish_market_order_fee_address=publisher_addr,
@@ -488,29 +473,29 @@ def test_create_erc20(
         from_wallet=publisher_wallet,
         datatoken_cap=to_wei("0.1"),
     )
-    assert tx, "Could not create ERC20 Enterprise."
+    assert tx, "Could not create datatoken Enterprise."
 
-    tx = erc721_nft.create_datatoken(
+    tx = data_nft.create_datatoken(
         template_index=2,
-        name="ERC20EnterpriseDT1",
-        symbol="ERC20EenterpriseDT1Symbol",
+        name="DatatokenEnterpriseDT1",
+        symbol="DatatokenEnterpriseDT1Symbol",
         datatoken_cap=to_wei("0.1"),
         from_wallet=publisher_wallet,
     )
-    assert tx, "Could not create ERC20 Enterprise using create_datatoken."
+    assert tx, "Could not create datatoken Enterprise using create_datatoken."
 
 
 def test_create_erc20_with_usdc_order_fee(
     web3: Web3,
     config: Config,
     publisher_wallet: Wallet,
-    erc721_nft: ERC721NFT,
-    erc721_factory: ERC721FactoryContract,
+    data_nft: DataNFT,
+    data_nft_factory: DataNFTFactoryContract,
 ):
     """Create an ERC20 with order fees ( 5 USDC, going to publishMarketAddress)"""
-    usdc = ERC20Token(web3, get_address_of_type(config, "MockUSDC"))
+    usdc = Datatoken(web3, get_address_of_type(config, "MockUSDC"))
     publish_market_order_fee_amount_in_wei = to_wei(5)
-    tx = erc721_nft.create_erc20(
+    tx = data_nft.create_erc20(
         template_index=1,
         name="ERC20DT1",
         symbol="ERC20DT1Symbol",
@@ -524,15 +509,15 @@ def test_create_erc20_with_usdc_order_fee(
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
 
-    event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
     )
 
     erc20_address = event[0].args.newTokenAddress
-    erc20 = ERC20Token(web3, erc20_address)
+    erc20 = Datatoken(web3, erc20_address)
 
     # Check publish fee info
     (
@@ -550,24 +535,24 @@ def test_create_erc20_with_non_owner(
     web3: Web3,
     publisher_wallet: Wallet,
     consumer_wallet: Wallet,
-    erc721_nft: ERC721NFT,
-    erc721_factory: ERC721FactoryContract,
+    data_nft: DataNFT,
+    data_nft_factory: DataNFTFactoryContract,
 ):
     """Tests creating an ERC20 token by wallet other than nft owner"""
 
     # Assert consumer cannot create ERC20
-    assert not erc721_nft.get_permissions(consumer_wallet.address)[
-        ERC721Permissions.DEPLOY_ERC20
+    assert not data_nft.get_permissions(consumer_wallet.address)[
+        DataNFTPermissions.DEPLOY_DATATOKEN
     ]
 
     # Grant consumer permission to create ERC20
-    erc721_nft.add_to_create_erc20_list(consumer_wallet.address, publisher_wallet)
-    assert erc721_nft.get_permissions(consumer_wallet.address)[
-        ERC721Permissions.DEPLOY_ERC20
+    data_nft.add_to_create_erc20_list(consumer_wallet.address, publisher_wallet)
+    assert data_nft.get_permissions(consumer_wallet.address)[
+        DataNFTPermissions.DEPLOY_DATATOKEN
     ]
 
     # Consumer creates ERC20
-    tx = erc721_nft.create_erc20(
+    tx = data_nft.create_erc20(
         template_index=1,
         name="ERC20DT1",
         symbol="ERC20DT1Symbol",
@@ -582,8 +567,8 @@ def test_create_erc20_with_non_owner(
     assert tx, "Failed to create ERC20 token."
 
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_token_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_token_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -591,22 +576,20 @@ def test_create_erc20_with_non_owner(
     assert registered_token_event, "Cannot find TokenCreated event."
 
     # Consumer self-revokes permission to create ERC20
-    erc721_nft.remove_from_create_erc20_list(consumer_wallet.address, consumer_wallet)
-    assert not erc721_nft.get_permissions(consumer_wallet.address)[
-        ERC721Permissions.DEPLOY_ERC20
+    data_nft.remove_from_create_erc20_list(consumer_wallet.address, consumer_wallet)
+    assert not data_nft.get_permissions(consumer_wallet.address)[
+        DataNFTPermissions.DEPLOY_DATATOKEN
     ]
 
 
 @pytest.mark.unit
-def test_fail_creating_erc20(
-    consumer_wallet, publisher_addr, consumer_addr, erc721_nft
-):
+def test_fail_creating_erc20(consumer_wallet, publisher_addr, consumer_addr, data_nft):
     """Tests failure for creating ERC20 token."""
     assert not (
-        erc721_nft.get_permissions(consumer_addr)[ERC721Permissions.DEPLOY_ERC20]
+        data_nft.get_permissions(consumer_addr)[DataNFTPermissions.DEPLOY_DATATOKEN]
     )
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.create_erc20(
+        data_nft.create_erc20(
             template_index=1,
             name="ERC20DT1",
             symbol="ERC20DT1Symbol",
@@ -632,23 +615,23 @@ def test_erc721_datatoken_functions(
     consumer_wallet,
     publisher_addr,
     consumer_addr,
-    erc721_nft,
-    erc20_token,
+    data_nft,
+    datatoken,
 ):
     """Tests ERC721 Template functions for ERC20 tokens."""
-    assert len(erc721_nft.get_tokens_list()) == 1
-    assert erc721_nft.is_deployed(datatoken=erc20_token.address)
+    assert len(data_nft.get_tokens_list()) == 1
+    assert data_nft.is_deployed(datatoken=datatoken.address)
 
-    assert not erc721_nft.is_deployed(datatoken=consumer_addr)
-    tx = erc721_nft.set_token_uri(
+    assert not data_nft.is_deployed(datatoken=consumer_addr)
+    tx = data_nft.set_token_uri(
         token_id=1,
         new_token_uri="https://newurl.com/nft/",
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
     assert tx_receipt.status == 1
-    registered_event = erc721_nft.get_event_log(
-        event_name=ERC721NFT.EVENT_TOKEN_URI_UPDATED,
+    registered_event = data_nft.get_event_log(
+        event_name=DataNFT.EVENT_TOKEN_URI_UPDATED,
         from_block=tx_receipt.blockNumber,
         to_block=web3.eth.block_number,
         filters=None,
@@ -657,12 +640,12 @@ def test_erc721_datatoken_functions(
     assert registered_event[0].args.updatedBy == publisher_addr
     assert registered_event[0].args.tokenID == 1
     assert registered_event[0].args.blockNumber == tx_receipt.blockNumber
-    assert erc721_nft.token_uri(token_id=1) == "https://newurl.com/nft/"
-    assert erc721_nft.token_uri(token_id=1) == registered_event[0].args.tokenURI
+    assert data_nft.token_uri(token_id=1) == "https://newurl.com/nft/"
+    assert data_nft.token_uri(token_id=1) == registered_event[0].args.tokenURI
 
     # Tests failing setting token URI by another user
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.set_token_uri(
+        data_nft.set_token_uri(
             token_id=1,
             new_token_uri="https://foourl.com/nft/",
             from_wallet=consumer_wallet,
@@ -673,26 +656,26 @@ def test_erc721_datatoken_functions(
     )
 
     # Tests transfer functions
-    erc20_token.mint(
+    datatoken.mint(
         account_address=consumer_addr,
         value=to_wei("0.2"),
         from_wallet=publisher_wallet,
     )
-    assert erc20_token.balanceOf(account=consumer_addr) == to_wei("0.2")
-    assert erc721_nft.owner_of(token_id=1) == publisher_addr
+    assert datatoken.balanceOf(account=consumer_addr) == to_wei("0.2")
+    assert data_nft.owner_of(token_id=1) == publisher_addr
 
-    erc721_nft.transfer_from(
+    data_nft.transfer_from(
         from_address=publisher_addr,
         to_address=consumer_addr,
         token_id=1,
         from_wallet=publisher_wallet,
     )
-    assert erc721_nft.balance_of(account=publisher_addr) == 0
-    assert erc721_nft.owner_of(token_id=1) == consumer_addr
-    assert erc721_nft.get_permissions(user=consumer_addr)[
-        ERC721Permissions.DEPLOY_ERC20
+    assert data_nft.balance_of(account=publisher_addr) == 0
+    assert data_nft.owner_of(token_id=1) == consumer_addr
+    assert data_nft.get_permissions(user=consumer_addr)[
+        DataNFTPermissions.DEPLOY_DATATOKEN
     ]
-    erc721_nft.create_erc20(
+    data_nft.create_erc20(
         template_index=1,
         name="ERC20DT1",
         symbol="ERC20DT1Symbol",
@@ -705,7 +688,7 @@ def test_erc721_datatoken_functions(
         from_wallet=consumer_wallet,
     )
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.mint(
+        datatoken.mint(
             account_address=consumer_addr,
             value=to_wei("1"),
             from_wallet=consumer_wallet,
@@ -715,22 +698,22 @@ def test_erc721_datatoken_functions(
         == "execution reverted: VM Exception while processing transaction: revert ERC20Template: NOT MINTER"
     )
 
-    erc20_token.add_minter(minter_address=consumer_addr, from_wallet=consumer_wallet)
-    erc20_token.mint(
+    datatoken.add_minter(minter_address=consumer_addr, from_wallet=consumer_wallet)
+    datatoken.mint(
         account_address=consumer_addr,
         value=to_wei("0.2"),
         from_wallet=consumer_wallet,
     )
-    assert erc20_token.balanceOf(account=consumer_addr) == to_wei("0.4")
+    assert datatoken.balanceOf(account=consumer_addr) == to_wei("0.4")
 
 
 @pytest.mark.unit
 def test_fail_transfer_function(
-    consumer_wallet, publisher_addr, consumer_addr, erc721_nft
+    consumer_wallet, publisher_addr, consumer_addr, data_nft
 ):
     """Tests failure of using the transfer functions."""
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.transfer_from(
+        data_nft.transfer_from(
             from_address=publisher_addr,
             to_address=consumer_addr,
             token_id=1,
@@ -744,7 +727,7 @@ def test_fail_transfer_function(
 
     # Tests for safe transfer as well
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.safe_transfer_from(
+        data_nft.safe_transfer_from(
             from_address=publisher_addr,
             to_address=consumer_addr,
             token_id=1,
@@ -764,12 +747,12 @@ def test_transfer_nft(
     publisher_addr,
     consumer_addr,
     factory_router,
-    erc721_factory,
+    data_nft_factory,
     publisher_ocean_instance,
 ):
     """Tests transferring the NFT before deploying an ERC20, a pool, a FRE."""
 
-    tx = erc721_factory.deploy_erc721_contract(
+    tx = data_nft_factory.deploy_erc721_contract(
         name="NFT to TRANSFER",
         symbol="NFTtT",
         template_index=1,
@@ -781,8 +764,8 @@ def test_transfer_nft(
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -790,19 +773,19 @@ def test_transfer_nft(
     assert registered_event[0].event == "NFTCreated"
     assert registered_event[0].args.admin == publisher_wallet.address
     token_address = registered_event[0].args.newTokenAddress
-    erc721_nft = ERC721NFT(web3, token_address)
-    assert erc721_nft.contract.caller.name() == "NFT to TRANSFER"
-    assert erc721_nft.symbol() == "NFTtT"
+    data_nft = DataNFT(web3, token_address)
+    assert data_nft.contract.caller.name() == "NFT to TRANSFER"
+    assert data_nft.symbol() == "NFTtT"
 
-    tx = erc721_nft.safe_transfer_from(
+    tx = data_nft.safe_transfer_from(
         publisher_addr,
         consumer_addr,
         token_id=1,
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    transfer_event = erc721_nft.get_event_log(
-        ERC721FactoryContract.EVENT_TRANSFER,
+    transfer_event = data_nft.get_event_log(
+        DataNFTFactoryContract.EVENT_TRANSFER,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -810,13 +793,13 @@ def test_transfer_nft(
     assert transfer_event[0].event == "Transfer"
     assert transfer_event[0].args["from"] == publisher_addr
     assert transfer_event[0].args.to == consumer_addr
-    assert erc721_nft.balance_of(consumer_addr) == 1
-    assert erc721_nft.balance_of(publisher_addr) == 0
-    assert erc721_nft.is_erc20_deployer(consumer_addr)
-    assert erc721_nft.owner_of(1) == consumer_addr
+    assert data_nft.balance_of(consumer_addr) == 1
+    assert data_nft.balance_of(publisher_addr) == 0
+    assert data_nft.is_erc20_deployer(consumer_addr)
+    assert data_nft.owner_of(1) == consumer_addr
 
     # Consumer is not the additional ERC20 deployer, but will be after the NFT transfer
-    tx = erc721_factory.deploy_erc721_contract(
+    tx = data_nft_factory.deploy_erc721_contract(
         name="NFT1",
         symbol="NFT",
         template_index=1,
@@ -828,23 +811,23 @@ def test_transfer_nft(
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
     )
     token_address = registered_event[0].args.newTokenAddress
-    erc721_nft = ERC721NFT(web3, token_address)
-    tx = erc721_nft.safe_transfer_from(
+    data_nft = DataNFT(web3, token_address)
+    tx = data_nft.safe_transfer_from(
         publisher_addr,
         consumer_addr,
         token_id=1,
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    transfer_event = erc721_nft.get_event_log(
-        ERC721FactoryContract.EVENT_TRANSFER,
+    transfer_event = data_nft.get_event_log(
+        DataNFTFactoryContract.EVENT_TRANSFER,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -852,10 +835,10 @@ def test_transfer_nft(
     assert transfer_event[0].event == "Transfer"
     assert transfer_event[0].args["from"] == publisher_addr
     assert transfer_event[0].args.to == consumer_addr
-    assert erc721_nft.is_erc20_deployer(consumer_addr)
+    assert data_nft.is_erc20_deployer(consumer_addr)
 
     # Creates an ERC20
-    tx_result = erc721_nft.create_erc20(
+    tx_result = data_nft.create_erc20(
         template_index=1,
         name="ERC20DT1",
         symbol="ERC20DT1Symbol",
@@ -869,39 +852,39 @@ def test_transfer_nft(
     )
     assert tx_result, "Failed to create ERC20 token."
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx_result)
-    registered_token_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_token_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
     )
     assert registered_token_event, "Cannot find TokenCreated event."
     erc20_address = registered_token_event[0].args.newTokenAddress
-    erc20_token = ERC20Token(web3, erc20_address)
+    datatoken = Datatoken(web3, erc20_address)
 
-    assert not erc20_token.is_minter(publisher_addr)
-    assert erc20_token.is_minter(consumer_addr)
-    erc20_token.add_minter(publisher_addr, consumer_wallet)
-    assert erc20_token.get_permissions(publisher_addr)[0]  # publisher is minter now
+    assert not datatoken.is_minter(publisher_addr)
+    assert datatoken.is_minter(consumer_addr)
+    datatoken.add_minter(publisher_addr, consumer_wallet)
+    assert datatoken.get_permissions(publisher_addr)[0]  # publisher is minter now
 
     ocean_token = publisher_ocean_instance.OCEAN_token
     ocean_token.approve(factory_router.address, to_wei(10000), consumer_wallet)
 
     # Make consumer the publish_market_order_fee_address instead of publisher
-    tx_result = erc20_token.set_publishing_market_fee(
+    tx_result = datatoken.set_publishing_market_fee(
         consumer_addr, ocean_token.address, to_wei(1), publisher_wallet
     )
 
     assert tx_result, "Failed to set the publish fee."
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx_result)
-    set_publishing_fee_event = erc20_token.get_event_log(
-        ERC20Token.EVENT_PUBLISH_MARKET_FEE_CHANGED,
+    set_publishing_fee_event = datatoken.get_event_log(
+        Datatoken.EVENT_PUBLISH_MARKET_FEE_CHANGED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
     )
     assert set_publishing_fee_event, "Cannot find PublishMarketFeeChanged event."
-    publish_fees = erc20_token.get_publishing_market_fee()
+    publish_fees = datatoken.get_publishing_market_fee()
     assert publish_fees[0] == consumer_addr
     assert publish_fees[1] == ocean_token.address
     assert publish_fees[2] == to_wei(1)
@@ -914,22 +897,22 @@ def test_nft_transfer_with_pool(
     publisher_wallet,
     consumer_wallet,
     factory_router,
-    erc721_nft,
-    erc20_token,
+    data_nft,
+    datatoken,
     publisher_addr,
     consumer_addr,
 ):
     """Tests transferring the NFT before deploying an ERC20, a pool."""
 
-    tx = erc721_nft.safe_transfer_from(
+    tx = data_nft.safe_transfer_from(
         publisher_wallet.address,
         consumer_wallet.address,
         token_id=1,
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    transfer_event = erc721_nft.get_event_log(
-        ERC721FactoryContract.EVENT_TRANSFER,
+    transfer_event = data_nft.get_event_log(
+        DataNFTFactoryContract.EVENT_TRANSFER,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -937,14 +920,14 @@ def test_nft_transfer_with_pool(
     assert transfer_event[0].event == "Transfer"
     assert transfer_event[0].args["from"] == publisher_wallet.address
     assert transfer_event[0].args.to == consumer_wallet.address
-    assert erc721_nft.balance_of(consumer_wallet.address) == 1
-    assert erc721_nft.balance_of(publisher_wallet.address) == 0
-    assert erc721_nft.is_erc20_deployer(consumer_wallet.address) is True
-    assert erc721_nft.owner_of(1) == consumer_wallet.address
+    assert data_nft.balance_of(consumer_wallet.address) == 1
+    assert data_nft.balance_of(publisher_wallet.address) == 0
+    assert data_nft.is_erc20_deployer(consumer_wallet.address) is True
+    assert data_nft.owner_of(1) == consumer_wallet.address
 
     ocean_token.approve(factory_router.address, to_wei(10000), consumer_wallet)
 
-    tx = erc20_token.deploy_pool(
+    tx = datatoken.deploy_pool(
         rate=to_wei(1),
         base_token_decimals=ocean_token.decimals(),
         base_token_amount=to_wei(100),
@@ -960,7 +943,7 @@ def test_nft_transfer_with_pool(
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
     pool_event = factory_router.get_event_log(
-        ERC721FactoryContract.EVENT_NEW_POOL,
+        DataNFTFactoryContract.EVENT_NEW_POOL,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -972,9 +955,9 @@ def test_nft_transfer_with_pool(
     assert bpool.get_opc_fee() == OPC_SWAP_FEE_APPROVED
     assert bpool.get_swap_fee() == to_wei("0.003")
     assert bpool.community_fee(ocean_token.address) == 0
-    assert bpool.community_fee(erc20_token.address) == 0
+    assert bpool.community_fee(datatoken.address) == 0
     assert bpool.publish_market_fee(ocean_token.address) == 0
-    assert bpool.publish_market_fee(erc20_token.address) == 0
+    assert bpool.publish_market_fee(datatoken.address) == 0
 
     ocean_token.approve(bpool_address, to_wei(1000000), consumer_wallet)
     tx = bpool.join_swap_extern_amount_in(
@@ -1001,11 +984,11 @@ def test_nft_transfer_with_pool(
     assert bpool.get_balance(ocean_token.address) == to_wei(100) + to_wei(10)
 
     amount_out = bpool.get_amount_out_exact_in(
-        ocean_token.address, erc20_token.address, to_wei(20), to_wei("0.01")
+        ocean_token.address, datatoken.address, to_wei(20), to_wei("0.01")
     )[0]
     tx = bpool.swap_exact_amount_in(
         token_in=ocean_token.address,
-        token_out=erc20_token.address,
+        token_out=datatoken.address,
         consume_market_swap_fee_address=consumer_addr,
         token_amount_in=to_wei(20),
         min_amount_out=to_wei(5),
@@ -1053,21 +1036,21 @@ def test_nft_transfer_with_fre(
     ocean_token,
     publisher_wallet,
     consumer_wallet,
-    erc721_nft,
-    erc20_token,
+    data_nft,
+    datatoken,
     consumer_addr,
 ):
     """Tests transferring the NFT before deploying an ERC20, a FRE."""
 
-    tx = erc721_nft.safe_transfer_from(
+    tx = data_nft.safe_transfer_from(
         publisher_wallet.address,
         consumer_wallet.address,
         token_id=1,
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    transfer_event = erc721_nft.get_event_log(
-        ERC721FactoryContract.EVENT_TRANSFER,
+    transfer_event = data_nft.get_event_log(
+        DataNFTFactoryContract.EVENT_TRANSFER,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -1075,22 +1058,22 @@ def test_nft_transfer_with_fre(
     assert transfer_event[0].event == "Transfer"
     assert transfer_event[0].args["from"] == publisher_wallet.address
     assert transfer_event[0].args.to == consumer_wallet.address
-    assert erc721_nft.balance_of(consumer_wallet.address) == 1
-    assert erc721_nft.balance_of(publisher_wallet.address) == 0
-    assert erc721_nft.is_erc20_deployer(consumer_wallet.address) is True
-    assert erc721_nft.owner_of(1) == consumer_wallet.address
+    assert data_nft.balance_of(consumer_wallet.address) == 1
+    assert data_nft.balance_of(publisher_wallet.address) == 0
+    assert data_nft.is_erc20_deployer(consumer_wallet.address) is True
+    assert data_nft.owner_of(1) == consumer_wallet.address
 
     # The newest owner of the NFT (consumer wallet) has ERC20 deployer role & can deploy a FRE
     fixed_exchange = FixedRateExchange(web3, get_address_of_type(config, "FixedPrice"))
     number_of_exchanges = fixed_exchange.get_number_of_exchanges()
-    tx = erc20_token.create_fixed_rate(
+    tx = datatoken.create_fixed_rate(
         fixed_price_address=fixed_exchange.address,
         base_token_address=ocean_token.address,
         owner=consumer_wallet.address,
         publish_market_swap_fee_collector=consumer_wallet.address,
         allowed_swapper=ZERO_ADDRESS,
         base_token_decimals=ocean_token.decimals(),
-        datatoken_decimals=erc20_token.decimals(),
+        datatoken_decimals=datatoken.decimals(),
         fixed_rate=to_wei(1),
         publish_market_swap_fee_amount=to_wei("0.001"),
         with_mint=1,
@@ -1099,8 +1082,8 @@ def test_nft_transfer_with_fre(
 
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
 
-    fre_event = erc20_token.get_event_log(
-        event_name=ERC721FactoryContract.EVENT_NEW_FIXED_RATE,
+    fre_event = datatoken.get_event_log(
+        event_name=DataNFTFactoryContract.EVENT_NEW_FIXED_RATE,
         from_block=tx_receipt.blockNumber,
         to_block=web3.eth.block_number,
         filters=None,
@@ -1114,9 +1097,9 @@ def test_nft_transfer_with_fre(
     # Exchange should have supply and fees setup
     exchange_details = fixed_exchange.get_exchange(exchange_id)
     assert exchange_details[FixedRateExchangeDetails.EXCHANGE_OWNER] == consumer_addr
-    assert exchange_details[FixedRateExchangeDetails.DATATOKEN] == erc20_token.address
+    assert exchange_details[FixedRateExchangeDetails.DATATOKEN] == datatoken.address
     assert (
-        exchange_details[FixedRateExchangeDetails.DT_DECIMALS] == erc20_token.decimals()
+        exchange_details[FixedRateExchangeDetails.DT_DECIMALS] == datatoken.decimals()
     )
     assert exchange_details[FixedRateExchangeDetails.BASE_TOKEN] == ocean_token.address
     assert (
@@ -1129,7 +1112,7 @@ def test_nft_transfer_with_fre(
     assert exchange_details[FixedRateExchangeDetails.BT_BALANCE] == 0
     assert exchange_details[FixedRateExchangeDetails.WITH_MINT]
 
-    erc20_token.approve(fixed_exchange.address, to_wei(100), consumer_wallet)
+    datatoken.approve(fixed_exchange.address, to_wei(100), consumer_wallet)
     ocean_token.approve(fixed_exchange.address, to_wei(100), consumer_wallet)
     amount_dt_bought = to_wei(2)
     fixed_exchange.buy_dt(
@@ -1144,7 +1127,7 @@ def test_nft_transfer_with_fre(
         fixed_exchange.get_dt_supply(exchange_id)
         == exchange_details[FixedRateExchangeDetails.DT_SUPPLY] - amount_dt_bought
     )
-    assert erc20_token.balanceOf(consumer_addr) == amount_dt_bought
+    assert datatoken.balanceOf(consumer_addr) == amount_dt_bought
     fixed_exchange.sell_dt(
         exchange_id=exchange_id,
         datatoken_amount=to_wei(2),
@@ -1157,11 +1140,11 @@ def test_nft_transfer_with_fre(
         fixed_exchange.get_dt_supply(exchange_id)
         == exchange_details[FixedRateExchangeDetails.DT_SUPPLY] - amount_dt_bought
     )
-    assert erc20_token.balanceOf(consumer_addr) == 0
+    assert datatoken.balanceOf(consumer_addr) == 0
     fixed_exchange.collect_dt(
         exchange_id=exchange_id, amount=to_wei(1), from_wallet=consumer_wallet
     )
-    assert erc20_token.balanceOf(consumer_addr) == to_wei(1)
+    assert datatoken.balanceOf(consumer_addr) == to_wei(1)
 
 
 def test_transfer_nft_with_erc20_pool_fre(
@@ -1173,11 +1156,11 @@ def test_transfer_nft_with_erc20_pool_fre(
     consumer_addr,
     factory_router,
     publisher_ocean_instance,
-    erc721_factory,
+    data_nft_factory,
 ):
     """Tests transferring the NFT after deploying an ERC20, a pool, a FRE."""
 
-    tx = erc721_factory.deploy_erc721_contract(
+    tx = data_nft_factory.deploy_erc721_contract(
         name="NFT to TRANSFER",
         symbol="NFTtT",
         template_index=1,
@@ -1189,8 +1172,8 @@ def test_transfer_nft_with_erc20_pool_fre(
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -1198,12 +1181,12 @@ def test_transfer_nft_with_erc20_pool_fre(
     assert registered_event[0].event == "NFTCreated"
     assert registered_event[0].args.admin == publisher_addr
     token_address = registered_event[0].args.newTokenAddress
-    erc721_nft = ERC721NFT(web3, token_address)
-    assert erc721_nft.contract.caller.name() == "NFT to TRANSFER"
-    assert erc721_nft.symbol() == "NFTtT"
+    data_nft = DataNFT(web3, token_address)
+    assert data_nft.contract.caller.name() == "NFT to TRANSFER"
+    assert data_nft.symbol() == "NFTtT"
 
     # Creates an ERC20
-    tx_result = erc721_nft.create_erc20(
+    tx_result = data_nft.create_erc20(
         template_index=1,
         name="ERC20DT1",
         symbol="ERC20DT1Symbol",
@@ -1217,23 +1200,23 @@ def test_transfer_nft_with_erc20_pool_fre(
     )
     assert tx_result, "Failed to create ERC20 token."
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx_result)
-    registered_token_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_token_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
     )
     assert registered_token_event, "Cannot find TokenCreated event."
     erc20_address = registered_token_event[0].args.newTokenAddress
-    erc20_token = ERC20Token(web3, erc20_address)
+    datatoken = Datatoken(web3, erc20_address)
 
-    assert erc20_token.is_minter(publisher_addr)
+    assert datatoken.is_minter(publisher_addr)
 
     ocean_token = publisher_ocean_instance.OCEAN_token
 
     # The owner of the NFT (publisher wallet) has ERC20 deployer role & can deploy a pool
     ocean_token.approve(factory_router.address, to_wei(10000), publisher_wallet)
-    tx = erc20_token.deploy_pool(
+    tx = datatoken.deploy_pool(
         rate=to_wei(1),
         base_token_decimals=ocean_token.decimals(),
         base_token_amount=to_wei(100),
@@ -1249,7 +1232,7 @@ def test_transfer_nft_with_erc20_pool_fre(
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
     pool_event = factory_router.get_event_log(
-        ERC721FactoryContract.EVENT_NEW_POOL,
+        DataNFTFactoryContract.EVENT_NEW_POOL,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -1261,9 +1244,9 @@ def test_transfer_nft_with_erc20_pool_fre(
     assert bpool.get_opc_fee() == OPC_SWAP_FEE_APPROVED
     assert bpool.get_swap_fee() == to_wei("0.003")
     assert bpool.community_fee(ocean_token.address) == 0
-    assert bpool.community_fee(erc20_token.address) == 0
+    assert bpool.community_fee(datatoken.address) == 0
     assert bpool.publish_market_fee(ocean_token.address) == 0
-    assert bpool.publish_market_fee(erc20_token.address) == 0
+    assert bpool.publish_market_fee(datatoken.address) == 0
 
     ocean_token.approve(bpool_address, to_wei(1000000), publisher_wallet)
     tx = bpool.join_swap_extern_amount_in(
@@ -1292,14 +1275,14 @@ def test_transfer_nft_with_erc20_pool_fre(
     # The owner of the NFT (publisher wallet) has ERC20 deployer role & can deploy a FRE
     fixed_exchange = FixedRateExchange(web3, get_address_of_type(config, "FixedPrice"))
     number_of_exchanges = fixed_exchange.get_number_of_exchanges()
-    tx = erc20_token.create_fixed_rate(
+    tx = datatoken.create_fixed_rate(
         fixed_price_address=fixed_exchange.address,
         base_token_address=ocean_token.address,
         owner=publisher_addr,
         publish_market_swap_fee_collector=publisher_addr,
         allowed_swapper=ZERO_ADDRESS,
         base_token_decimals=ocean_token.decimals(),
-        datatoken_decimals=erc20_token.decimals(),
+        datatoken_decimals=datatoken.decimals(),
         fixed_rate=to_wei(1),
         publish_market_swap_fee_amount=to_wei("0.001"),
         with_mint=0,
@@ -1308,8 +1291,8 @@ def test_transfer_nft_with_erc20_pool_fre(
 
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
 
-    fre_event = erc20_token.get_event_log(
-        event_name=ERC721FactoryContract.EVENT_NEW_FIXED_RATE,
+    fre_event = datatoken.get_event_log(
+        event_name=DataNFTFactoryContract.EVENT_NEW_FIXED_RATE,
         from_block=tx_receipt.blockNumber,
         to_block=web3.eth.block_number,
         filters=None,
@@ -1322,9 +1305,9 @@ def test_transfer_nft_with_erc20_pool_fre(
 
     exchange_details = fixed_exchange.get_exchange(exchange_id)
     assert exchange_details[FixedRateExchangeDetails.EXCHANGE_OWNER] == publisher_addr
-    assert exchange_details[FixedRateExchangeDetails.DATATOKEN] == erc20_token.address
+    assert exchange_details[FixedRateExchangeDetails.DATATOKEN] == datatoken.address
     assert (
-        exchange_details[FixedRateExchangeDetails.DT_DECIMALS] == erc20_token.decimals()
+        exchange_details[FixedRateExchangeDetails.DT_DECIMALS] == datatoken.decimals()
     )
     assert exchange_details[FixedRateExchangeDetails.BASE_TOKEN] == ocean_token.address
     assert (
@@ -1338,15 +1321,15 @@ def test_transfer_nft_with_erc20_pool_fre(
     assert exchange_details[FixedRateExchangeDetails.BT_BALANCE] == 0
     assert not exchange_details[FixedRateExchangeDetails.WITH_MINT]
 
-    tx = erc721_nft.safe_transfer_from(
+    tx = data_nft.safe_transfer_from(
         publisher_addr,
         consumer_addr,
         token_id=1,
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    transfer_event = erc721_nft.get_event_log(
-        ERC721FactoryContract.EVENT_TRANSFER,
+    transfer_event = data_nft.get_event_log(
+        DataNFTFactoryContract.EVENT_TRANSFER,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -1354,14 +1337,14 @@ def test_transfer_nft_with_erc20_pool_fre(
     assert transfer_event[0].event == "Transfer"
     assert transfer_event[0].args["from"] == publisher_addr
     assert transfer_event[0].args.to == consumer_addr
-    assert erc721_nft.balance_of(consumer_addr) == 1
-    assert erc721_nft.balance_of(publisher_addr) == 0
-    assert erc721_nft.is_erc20_deployer(consumer_addr)
-    assert erc721_nft.owner_of(1) == consumer_addr
-    permissions = erc20_token.get_permissions(consumer_addr)
+    assert data_nft.balance_of(consumer_addr) == 1
+    assert data_nft.balance_of(publisher_addr) == 0
+    assert data_nft.is_erc20_deployer(consumer_addr)
+    assert data_nft.owner_of(1) == consumer_addr
+    permissions = datatoken.get_permissions(consumer_addr)
     assert not permissions[0]  # the newest owner is not the minter
-    erc20_token.add_minter(consumer_addr, consumer_wallet)
-    assert erc20_token.permissions(consumer_addr)[0]
+    datatoken.add_minter(consumer_addr, consumer_wallet)
+    assert datatoken.permissions(consumer_addr)[0]
 
     # Consumer wallet is not the publish market fee collector
     with pytest.raises(exceptions.ContractLogicError) as err:
diff --git a/ocean_lib/models/test/test_erc721_factory.py b/ocean_lib/models/test/test_data_nft_factory.py
similarity index 71%
rename from ocean_lib/models/test/test_erc721_factory.py
rename to ocean_lib/models/test/test_data_nft_factory.py
index 469e5060f..ca34b838f 100644
--- a/ocean_lib/models/test/test_erc721_factory.py
+++ b/ocean_lib/models/test/test_data_nft_factory.py
@@ -6,10 +6,10 @@
 from web3 import exceptions
 from web3.main import Web3
 
+from ocean_lib.models.data_nft import DataNFT
+from ocean_lib.models.data_nft_factory import DataNFTFactoryContract
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.models.dispenser import Dispenser
-from ocean_lib.models.erc20_token import ERC20Token
-from ocean_lib.models.erc721_factory import ERC721FactoryContract
-from ocean_lib.models.erc721_nft import ERC721NFT
 from ocean_lib.structures.abi_tuples import OrderData
 from ocean_lib.utils.utilities import create_checksum
 from ocean_lib.web3_internal.constants import ZERO_ADDRESS
@@ -21,53 +21,54 @@
 @pytest.mark.unit
 def test_properties(web3, config):
     """Tests the events' properties."""
-    erc721_factory_address = get_address_of_type(
-        config, ERC721FactoryContract.CONTRACT_NAME
+    data_nft_factory_address = get_address_of_type(
+        config, DataNFTFactoryContract.CONTRACT_NAME
     )
-    erc721_factory = ERC721FactoryContract(web3, erc721_factory_address)
+    data_nft_factory = DataNFTFactoryContract(web3, data_nft_factory_address)
 
     assert (
-        erc721_factory.event_NFTCreated.abi["name"]
-        == ERC721FactoryContract.EVENT_NFT_CREATED
+        data_nft_factory.event_NFTCreated.abi["name"]
+        == DataNFTFactoryContract.EVENT_NFT_CREATED
     )
     assert (
-        erc721_factory.event_TokenCreated.abi["name"]
-        == ERC721FactoryContract.EVENT_TOKEN_CREATED
+        data_nft_factory.event_TokenCreated.abi["name"]
+        == DataNFTFactoryContract.EVENT_TOKEN_CREATED
     )
     assert (
-        erc721_factory.event_Template721Added.abi["name"]
-        == ERC721FactoryContract.EVENT_TEMPLATE721_ADDED
+        data_nft_factory.event_Template721Added.abi["name"]
+        == DataNFTFactoryContract.EVENT_TEMPLATE721_ADDED
     )
     assert (
-        erc721_factory.event_Template20Added.abi["name"]
-        == ERC721FactoryContract.EVENT_TEMPLATE20_ADDED
+        data_nft_factory.event_Template20Added.abi["name"]
+        == DataNFTFactoryContract.EVENT_TEMPLATE20_ADDED
     )
     assert (
-        erc721_factory.event_NewPool.abi["name"] == ERC721FactoryContract.EVENT_NEW_POOL
+        data_nft_factory.event_NewPool.abi["name"]
+        == DataNFTFactoryContract.EVENT_NEW_POOL
     )
     assert (
-        erc721_factory.event_NewFixedRate.abi["name"]
-        == ERC721FactoryContract.EVENT_NEW_FIXED_RATE
+        data_nft_factory.event_NewFixedRate.abi["name"]
+        == DataNFTFactoryContract.EVENT_NEW_FIXED_RATE
     )
     assert (
-        erc721_factory.event_DispenserCreated.abi["name"]
-        == ERC721FactoryContract.EVENT_DISPENSER_CREATED
+        data_nft_factory.event_DispenserCreated.abi["name"]
+        == DataNFTFactoryContract.EVENT_DISPENSER_CREATED
     )
     assert (
-        erc721_factory.event_Transfer.abi["name"]
-        == ERC721FactoryContract.EVENT_TRANSFER
+        data_nft_factory.event_Transfer.abi["name"]
+        == DataNFTFactoryContract.EVENT_TRANSFER
     )
 
 
 @pytest.mark.unit
 def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_wallet):
     """Tests the utils functions."""
-    erc721_factory_address = get_address_of_type(
-        config, ERC721FactoryContract.CONTRACT_NAME
+    data_nft_factory_address = get_address_of_type(
+        config, DataNFTFactoryContract.CONTRACT_NAME
     )
-    erc721_factory = ERC721FactoryContract(web3, erc721_factory_address)
+    data_nft_factory = DataNFTFactoryContract(web3, data_nft_factory_address)
 
-    tx = erc721_factory.deploy_erc721_contract(
+    tx = data_nft_factory.deploy_erc721_contract(
         name="DT1",
         symbol="DTSYMBOL",
         template_index=1,
@@ -79,8 +80,8 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -88,13 +89,13 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     assert registered_event[0].event == "NFTCreated"
     assert registered_event[0].args.admin == publisher_wallet.address
     token_address = registered_event[0].args.newTokenAddress
-    erc721_nft = ERC721NFT(web3, token_address)
-    assert erc721_nft.contract.caller.name() == "DT1"
-    assert erc721_nft.symbol() == "DTSYMBOL"
+    data_nft = DataNFT(web3, token_address)
+    assert data_nft.contract.caller.name() == "DT1"
+    assert data_nft.symbol() == "DTSYMBOL"
 
     # Tests current NFT count
-    current_nft_count = erc721_factory.get_current_nft_count()
-    erc721_factory.deploy_erc721_contract(
+    current_nft_count = data_nft_factory.get_current_nft_count()
+    data_nft_factory.deploy_erc721_contract(
         name="DT2",
         symbol="DTSYMBOL1",
         template_index=1,
@@ -105,17 +106,17 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
         owner=publisher_wallet.address,
         from_wallet=publisher_wallet,
     )
-    assert erc721_factory.get_current_nft_count() == current_nft_count + 1
+    assert data_nft_factory.get_current_nft_count() == current_nft_count + 1
 
     # Tests get NFT template
-    nft_template_address = get_address_of_type(config, ERC721NFT.CONTRACT_NAME, "1")
-    nft_template = erc721_factory.get_nft_template(1)
+    nft_template_address = get_address_of_type(config, DataNFT.CONTRACT_NAME, "1")
+    nft_template = data_nft_factory.get_nft_template(1)
     assert nft_template[0] == nft_template_address
     assert nft_template[1] is True
 
     # Tests creating successfully an ERC20 token
-    erc721_nft.add_to_create_erc20_list(consumer_wallet.address, publisher_wallet)
-    tx_result = erc721_nft.create_erc20(
+    data_nft.add_to_create_erc20_list(consumer_wallet.address, publisher_wallet)
+    tx_result = data_nft.create_erc20(
         template_index=1,
         name="ERC20DT1",
         symbol="ERC20DT1Symbol",
@@ -129,8 +130,8 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     )
     assert tx_result, "Failed to create ERC20 token."
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx_result)
-    registered_token_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_token_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -139,22 +140,22 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     erc20_address = registered_token_event[0].args.newTokenAddress
 
     # Tests templateCount function (one of them should be the Enterprise template)
-    assert erc721_factory.template_count() == 2
+    assert data_nft_factory.template_count() == 2
 
     # Tests ERC20 token template list
-    erc20_template_address = get_address_of_type(config, ERC20Token.CONTRACT_NAME, "1")
-    template = erc721_factory.get_token_template(1)
+    erc20_template_address = get_address_of_type(config, Datatoken.CONTRACT_NAME, "1")
+    template = data_nft_factory.get_token_template(1)
     assert template[0] == erc20_template_address
     assert template[1] is True
 
     # Tests current token template (one of them should be the Enterprise template)
-    assert erc721_factory.get_current_template_count() == 2
+    assert data_nft_factory.get_current_template_count() == 2
 
-    erc20_token = ERC20Token(web3, erc20_address)
-    erc20_token.add_minter(consumer_wallet.address, publisher_wallet)
+    datatoken = Datatoken(web3, erc20_address)
+    datatoken.add_minter(consumer_wallet.address, publisher_wallet)
 
     # Tests creating NFT with ERC20 successfully
-    tx = erc721_factory.create_nft_with_erc20(
+    tx = data_nft_factory.create_nft_with_erc20(
         nft_name="72120Bundle",
         nft_symbol="72Bundle",
         nft_template=1,
@@ -173,8 +174,8 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_nft_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_nft_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -185,12 +186,12 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     assert registered_nft_event[0].event == "NFTCreated"
     assert registered_nft_event[0].args.admin == publisher_wallet.address
     erc721_address2 = registered_nft_event[0].args.newTokenAddress
-    erc721_token2 = ERC721NFT(web3, erc721_address2)
-    assert erc721_token2.contract.caller.name() == "72120Bundle"
-    assert erc721_token2.symbol() == "72Bundle"
+    data_nft_token2 = DataNFT(web3, erc721_address2)
+    assert data_nft_token2.contract.caller.name() == "72120Bundle"
+    assert data_nft_token2.symbol() == "72Bundle"
 
-    registered_token_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_token_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -199,20 +200,20 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     # Verify if the ERC20 token was created.
     assert registered_token_event, "Cannot find TokenCreated event."
     erc20_address2 = registered_token_event[0].args.newTokenAddress
-    erc20_token2 = ERC20Token(web3, erc20_address2)
-    assert erc20_token2.contract.caller.name() == "ERC20B1"
-    assert erc20_token2.symbol() == "ERC20DT1Symbol"
+    datatoken2 = Datatoken(web3, erc20_address2)
+    assert datatoken2.contract.caller.name() == "ERC20B1"
+    assert datatoken2.symbol() == "ERC20DT1Symbol"
 
     # Tests creating NFT with ERC20 and with Pool successfully.
     side_staking_address = get_address_of_type(config, "Staking")
     pool_template_address = get_address_of_type(config, "poolTemplate")
     initial_pool_liquidity = to_wei("0.02")
 
-    erc20_token.mint(publisher_wallet.address, initial_pool_liquidity, publisher_wallet)
-    erc20_token.approve(
-        erc721_factory_address, initial_pool_liquidity, publisher_wallet
+    datatoken.mint(publisher_wallet.address, initial_pool_liquidity, publisher_wallet)
+    datatoken.approve(
+        data_nft_factory_address, initial_pool_liquidity, publisher_wallet
     )
-    tx = erc721_factory.create_nft_erc20_with_pool(
+    tx = data_nft_factory.create_nft_erc20_with_pool(
         nft_name="72120Bundle",
         nft_symbol="72Bundle",
         nft_template=1,
@@ -229,21 +230,21 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
         datatoken_publish_market_order_fee_amount=0,
         datatoken_bytess=[b""],
         pool_rate=to_wei("1"),
-        pool_base_token_decimals=erc20_token.decimals(),
+        pool_base_token_decimals=datatoken.decimals(),
         pool_base_token_amount=initial_pool_liquidity,
         pool_lp_swap_fee_amount=to_wei("0.001"),
         pool_publish_market_swap_fee_amount=to_wei("0.001"),
         pool_side_staking=side_staking_address,
         pool_base_token=erc20_address,
-        pool_base_token_sender=erc721_factory_address,
+        pool_base_token_sender=data_nft_factory_address,
         pool_publisher=publisher_wallet.address,
         pool_publish_market_swap_fee_collector=consumer_wallet.address,
         pool_template_address=pool_template_address,
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_nft_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_nft_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -252,13 +253,13 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     assert registered_nft_event, "Cannot find NFTCreated event."
     assert registered_nft_event[0].event == "NFTCreated"
     assert registered_nft_event[0].args.admin == publisher_wallet.address
-    erc721_token3 = registered_nft_event[0].args.newTokenAddress
-    erc721_token3 = ERC721NFT(web3, erc721_token3)
-    assert erc721_token3.contract.caller.name() == "72120Bundle"
-    assert erc721_token3.symbol() == "72Bundle"
+    data_nft_token3 = registered_nft_event[0].args.newTokenAddress
+    data_nft_token3 = DataNFT(web3, data_nft_token3)
+    assert data_nft_token3.contract.caller.name() == "72120Bundle"
+    assert data_nft_token3.symbol() == "72Bundle"
 
-    registered_token_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_token_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -267,12 +268,12 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     # Verify if the ERC20 token was created.
     assert registered_token_event, "Cannot find TokenCreated event."
     erc20_address3 = registered_token_event[0].args.newTokenAddress
-    erc20_token3 = ERC20Token(web3, erc20_address3)
-    assert erc20_token3.contract.caller.name() == "ERC20WithPool"
-    assert erc20_token3.symbol() == "ERC20P"
+    datatoken3 = Datatoken(web3, erc20_address3)
+    assert datatoken3.contract.caller.name() == "ERC20WithPool"
+    assert datatoken3.symbol() == "ERC20P"
 
-    registered_pool_event = erc20_token3.get_event_log(
-        ERC721FactoryContract.EVENT_NEW_POOL,
+    registered_pool_event = datatoken3.get_event_log(
+        DataNFTFactoryContract.EVENT_NEW_POOL,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -281,7 +282,7 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     # Verify if the pool was created.
     assert registered_pool_event, "Cannot find NewPool event."
     pool_address = registered_pool_event[0].args.poolAddress
-    pool_token = ERC20Token(web3, pool_address)
+    pool_token = Datatoken(web3, pool_address)
 
     assert pool_token.balanceOf(publisher_wallet.address) > 0, "Invalid pool share."
 
@@ -289,7 +290,7 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     fixed_rate_address = get_address_of_type(config, "FixedPrice")
 
     # Create ERC20 data token for fees.
-    tx = erc721_nft.create_erc20(
+    tx = data_nft.create_erc20(
         template_index=1,
         name="ERC20DT1P",
         symbol="ERC20DT1SymbolP",
@@ -303,8 +304,8 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     )
     assert tx, "Failed to create ERC20 token."
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_fee_token_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_fee_token_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -312,7 +313,7 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     assert registered_fee_token_event, "Cannot find TokenCreated event."
     fee_erc20_address = registered_fee_token_event[0].args.newTokenAddress
 
-    tx = erc721_factory.create_nft_erc20_with_fixed_rate(
+    tx = data_nft_factory.create_nft_erc20_with_fixed_rate(
         nft_name="72120Bundle",
         nft_symbol="72Bundle",
         nft_template=1,
@@ -341,8 +342,8 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_nft_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_nft_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -352,12 +353,12 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     assert registered_nft_event[0].event == "NFTCreated"
     assert registered_nft_event[0].args.admin == publisher_wallet.address
     erc721_address4 = registered_nft_event[0].args.newTokenAddress
-    erc721_token4 = ERC721NFT(web3, erc721_address4)
-    assert erc721_token4.contract.caller.name() == "72120Bundle"
-    assert erc721_token4.symbol() == "72Bundle"
+    data_nft_token4 = DataNFT(web3, erc721_address4)
+    assert data_nft_token4.contract.caller.name() == "72120Bundle"
+    assert data_nft_token4.symbol() == "72Bundle"
 
-    registered_token_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_token_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -366,12 +367,12 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     # Verify if the ERC20 token was created.
     assert registered_token_event, "Cannot find TokenCreated event."
     erc20_address4 = registered_token_event[0].args.newTokenAddress
-    erc20_token4 = ERC20Token(web3, erc20_address4)
-    assert erc20_token4.contract.caller.name() == "ERC20WithPool"
-    assert erc20_token4.symbol() == "ERC20P"
+    datatoken4 = Datatoken(web3, erc20_address4)
+    assert datatoken4.contract.caller.name() == "ERC20WithPool"
+    assert datatoken4.symbol() == "ERC20P"
 
-    registered_fixed_rate_event = erc20_token4.get_event_log(
-        ERC721FactoryContract.EVENT_NEW_FIXED_RATE,
+    registered_fixed_rate_event = datatoken4.get_event_log(
+        DataNFTFactoryContract.EVENT_NEW_FIXED_RATE,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -384,7 +385,7 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     # Tests creating NFT with ERC20 and with Dispenser successfully.
     dispenser_address = get_address_of_type(config, Dispenser.CONTRACT_NAME)
 
-    tx = erc721_factory.create_nft_erc20_with_dispenser(
+    tx = data_nft_factory.create_nft_erc20_with_dispenser(
         nft_name="72120Bundle",
         nft_symbol="72Bundle",
         nft_template=1,
@@ -408,8 +409,8 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_nft_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_nft_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -419,12 +420,12 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     assert registered_nft_event[0].event == "NFTCreated"
     assert registered_nft_event[0].args.admin == publisher_wallet.address
     erc721_address5 = registered_nft_event[0].args.newTokenAddress
-    erc721_token5 = ERC721NFT(web3, erc721_address5)
-    assert erc721_token5.contract.caller.name() == "72120Bundle"
-    assert erc721_token5.symbol() == "72Bundle"
+    data_nft_token5 = DataNFT(web3, erc721_address5)
+    assert data_nft_token5.contract.caller.name() == "72120Bundle"
+    assert data_nft_token5.symbol() == "72Bundle"
 
-    registered_token_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_token_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -433,14 +434,14 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     # Verify if the ERC20 token was created.
     assert registered_token_event, "Cannot find TokenCreated event."
     erc20_address5 = registered_token_event[0].args.newTokenAddress
-    erc20_token5 = ERC20Token(web3, erc20_address5)
-    assert erc20_token5.contract.caller.name() == "ERC20WithPool"
-    assert erc20_token5.symbol() == "ERC20P"
+    datatoken5 = Datatoken(web3, erc20_address5)
+    assert datatoken5.contract.caller.name() == "ERC20WithPool"
+    assert datatoken5.symbol() == "ERC20P"
 
     dispenser = Dispenser(web3, dispenser_address)
 
     registered_dispenser_event = dispenser.get_event_log(
-        ERC721FactoryContract.EVENT_DISPENSER_CREATED,
+        DataNFTFactoryContract.EVENT_DISPENSER_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -453,7 +454,7 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     ].args.datatokenAddress, "Invalid data token address by dispenser."
 
     # Create a new erc721 with metadata in one single call and get address
-    tx = erc721_factory.create_nft_with_metadata(
+    tx = data_nft_factory.create_nft_with_metadata(
         nft_name="72120Bundle",
         nft_symbol="72Bundle",
         nft_template=1,
@@ -470,8 +471,8 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_nft_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_nft_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -480,12 +481,12 @@ def test_main(web3, config, publisher_wallet, consumer_wallet, another_consumer_
     assert (
         registered_nft_event[0].args.admin == publisher_wallet.address
     ), "Invalid NFT owner!"
-    erc721_nft_address = registered_nft_event[0].args.newTokenAddress
-    erc721_nft = ERC721NFT(web3, erc721_nft_address)
+    data_nft_address = registered_nft_event[0].args.newTokenAddress
+    data_nft = DataNFT(web3, data_nft_address)
     assert (
-        erc721_nft.token_name() == "72120Bundle"
+        data_nft.token_name() == "72120Bundle"
     ), "NFT name doesn't match with the expected one."
-    metadata_info = erc721_nft.get_metadata()
+    metadata_info = data_nft.get_metadata()
     assert metadata_info[3] is True
     assert metadata_info[0] == "http://myprovider:8030"
 
@@ -495,12 +496,12 @@ def test_start_multiple_order(
     web3, config, publisher_wallet, consumer_wallet, another_consumer_wallet
 ):
     """Tests the utils functions."""
-    erc721_factory_address = get_address_of_type(
-        config, ERC721FactoryContract.CONTRACT_NAME
+    data_nft_factory_address = get_address_of_type(
+        config, DataNFTFactoryContract.CONTRACT_NAME
     )
-    erc721_factory = ERC721FactoryContract(web3, erc721_factory_address)
+    data_nft_factory = DataNFTFactoryContract(web3, data_nft_factory_address)
 
-    tx = erc721_factory.deploy_erc721_contract(
+    tx = data_nft_factory.deploy_erc721_contract(
         name="DT1",
         symbol="DTSYMBOL",
         template_index=1,
@@ -512,8 +513,8 @@ def test_start_multiple_order(
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -521,14 +522,14 @@ def test_start_multiple_order(
     assert registered_event[0].event == "NFTCreated"
     assert registered_event[0].args.admin == publisher_wallet.address
     token_address = registered_event[0].args.newTokenAddress
-    erc721_nft = ERC721NFT(web3, token_address)
-    assert erc721_nft.contract.caller.name() == "DT1"
-    assert erc721_nft.symbol() == "DTSYMBOL"
-    assert erc721_factory.check_nft(token_address)
+    data_nft = DataNFT(web3, token_address)
+    assert data_nft.contract.caller.name() == "DT1"
+    assert data_nft.symbol() == "DTSYMBOL"
+    assert data_nft_factory.check_nft(token_address)
 
     # Tests current NFT count
-    current_nft_count = erc721_factory.get_current_nft_count()
-    erc721_factory.deploy_erc721_contract(
+    current_nft_count = data_nft_factory.get_current_nft_count()
+    data_nft_factory.deploy_erc721_contract(
         name="DT2",
         symbol="DTSYMBOL1",
         template_index=1,
@@ -539,17 +540,17 @@ def test_start_multiple_order(
         owner=publisher_wallet.address,
         from_wallet=publisher_wallet,
     )
-    assert erc721_factory.get_current_nft_count() == current_nft_count + 1
+    assert data_nft_factory.get_current_nft_count() == current_nft_count + 1
 
     # Tests get NFT template
-    nft_template_address = get_address_of_type(config, ERC721NFT.CONTRACT_NAME, "1")
-    nft_template = erc721_factory.get_nft_template(1)
+    nft_template_address = get_address_of_type(config, DataNFT.CONTRACT_NAME, "1")
+    nft_template = data_nft_factory.get_nft_template(1)
     assert nft_template[0] == nft_template_address
     assert nft_template[1] is True
 
     # Tests creating successfully an ERC20 token
-    erc721_nft.add_to_create_erc20_list(consumer_wallet.address, publisher_wallet)
-    tx_result = erc721_nft.create_erc20(
+    data_nft.add_to_create_erc20_list(consumer_wallet.address, publisher_wallet)
+    tx_result = data_nft.create_erc20(
         template_index=1,
         name="ERC20DT1",
         symbol="ERC20DT1Symbol",
@@ -563,8 +564,8 @@ def test_start_multiple_order(
     )
     assert tx_result, "Failed to create ERC20 token."
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx_result)
-    registered_token_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_token_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -573,33 +574,33 @@ def test_start_multiple_order(
     erc20_address = registered_token_event[0].args.newTokenAddress
 
     # Tests templateCount function (one of them should be the Enterprise template)
-    assert erc721_factory.template_count() == 2
+    assert data_nft_factory.template_count() == 2
 
     # Tests ERC20 token template list
-    erc20_template_address = get_address_of_type(config, ERC20Token.CONTRACT_NAME, "1")
-    template = erc721_factory.get_token_template(1)
+    erc20_template_address = get_address_of_type(config, Datatoken.CONTRACT_NAME, "1")
+    template = data_nft_factory.get_token_template(1)
     assert template[0] == erc20_template_address
     assert template[1] is True
 
     # Tests current token template (one of them should be the Enterprise template)
-    assert erc721_factory.get_current_template_count() == 2
+    assert data_nft_factory.get_current_template_count() == 2
 
     # Tests erc20 can be checked as deployed by the factory
-    assert erc721_factory.check_datatoken(erc20_address)
+    assert data_nft_factory.check_datatoken(erc20_address)
 
     # Tests starting multiple token orders successfully
-    erc20_token = ERC20Token(web3, erc20_address)
+    datatoken = Datatoken(web3, erc20_address)
     dt_amount = to_wei("2")
     mock_dai_contract_address = get_address_of_type(config, "MockDAI")
-    assert erc20_token.balanceOf(consumer_wallet.address) == 0
+    assert datatoken.balanceOf(consumer_wallet.address) == 0
 
-    erc20_token.add_minter(consumer_wallet.address, publisher_wallet)
-    erc20_token.mint(consumer_wallet.address, dt_amount, consumer_wallet)
-    assert erc20_token.balanceOf(consumer_wallet.address) == dt_amount
+    datatoken.add_minter(consumer_wallet.address, publisher_wallet)
+    datatoken.mint(consumer_wallet.address, dt_amount, consumer_wallet)
+    assert datatoken.balanceOf(consumer_wallet.address) == dt_amount
 
-    erc20_token.approve(erc721_factory_address, dt_amount, consumer_wallet)
+    datatoken.approve(data_nft_factory_address, dt_amount, consumer_wallet)
 
-    erc20_token.set_payment_collector(another_consumer_wallet.address, publisher_wallet)
+    datatoken.set_payment_collector(another_consumer_wallet.address, publisher_wallet)
 
     provider_fee_token = mock_dai_contract_address
     provider_fee_amount = 0
@@ -643,12 +644,12 @@ def test_start_multiple_order(
 
     orders = [order_data, order_data]
 
-    tx = erc721_factory.start_multiple_token_order(orders, consumer_wallet)
+    tx = data_nft_factory.start_multiple_token_order(orders, consumer_wallet)
 
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
 
-    registered_erc20_start_order_event = erc20_token.get_event_log(
-        ERC20Token.EVENT_ORDER_STARTED,
+    registered_erc20_start_order_event = datatoken.get_event_log(
+        Datatoken.EVENT_ORDER_STARTED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -659,32 +660,30 @@ def test_start_multiple_order(
         registered_erc20_start_order_event[0].args.consumer == consumer_wallet.address
     )
 
-    assert erc20_token.balanceOf(consumer_wallet.address) == 0
-    assert erc20_token.balanceOf(erc20_token.get_payment_collector()) == (
-        dt_amount * 0.97
-    )
+    assert datatoken.balanceOf(consumer_wallet.address) == 0
+    assert datatoken.balanceOf(datatoken.get_payment_collector()) == (dt_amount * 0.97)
 
 
 @pytest.mark.unit
 def test_fail_get_templates(web3, config):
     """Tests multiple failures for getting tokens' templates."""
-    erc721_factory_address = get_address_of_type(
-        config, ERC721FactoryContract.CONTRACT_NAME
+    data_nft_factory_address = get_address_of_type(
+        config, DataNFTFactoryContract.CONTRACT_NAME
     )
-    erc721_factory = ERC721FactoryContract(web3, erc721_factory_address)
+    data_nft_factory = DataNFTFactoryContract(web3, data_nft_factory_address)
 
-    # Should fail to get the ERC20token template if index = 0
+    # Should fail to get the Datatoken template if index = 0
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_factory.get_token_template(0)
+        data_nft_factory.get_token_template(0)
     assert (
         err.value.args[0]
         == "execution reverted: VM Exception while processing transaction: revert ERC20Factory: "
         "Template index doesnt exist"
     )
 
-    # Should fail to get the ERC20token template if index > templateCount
+    # Should fail to get the Datatoken template if index > templateCount
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_factory.get_token_template(3)
+        data_nft_factory.get_token_template(3)
     assert (
         err.value.args[0]
         == "execution reverted: VM Exception while processing transaction: revert ERC20Factory: "
@@ -698,12 +697,12 @@ def test_fail_create_erc20(
 ):
     """Tests multiple failures for creating ERC20 token."""
 
-    erc721_factory_address = get_address_of_type(
-        config, ERC721FactoryContract.CONTRACT_NAME
+    data_nft_factory_address = get_address_of_type(
+        config, DataNFTFactoryContract.CONTRACT_NAME
     )
-    erc721_factory = ERC721FactoryContract(web3, erc721_factory_address)
+    data_nft_factory = DataNFTFactoryContract(web3, data_nft_factory_address)
 
-    tx = erc721_factory.deploy_erc721_contract(
+    tx = data_nft_factory.deploy_erc721_contract(
         name="DT1",
         symbol="DTSYMBOL",
         template_index=1,
@@ -715,8 +714,8 @@ def test_fail_create_erc20(
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -724,12 +723,12 @@ def test_fail_create_erc20(
     assert registered_event[0].event == "NFTCreated"
     assert registered_event[0].args.admin == publisher_wallet.address
     token_address = registered_event[0].args.newTokenAddress
-    erc721_nft = ERC721NFT(web3, token_address)
-    erc721_nft.add_to_create_erc20_list(consumer_wallet.address, publisher_wallet)
+    data_nft = DataNFT(web3, token_address)
+    data_nft.add_to_create_erc20_list(consumer_wallet.address, publisher_wallet)
 
     # Should fail to create a specific ERC20 Template if the index is ZERO
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.create_erc20(
+        data_nft.create_erc20(
             template_index=0,
             name="ERC20DT1",
             symbol="ERC20DT1Symbol",
@@ -749,7 +748,7 @@ def test_fail_create_erc20(
 
     # Should fail to create a specific ERC20 Template if the index doesn't exist
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.create_erc20(
+        data_nft.create_erc20(
             template_index=3,
             name="ERC20DT1",
             symbol="ERC20DT1Symbol",
@@ -768,9 +767,9 @@ def test_fail_create_erc20(
     )
 
     # Should fail to create a specific ERC20 Template if the user is not added on the ERC20 deployers list
-    assert erc721_nft.get_permissions(another_consumer_wallet.address)[1] is False
+    assert data_nft.get_permissions(another_consumer_wallet.address)[1] is False
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.create_erc20(
+        data_nft.create_erc20(
             template_index=1,
             name="ERC20DT1",
             symbol="ERC20DT1Symbol",
@@ -793,14 +792,14 @@ def test_fail_create_erc20(
 def test_datatoken_cap(
     web3, config, publisher_wallet, consumer_wallet, another_consumer_wallet
 ):
-    erc721_factory_address = get_address_of_type(
-        config, ERC721FactoryContract.CONTRACT_NAME
+    data_nft_factory_address = get_address_of_type(
+        config, DataNFTFactoryContract.CONTRACT_NAME
     )
-    erc721_factory = ERC721FactoryContract(web3, erc721_factory_address)
+    data_nft_factory = DataNFTFactoryContract(web3, data_nft_factory_address)
 
     # create NFT with ERC20
-    with pytest.raises(Exception, match="Cap is needed for ERC20 Enterprise"):
-        erc721_factory.create_nft_with_erc20(
+    with pytest.raises(Exception, match="Cap is needed for Datatoken Enterprise"):
+        data_nft_factory.create_nft_with_erc20(
             nft_name="72120Bundle",
             nft_symbol="72Bundle",
             nft_template=1,
@@ -822,8 +821,8 @@ def test_datatoken_cap(
     # create NFT with ERC20 and pool
     initial_pool_liquidity = to_wei("0.02")
 
-    with pytest.raises(Exception, match="Cap is needed for ERC20 Enterprise"):
-        erc721_factory.create_nft_erc20_with_pool(
+    with pytest.raises(Exception, match="Cap is needed for Datatoken Enterprise"):
+        data_nft_factory.create_nft_erc20_with_pool(
             nft_name="72120Bundle",
             nft_symbol="72Bundle",
             nft_template=1,
@@ -831,7 +830,7 @@ def test_datatoken_cap(
             nft_transferable=True,
             nft_owner=publisher_wallet.address,
             datatoken_template=2,
-            datatoken_name="ERC20EnterpriseWithPool",
+            datatoken_name="DatatokenEnterpriseWithPool",
             datatoken_symbol="ERC20EP",
             datatoken_minter=publisher_wallet.address,
             datatoken_fee_manager=consumer_wallet.address,
@@ -846,15 +845,15 @@ def test_datatoken_cap(
             pool_publish_market_swap_fee_amount=to_wei("0.001"),
             pool_side_staking=ZERO_ADDRESS,
             pool_base_token=ZERO_ADDRESS,
-            pool_base_token_sender=erc721_factory_address,
+            pool_base_token_sender=data_nft_factory_address,
             pool_publisher=publisher_wallet.address,
             pool_publish_market_swap_fee_collector=consumer_wallet.address,
             pool_template_address=ZERO_ADDRESS,
             from_wallet=publisher_wallet,
         )
 
-    with pytest.raises(Exception, match="Cap is needed for ERC20 Enterprise"):
-        erc721_factory.create_nft_erc20_with_fixed_rate(
+    with pytest.raises(Exception, match="Cap is needed for Datatoken Enterprise"):
+        data_nft_factory.create_nft_erc20_with_fixed_rate(
             nft_name="72120Bundle",
             nft_symbol="72Bundle",
             nft_template=1,
@@ -883,8 +882,8 @@ def test_datatoken_cap(
             from_wallet=publisher_wallet,
         )
 
-    with pytest.raises(Exception, match="Cap is needed for ERC20 Enterprise"):
-        erc721_factory.create_nft_erc20_with_dispenser(
+    with pytest.raises(Exception, match="Cap is needed for Datatoken Enterprise"):
+        data_nft_factory.create_nft_erc20_with_dispenser(
             nft_name="72120Bundle",
             nft_symbol="72Bundle",
             nft_template=1,
diff --git a/ocean_lib/models/test/test_erc20_token.py b/ocean_lib/models/test/test_datatoken.py
similarity index 66%
rename from ocean_lib/models/test/test_erc20_token.py
rename to ocean_lib/models/test/test_datatoken.py
index 46f719faf..45ab027a1 100644
--- a/ocean_lib/models/test/test_erc20_token.py
+++ b/ocean_lib/models/test/test_datatoken.py
@@ -8,8 +8,8 @@
 from web3 import exceptions
 from web3.main import Web3
 
-from ocean_lib.models.erc20_token import ERC20Token, RolesERC20
-from ocean_lib.models.erc721_nft import ERC721NFT
+from ocean_lib.models.data_nft import DataNFT
+from ocean_lib.models.datatoken import Datatoken, DatatokenRoles
 from ocean_lib.web3_internal.constants import MAX_UINT256
 from ocean_lib.web3_internal.currency import to_wei
 from ocean_lib.web3_internal.utils import split_signature
@@ -18,34 +18,28 @@
 
 
 @pytest.mark.unit
-def test_properties(erc20_token):
+def test_properties(datatoken):
     """Tests the events' properties."""
-    assert erc20_token.event_NewPool.abi["name"] == ERC20Token.EVENT_NEW_POOL
-    assert erc20_token.event_NewFixedRate.abi["name"] == ERC20Token.EVENT_NEW_FIXED_RATE
+    assert datatoken.event_NewPool.abi["name"] == Datatoken.EVENT_NEW_POOL
+    assert datatoken.event_NewFixedRate.abi["name"] == Datatoken.EVENT_NEW_FIXED_RATE
+    assert datatoken.event_MinterProposed.abi["name"] == Datatoken.EVENT_MINTER_PROPOSED
+    assert datatoken.event_OrderStarted.abi["name"] == Datatoken.EVENT_ORDER_STARTED
+    assert datatoken.event_MinterApproved.abi["name"] == Datatoken.EVENT_MINTER_APPROVED
+    assert datatoken.event_OrderReused.abi["name"] == Datatoken.EVENT_ORDER_REUSED
+    assert datatoken.event_OrderExecuted.abi["name"] == Datatoken.EVENT_ORDER_EXECUTED
     assert (
-        erc20_token.event_MinterProposed.abi["name"] == ERC20Token.EVENT_MINTER_PROPOSED
+        datatoken.event_PublishMarketFeeChanged.abi["name"]
+        == Datatoken.EVENT_PUBLISH_MARKET_FEE_CHANGED
     )
-    assert erc20_token.event_OrderStarted.abi["name"] == ERC20Token.EVENT_ORDER_STARTED
     assert (
-        erc20_token.event_MinterApproved.abi["name"] == ERC20Token.EVENT_MINTER_APPROVED
+        datatoken.event_PublishMarketFee.abi["name"]
+        == Datatoken.EVENT_PUBLISH_MARKET_FEE
     )
-    assert erc20_token.event_OrderReused.abi["name"] == ERC20Token.EVENT_ORDER_REUSED
     assert (
-        erc20_token.event_OrderExecuted.abi["name"] == ERC20Token.EVENT_ORDER_EXECUTED
+        datatoken.event_ConsumeMarketFee.abi["name"]
+        == Datatoken.EVENT_CONSUME_MARKET_FEE
     )
-    assert (
-        erc20_token.event_PublishMarketFeeChanged.abi["name"]
-        == ERC20Token.EVENT_PUBLISH_MARKET_FEE_CHANGED
-    )
-    assert (
-        erc20_token.event_PublishMarketFee.abi["name"]
-        == ERC20Token.EVENT_PUBLISH_MARKET_FEE
-    )
-    assert (
-        erc20_token.event_ConsumeMarketFee.abi["name"]
-        == ERC20Token.EVENT_CONSUME_MARKET_FEE
-    )
-    assert erc20_token.event_ProviderFee.abi["name"] == ERC20Token.EVENT_PROVIDER_FEE
+    assert datatoken.event_ProviderFee.abi["name"] == Datatoken.EVENT_PROVIDER_FEE
 
 
 @pytest.mark.unit
@@ -53,98 +47,98 @@ def test_main(
     web3: Web3,
     publisher_wallet: Wallet,
     consumer_wallet: Wallet,
-    erc721_nft: ERC721NFT,
-    erc20_token: ERC20Token,
+    data_nft: DataNFT,
+    datatoken: Datatoken,
 ):
     """Tests successful function calls"""
 
     # Check erc20 params
-    assert erc20_token.get_id() == 1
-    assert erc20_token.contract.caller.name() == "ERC20DT1"
-    assert erc20_token.symbol() == "ERC20DT1Symbol"
-    assert erc20_token.decimals() == 18
-    assert erc20_token.cap() == MAX_UINT256
+    assert datatoken.get_id() == 1
+    assert datatoken.contract.caller.name() == "ERC20DT1"
+    assert datatoken.symbol() == "ERC20DT1Symbol"
+    assert datatoken.decimals() == 18
+    assert datatoken.cap() == MAX_UINT256
 
     # Check erc721 address
-    assert erc20_token.get_erc721_address() == erc721_nft.address
+    assert datatoken.get_erc721_address() == data_nft.address
 
-    # Check that the erc20Token contract is initialized
-    assert erc20_token.is_initialized()
+    # Check that the Datatoken contract is initialized
+    assert datatoken.is_initialized()
 
     # Check publish market payment collector
-    assert erc20_token.get_payment_collector() == publisher_wallet.address
+    assert datatoken.get_payment_collector() == publisher_wallet.address
 
     # Set payment collector to consumer
-    erc20_token.set_payment_collector(
+    datatoken.set_payment_collector(
         publish_market_order_fee_address=consumer_wallet.address,
         from_wallet=publisher_wallet,
     )
-    assert erc20_token.get_payment_collector() == consumer_wallet.address
+    assert datatoken.get_payment_collector() == consumer_wallet.address
 
     # Check minter permissions
-    assert erc20_token.get_permissions(publisher_wallet.address)[RolesERC20.MINTER]
-    assert erc20_token.is_minter(publisher_wallet.address)
+    assert datatoken.get_permissions(publisher_wallet.address)[DatatokenRoles.MINTER]
+    assert datatoken.is_minter(publisher_wallet.address)
 
-    # Mint ERC20Token to user2 from publisher
-    erc20_token.mint(consumer_wallet.address, 1, publisher_wallet)
-    assert erc20_token.balanceOf(consumer_wallet.address) == 1
+    # Mint Datatoken to user2 from publisher
+    datatoken.mint(consumer_wallet.address, 1, publisher_wallet)
+    assert datatoken.balanceOf(consumer_wallet.address) == 1
 
     # Add minter
-    assert not erc20_token.get_permissions(consumer_wallet.address)[RolesERC20.MINTER]
-    erc20_token.add_minter(consumer_wallet.address, publisher_wallet)
-    assert erc20_token.get_permissions(consumer_wallet.address)[RolesERC20.MINTER]
+    assert not datatoken.get_permissions(consumer_wallet.address)[DatatokenRoles.MINTER]
+    datatoken.add_minter(consumer_wallet.address, publisher_wallet)
+    assert datatoken.get_permissions(consumer_wallet.address)[DatatokenRoles.MINTER]
 
-    # Mint ERC20Token to user2 from consumer
-    erc20_token.mint(consumer_wallet.address, 1, consumer_wallet)
-    assert erc20_token.balanceOf(consumer_wallet.address) == 2
+    # Mint Datatoken to user2 from consumer
+    datatoken.mint(consumer_wallet.address, 1, consumer_wallet)
+    assert datatoken.balanceOf(consumer_wallet.address) == 2
 
     # Should succeed to removeMinter if erc20Deployer
-    erc20_token.remove_minter(consumer_wallet.address, publisher_wallet)
-    assert not erc20_token.get_permissions(consumer_wallet.address)[RolesERC20.MINTER]
+    datatoken.remove_minter(consumer_wallet.address, publisher_wallet)
+    assert not datatoken.get_permissions(consumer_wallet.address)[DatatokenRoles.MINTER]
 
     # Should succeed to addFeeManager if erc20Deployer (permission to deploy the erc20Contract at 721 level)
-    assert not erc20_token.get_permissions(consumer_wallet.address)[
-        RolesERC20.PAYMENT_MANAGER
+    assert not datatoken.get_permissions(consumer_wallet.address)[
+        DatatokenRoles.PAYMENT_MANAGER
     ]
-    erc20_token.add_payment_manager(consumer_wallet.address, publisher_wallet)
-    assert erc20_token.get_permissions(consumer_wallet.address)[
-        RolesERC20.PAYMENT_MANAGER
+    datatoken.add_payment_manager(consumer_wallet.address, publisher_wallet)
+    assert datatoken.get_permissions(consumer_wallet.address)[
+        DatatokenRoles.PAYMENT_MANAGER
     ]
 
     # Should succeed to removeFeeManager if erc20Deployer
-    erc20_token.remove_payment_manager(
+    datatoken.remove_payment_manager(
         fee_manager=consumer_wallet.address, from_wallet=publisher_wallet
     )
-    assert not erc20_token.get_permissions(consumer_wallet.address)[
-        RolesERC20.PAYMENT_MANAGER
+    assert not datatoken.get_permissions(consumer_wallet.address)[
+        DatatokenRoles.PAYMENT_MANAGER
     ]
 
     # Should succeed to setData if erc20Deployer
     value = web3.toHex(text="SomeData")
-    key = web3.keccak(hexstr=erc20_token.address)
+    key = web3.keccak(hexstr=datatoken.address)
 
-    erc20_token.set_data(data=value, from_wallet=publisher_wallet)
+    datatoken.set_data(data=value, from_wallet=publisher_wallet)
 
-    assert web3.toHex(erc721_nft.get_data(key)) == value
+    assert web3.toHex(data_nft.get_data(key)) == value
 
     # Should succeed to call cleanPermissions if NFTOwner
-    erc20_token.clean_permissions(from_wallet=publisher_wallet)
+    datatoken.clean_permissions(from_wallet=publisher_wallet)
 
-    permissions = erc20_token.get_permissions(publisher_wallet.address)
-    assert not permissions[RolesERC20.MINTER]
-    assert not permissions[RolesERC20.PAYMENT_MANAGER]
+    permissions = datatoken.get_permissions(publisher_wallet.address)
+    assert not permissions[DatatokenRoles.MINTER]
+    assert not permissions[DatatokenRoles.PAYMENT_MANAGER]
 
 
 def test_start_order(
-    web3, config, publisher_wallet, consumer_wallet, erc721_nft, erc20_token
+    web3, config, publisher_wallet, consumer_wallet, data_nft, datatoken
 ):
     """Tests startOrder functionality without publish fees, consume fees."""
     # Mint erc20 tokens to use
-    erc20_token.mint(consumer_wallet.address, to_wei("10"), publisher_wallet)
-    erc20_token.mint(publisher_wallet.address, to_wei("10"), publisher_wallet)
+    datatoken.mint(consumer_wallet.address, to_wei("10"), publisher_wallet)
+    datatoken.mint(publisher_wallet.address, to_wei("10"), publisher_wallet)
 
     # Set the fee collector address
-    erc20_token.set_payment_collector(
+    datatoken.set_payment_collector(
         get_address_of_type(config, "OPFCommunityFeeCollector"), publisher_wallet
     )
 
@@ -166,7 +160,7 @@ def test_start_order(
     signed = web3.eth.sign(provider_fee_address, data=message)
     signature = split_signature(signed)
 
-    tx = erc20_token.start_order(
+    tx = datatoken.start_order(
         consumer=consumer_wallet.address,
         service_index=1,
         provider_fee_address=provider_fee_address,
@@ -179,14 +173,14 @@ def test_start_order(
         s=signature.s,
         valid_until=0,
         consume_market_order_fee_address=publisher_wallet.address,
-        consume_market_order_fee_token=erc20_token.address,
+        consume_market_order_fee_token=datatoken.address,
         consume_market_order_fee_amount=0,
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
     # Check erc20 balances
-    assert erc20_token.balanceOf(publisher_wallet.address) == to_wei("9")
-    assert erc20_token.balanceOf(
+    assert datatoken.balanceOf(publisher_wallet.address) == to_wei("9")
+    assert datatoken.balanceOf(
         get_address_of_type(config, "OPFCommunityFeeCollector")
     ) == to_wei("1")
 
@@ -202,7 +196,7 @@ def test_start_order(
     )
     consumer_signed = web3.eth.sign(consumer_wallet.address, data=message)
 
-    erc20_token.order_executed(
+    datatoken.order_executed(
         order_tx_id=tx_receipt.transactionHash,
         provider_data=Web3.toHex(Web3.toBytes(text=provider_data)),
         provider_signature=provider_signed,
@@ -211,8 +205,8 @@ def test_start_order(
         consumer=consumer_wallet.address,
         from_wallet=publisher_wallet,
     )
-    executed_event = erc20_token.get_event_log(
-        ERC20Token.EVENT_ORDER_EXECUTED,
+    executed_event = datatoken.get_event_log(
+        Datatoken.EVENT_ORDER_EXECUTED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -224,7 +218,7 @@ def test_start_order(
     # Tests exceptions for order_executed
     consumer_signed = web3.eth.sign(provider_fee_address, data=message)
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.order_executed(
+        datatoken.order_executed(
             tx_receipt.transactionHash,
             provider_data=Web3.toHex(Web3.toBytes(text=provider_data)),
             provider_signature=provider_signed,
@@ -245,7 +239,7 @@ def test_start_order(
     consumer_signed = web3.eth.sign(consumer_wallet.address, data=message)
 
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.order_executed(
+        datatoken.order_executed(
             tx_receipt.transactionHash,
             provider_data=Web3.toHex(Web3.toBytes(text=provider_data)),
             provider_signature=signed,
@@ -260,7 +254,7 @@ def test_start_order(
     )
 
     # Tests reuses order
-    erc20_token.reuse_order(
+    datatoken.reuse_order(
         tx_receipt.transactionHash,
         provider_fee_address=provider_fee_address,
         provider_fee_token=provider_fee_token,
@@ -273,8 +267,8 @@ def test_start_order(
         # make it compatible with last openzepellin https://github.com/OpenZeppelin/openzeppelin-contracts/pull/1622
         from_wallet=publisher_wallet,
     )
-    reused_event = erc20_token.get_event_log(
-        ERC20Token.EVENT_ORDER_REUSED,
+    reused_event = datatoken.get_event_log(
+        Datatoken.EVENT_ORDER_REUSED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -283,8 +277,8 @@ def test_start_order(
     assert reused_event[0].args.orderTxId == tx_receipt.transactionHash
     assert reused_event[0].args.caller == publisher_wallet.address
 
-    provider_fee_event = erc20_token.get_event_log(
-        ERC20Token.EVENT_PROVIDER_FEE,
+    provider_fee_event = datatoken.get_event_log(
+        Datatoken.EVENT_PROVIDER_FEE,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -292,14 +286,14 @@ def test_start_order(
     assert provider_fee_event[0].event == "ProviderFee", "Cannot find ProviderFee event"
 
     # Set and get publishing market fee params
-    erc20_token.set_publishing_market_fee(
+    datatoken.set_publishing_market_fee(
         publish_market_order_fee_address=publisher_wallet.address,
         publish_market_order_fee_token=get_address_of_type(config, "MockUSDC"),
         publish_market_order_fee_amount=to_wei("1.2"),
         from_wallet=publisher_wallet,
     )
 
-    publish_fees = erc20_token.get_publishing_market_fee()
+    publish_fees = datatoken.get_publishing_market_fee()
 
     # PublishMarketFeeAddress set previously
     assert publish_fees[0] == publisher_wallet.address
@@ -308,57 +302,57 @@ def test_start_order(
     # PublishMarketFeeAmount set previously
     assert publish_fees[2] == to_wei("1.2")
     # Fee collector
-    assert erc20_token.get_payment_collector() == get_address_of_type(
+    assert datatoken.get_payment_collector() == get_address_of_type(
         config, "OPFCommunityFeeCollector"
     )
 
     # Publisher should succeed to burn some consumer's tokens using burnFrom
-    initial_total_supply = erc20_token.get_total_supply()
-    initial_consumer_balance = erc20_token.balanceOf(consumer_wallet.address)
+    initial_total_supply = datatoken.get_total_supply()
+    initial_consumer_balance = datatoken.balanceOf(consumer_wallet.address)
 
     # Approve publisher to burn
-    erc20_token.approve(publisher_wallet.address, to_wei("10"), consumer_wallet)
+    datatoken.approve(publisher_wallet.address, to_wei("10"), consumer_wallet)
 
-    allowance = erc20_token.allowance(consumer_wallet.address, publisher_wallet.address)
+    allowance = datatoken.allowance(consumer_wallet.address, publisher_wallet.address)
     assert allowance == to_wei("10")
-    erc20_token.burn_from(consumer_wallet.address, to_wei("2"), publisher_wallet)
+    datatoken.burn_from(consumer_wallet.address, to_wei("2"), publisher_wallet)
 
-    assert erc20_token.get_total_supply() == initial_total_supply - to_wei("2")
-    assert erc20_token.balanceOf(
+    assert datatoken.get_total_supply() == initial_total_supply - to_wei("2")
+    assert datatoken.balanceOf(
         consumer_wallet.address
     ) == initial_consumer_balance - to_wei("2")
 
     # Test transterFrom too
-    initial_consumer_balance = erc20_token.balanceOf(consumer_wallet.address)
-    erc20_token.transferFrom(
+    initial_consumer_balance = datatoken.balanceOf(consumer_wallet.address)
+    datatoken.transferFrom(
         consumer_wallet.address, publisher_wallet.address, to_wei("1"), publisher_wallet
     )
-    assert erc20_token.balanceOf(
+    assert datatoken.balanceOf(
         consumer_wallet.address
     ) == initial_consumer_balance - to_wei("1")
 
     # Consumer should be able to burn his tokens too
-    initial_consumer_balance = erc20_token.balanceOf(consumer_wallet.address)
-    erc20_token.burn(to_wei("1"), consumer_wallet)
-    assert erc20_token.balanceOf(
+    initial_consumer_balance = datatoken.balanceOf(consumer_wallet.address)
+    datatoken.burn(to_wei("1"), consumer_wallet)
+    assert datatoken.balanceOf(
         consumer_wallet.address
     ) == initial_consumer_balance - to_wei("1")
 
     # Consumer should be able to transfer too
-    initial_consumer_balance = erc20_token.balanceOf(consumer_wallet.address)
-    erc20_token.transfer(publisher_wallet.address, to_wei("1"), consumer_wallet)
-    assert erc20_token.balanceOf(
+    initial_consumer_balance = datatoken.balanceOf(consumer_wallet.address)
+    datatoken.transfer(publisher_wallet.address, to_wei("1"), consumer_wallet)
+    assert datatoken.balanceOf(
         consumer_wallet.address
     ) == initial_consumer_balance - to_wei("1")
 
 
 @pytest.mark.unit
-def test_exceptions(web3, consumer_wallet, erc20_token):
+def test_exceptions(web3, consumer_wallet, datatoken):
     """Tests revert statements in contracts functions"""
 
     # Should fail to mint if wallet is not a minter
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.mint(
+        datatoken.mint(
             account_address=consumer_wallet.address,
             value=to_wei("1"),
             from_wallet=consumer_wallet,
@@ -370,7 +364,7 @@ def test_exceptions(web3, consumer_wallet, erc20_token):
 
     #  Should fail to set new FeeCollector if not NFTOwner
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.set_payment_collector(
+        datatoken.set_payment_collector(
             publish_market_order_fee_address=consumer_wallet.address,
             from_wallet=consumer_wallet,
         )
@@ -381,7 +375,7 @@ def test_exceptions(web3, consumer_wallet, erc20_token):
 
     # Should fail to addMinter if not erc20Deployer (permission to deploy the erc20Contract at 721 level)
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.add_minter(
+        datatoken.add_minter(
             minter_address=consumer_wallet.address, from_wallet=consumer_wallet
         )
     assert (
@@ -391,7 +385,7 @@ def test_exceptions(web3, consumer_wallet, erc20_token):
 
     #  Should fail to removeMinter even if it's minter
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.remove_minter(
+        datatoken.remove_minter(
             minter_address=consumer_wallet.address, from_wallet=consumer_wallet
         )
     assert (
@@ -401,7 +395,7 @@ def test_exceptions(web3, consumer_wallet, erc20_token):
 
     # Should fail to addFeeManager if not erc20Deployer (permission to deploy the erc20Contract at 721 level)
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.add_payment_manager(
+        datatoken.add_payment_manager(
             fee_manager=consumer_wallet.address, from_wallet=consumer_wallet
         )
     assert (
@@ -411,7 +405,7 @@ def test_exceptions(web3, consumer_wallet, erc20_token):
 
     # Should fail to removeFeeManager if NOT erc20Deployer
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.remove_payment_manager(
+        datatoken.remove_payment_manager(
             fee_manager=consumer_wallet.address, from_wallet=consumer_wallet
         )
     assert (
@@ -421,7 +415,7 @@ def test_exceptions(web3, consumer_wallet, erc20_token):
 
     # Should fail to setData if NOT erc20Deployer
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.set_data(
+        datatoken.set_data(
             data=web3.toHex(text="SomeData"), from_wallet=consumer_wallet
         )
     assert (
@@ -431,7 +425,7 @@ def test_exceptions(web3, consumer_wallet, erc20_token):
 
     # Should fail to call cleanPermissions if NOT NFTOwner
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.clean_permissions(from_wallet=consumer_wallet)
+        datatoken.clean_permissions(from_wallet=consumer_wallet)
     assert (
         err.value.args[0]
         == "execution reverted: VM Exception while processing transaction: revert ERC20Template: not NFTOwner"
@@ -439,7 +433,7 @@ def test_exceptions(web3, consumer_wallet, erc20_token):
 
     # Clean from nft should work shouldn't be callable by publisher or consumer, only by erc721 contract
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.clean_from_721(from_wallet=consumer_wallet)
+        datatoken.clean_from_721(from_wallet=consumer_wallet)
     assert (
         err.value.args[0]
         == "execution reverted: VM Exception while processing transaction: revert ERC20Template: NOT 721 Contract"
diff --git a/ocean_lib/models/test/test_erc20_enterprise.py b/ocean_lib/models/test/test_datatoken_enterprise.py
similarity index 83%
rename from ocean_lib/models/test/test_erc20_enterprise.py
rename to ocean_lib/models/test/test_datatoken_enterprise.py
index 9bf64f7e9..22e1cd820 100644
--- a/ocean_lib/models/test/test_erc20_enterprise.py
+++ b/ocean_lib/models/test/test_datatoken_enterprise.py
@@ -8,8 +8,8 @@
 from web3 import exceptions
 from web3.main import Web3
 
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.models.dispenser import Dispenser
-from ocean_lib.models.erc20_token import ERC20Token
 from ocean_lib.models.fixed_rate_exchange import FixedRateExchange
 from ocean_lib.web3_internal.constants import ZERO_ADDRESS
 from ocean_lib.web3_internal.currency import to_wei
@@ -24,14 +24,14 @@ def test_buy_from_dispenser_and_order(
     publisher_wallet,
     consumer_wallet,
     factory_deployer_wallet,
-    erc20_enterprise_token,
+    datatoken_enterprise_token,
 ):
-    """Tests buy_from_dispenser_and_order function of the ERC20 Enterprise"""
-    mock_usdc_contract = ERC20Token(web3, get_address_of_type(config, "MockUSDC"))
-    mock_dai_contract = ERC20Token(web3, get_address_of_type(config, "MockDAI"))
+    """Tests buy_from_dispenser_and_order function of the Datatoken Enterprise"""
+    mock_usdc_contract = Datatoken(web3, get_address_of_type(config, "MockUSDC"))
+    mock_dai_contract = Datatoken(web3, get_address_of_type(config, "MockDAI"))
     dispenser = Dispenser(web3, get_address_of_type(config, "Dispenser"))
 
-    tx = erc20_enterprise_token.create_dispenser(
+    tx = datatoken_enterprise_token.create_dispenser(
         dispenser_address=dispenser.address,
         allowed_swapper=ZERO_ADDRESS,
         max_balance=to_wei("1"),
@@ -42,7 +42,7 @@ def test_buy_from_dispenser_and_order(
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
     assert tx_receipt.status == 1
 
-    status = dispenser.status(erc20_enterprise_token.address)
+    status = dispenser.status(datatoken_enterprise_token.address)
 
     assert status[0] is True
     assert status[1] == publisher_wallet.address
@@ -50,7 +50,7 @@ def test_buy_from_dispenser_and_order(
 
     with pytest.raises(exceptions.ContractLogicError) as err:
         dispenser.dispense(
-            datatoken=erc20_enterprise_token.address,
+            datatoken=datatoken_enterprise_token.address,
             amount=to_wei("1"),
             destination=consumer_wallet.address,
             from_wallet=consumer_wallet,
@@ -63,13 +63,13 @@ def test_buy_from_dispenser_and_order(
 
     consume_fee_amount = to_wei("2")
     consume_fee_address = consumer_wallet.address
-    erc20_enterprise_token.set_publishing_market_fee(
+    datatoken_enterprise_token.set_publishing_market_fee(
         publish_market_order_fee_address=consume_fee_address,
         publish_market_order_fee_token=mock_usdc_contract.address,
         publish_market_order_fee_amount=consume_fee_amount,
         from_wallet=publisher_wallet,
     )
-    publish_fees = erc20_enterprise_token.get_publishing_market_fee()
+    publish_fees = datatoken_enterprise_token.get_publishing_market_fee()
 
     mock_usdc_contract.transfer(
         to=publisher_wallet.address,
@@ -78,7 +78,7 @@ def test_buy_from_dispenser_and_order(
     )
 
     mock_usdc_contract.approve(
-        spender=erc20_enterprise_token.address,
+        spender=datatoken_enterprise_token.address,
         amount=consume_fee_amount,
         from_wallet=publisher_wallet,
     )
@@ -90,7 +90,7 @@ def test_buy_from_dispenser_and_order(
     )
 
     mock_dai_contract.approve(
-        spender=erc20_enterprise_token.address,
+        spender=datatoken_enterprise_token.address,
         amount=consume_fee_amount,
         from_wallet=publisher_wallet,
     )
@@ -119,7 +119,7 @@ def test_buy_from_dispenser_and_order(
     balance_opf_consume_before = mock_dai_contract.balanceOf(opf_collector_address)
     balance_publish_before = mock_usdc_contract.balanceOf(consumer_wallet.address)
 
-    tx = erc20_enterprise_token.buy_from_dispenser_and_order(
+    tx = datatoken_enterprise_token.buy_from_dispenser_and_order(
         consumer=consume_fee_address,
         service_index=1,
         provider_fee_address=provider_fee_address,
@@ -139,7 +139,7 @@ def test_buy_from_dispenser_and_order(
 
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
     assert tx_receipt.status == 1
-    assert erc20_enterprise_token.get_total_supply() == to_wei("0")
+    assert datatoken_enterprise_token.get_total_supply() == to_wei("0")
 
     balance_opf_consume = mock_dai_contract.balanceOf(opf_collector_address)
     balance_publish = mock_usdc_contract.balanceOf(publish_fees[0])
@@ -148,7 +148,9 @@ def test_buy_from_dispenser_and_order(
     assert balance_publish - balance_publish_before == to_wei("2")
 
     assert (
-        erc20_enterprise_token.balanceOf(erc20_enterprise_token.get_payment_collector())
+        datatoken_enterprise_token.balanceOf(
+            datatoken_enterprise_token.get_payment_collector()
+        )
         == 0
     )
 
@@ -161,16 +163,16 @@ def test_buy_from_fre_and_order(
     consumer_wallet,
     factory_deployer_wallet,
     another_consumer_wallet,
-    erc20_enterprise_token,
+    datatoken_enterprise_token,
 ):
-    """Tests buy_from_fre_and_order function of the ERC20 Enterprise"""
-    mock_usdc_contract = ERC20Token(web3, get_address_of_type(config, "MockUSDC"))
-    mock_dai_contract = ERC20Token(web3, get_address_of_type(config, "MockDAI"))
+    """Tests buy_from_fre_and_order function of the Datatoken Enterprise"""
+    mock_usdc_contract = Datatoken(web3, get_address_of_type(config, "MockUSDC"))
+    mock_dai_contract = Datatoken(web3, get_address_of_type(config, "MockDAI"))
     fixed_rate_exchange = FixedRateExchange(
         web3, get_address_of_type(config, "FixedPrice")
     )
 
-    tx = erc20_enterprise_token.create_fixed_rate(
+    tx = datatoken_enterprise_token.create_fixed_rate(
         fixed_price_address=fixed_rate_exchange.address,
         base_token_address=mock_usdc_contract.address,
         owner=publisher_wallet.address,
@@ -187,7 +189,7 @@ def test_buy_from_fre_and_order(
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
     assert tx_receipt.status == 1
 
-    new_fixed_rate_event = erc20_enterprise_token.get_event_log(
+    new_fixed_rate_event = datatoken_enterprise_token.get_event_log(
         "NewFixedRate",
         from_block=tx_receipt.blockNumber,
         to_block=web3.eth.block_number,
@@ -217,13 +219,13 @@ def test_buy_from_fre_and_order(
 
     consume_fee_amount = to_wei("2")
     consume_fee_address = consumer_wallet.address
-    erc20_enterprise_token.set_publishing_market_fee(
+    datatoken_enterprise_token.set_publishing_market_fee(
         publish_market_order_fee_address=consume_fee_address,
         publish_market_order_fee_token=mock_usdc_contract.address,
         publish_market_order_fee_amount=consume_fee_amount,
         from_wallet=publisher_wallet,
     )
-    publish_fees = erc20_enterprise_token.get_publishing_market_fee()
+    publish_fees = datatoken_enterprise_token.get_publishing_market_fee()
 
     mock_usdc_contract.transfer(
         to=publisher_wallet.address,
@@ -231,7 +233,7 @@ def test_buy_from_fre_and_order(
         from_wallet=factory_deployer_wallet,
     )
     mock_usdc_contract.approve(
-        spender=erc20_enterprise_token.address,
+        spender=datatoken_enterprise_token.address,
         amount=2**256 - 1,
         from_wallet=publisher_wallet,
     )
@@ -241,7 +243,7 @@ def test_buy_from_fre_and_order(
         from_wallet=factory_deployer_wallet,
     )
     mock_dai_contract.approve(
-        spender=erc20_enterprise_token.address,
+        spender=datatoken_enterprise_token.address,
         amount=consume_fee_amount,
         from_wallet=publisher_wallet,
     )
@@ -271,7 +273,7 @@ def test_buy_from_fre_and_order(
         another_consumer_wallet.address
     )
 
-    tx = erc20_enterprise_token.buy_from_fre_and_order(
+    tx = datatoken_enterprise_token.buy_from_fre_and_order(
         consumer=another_consumer_wallet.address,
         service_index=1,
         provider_fee_address=publisher_wallet.address,
@@ -295,7 +297,7 @@ def test_buy_from_fre_and_order(
 
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
     assert tx_receipt.status == 1
-    assert erc20_enterprise_token.get_total_supply() == to_wei("0")
+    assert datatoken_enterprise_token.get_total_supply() == to_wei("0")
 
     provider_fee_balance_after = mock_usdc_contract.balanceOf(
         another_consumer_wallet.address
@@ -309,6 +311,8 @@ def test_buy_from_fre_and_order(
     assert balance_publish - balance_publish_before == to_wei("2")
 
     assert (
-        erc20_enterprise_token.balanceOf(erc20_enterprise_token.get_payment_collector())
+        datatoken_enterprise_token.balanceOf(
+            datatoken_enterprise_token.get_payment_collector()
+        )
         == 0
     )
diff --git a/ocean_lib/models/test/test_dispenser.py b/ocean_lib/models/test/test_dispenser.py
index 2162ea990..2469f20d3 100644
--- a/ocean_lib/models/test/test_dispenser.py
+++ b/ocean_lib/models/test/test_dispenser.py
@@ -48,7 +48,7 @@ def test_main(
     publisher_wallet,
     consumer_wallet,
     factory_deployer_wallet,
-    erc20_token,
+    datatoken,
 ):
     """Tests the main flow of the Dispenser."""
 
@@ -56,7 +56,7 @@ def test_main(
     dispenser = Dispenser(web3, get_address_of_type(config, "Dispenser"))
 
     # Tests publisher creates a dispenser with minter role
-    tx = erc20_token.create_dispenser(
+    tx = datatoken.create_dispenser(
         dispenser_address=dispenser.address,
         max_balance=to_wei("1"),
         max_tokens=to_wei("1"),
@@ -69,7 +69,7 @@ def test_main(
 
     # Tests publisher gets the dispenser status
 
-    dispenser_status = dispenser.status(erc20_token.address)
+    dispenser_status = dispenser.status(datatoken.address)
     assert dispenser_status[0] is True
     assert dispenser_status[1] == publisher_wallet.address
     assert dispenser_status[2] is True
@@ -77,7 +77,7 @@ def test_main(
     # Tests consumer requests more datatokens then allowed transaction reverts
     with pytest.raises(exceptions.ContractLogicError) as err:
         dispenser.dispense(
-            datatoken=erc20_token.address,
+            datatoken=datatoken.address,
             amount=to_wei("20"),
             destination=consumer_wallet.address,
             from_wallet=consumer_wallet,
@@ -89,7 +89,7 @@ def test_main(
 
     # Tests consumer requests data tokens
     tx = dispenser.dispense(
-        datatoken=erc20_token.address,
+        datatoken=datatoken.address,
         amount=to_wei("1"),
         destination=consumer_wallet.address,
         from_wallet=consumer_wallet,
@@ -100,7 +100,7 @@ def test_main(
     # Tests consumer requests more datatokens then exceeds maxBalance
     with pytest.raises(exceptions.ContractLogicError) as err:
         dispenser.dispense(
-            datatoken=erc20_token.address,
+            datatoken=datatoken.address,
             amount=to_wei("1"),
             destination=consumer_wallet.address,
             from_wallet=consumer_wallet,
@@ -111,14 +111,14 @@ def test_main(
     )
 
     # Tests publisher deactivates the dispenser
-    dispenser.deactivate(from_wallet=publisher_wallet, datatoken=erc20_token.address)
-    status = dispenser.status(erc20_token.address)
+    dispenser.deactivate(from_wallet=publisher_wallet, datatoken=datatoken.address)
+    status = dispenser.status(datatoken.address)
     assert status[0] is False
 
     # Tests factory deployer should fail to get data tokens
     with pytest.raises(exceptions.ContractLogicError) as err:
         dispenser.dispense(
-            datatoken=erc20_token.address,
+            datatoken=datatoken.address,
             amount=to_wei("0.00001"),
             destination=factory_deployer_wallet.address,
             from_wallet=factory_deployer_wallet,
@@ -132,7 +132,7 @@ def test_main(
     # Tests consumer should fail to activate a dispenser for a token for he is not a minter
     with pytest.raises(exceptions.ContractLogicError) as err:
         dispenser.activate(
-            datatoken=erc20_token.address,
+            datatoken=datatoken.address,
             max_tokens=to_wei("1"),
             max_balance=to_wei("1"),
             from_wallet=consumer_wallet,
@@ -145,14 +145,14 @@ def test_main(
 
 
 def test_dispenser_creation_without_minter(
-    web3, config, publisher_wallet, consumer_wallet, erc20_token
+    web3, config, publisher_wallet, consumer_wallet, datatoken
 ):
     """Tests dispenser creation without a minter role."""
 
     # get the dispenser
     dispenser = Dispenser(web3, get_address_of_type(config, "Dispenser"))
 
-    erc20_token.create_dispenser(
+    datatoken.create_dispenser(
         dispenser_address=dispenser.address,
         max_balance=to_wei("1"),
         max_tokens=to_wei("1"),
@@ -164,7 +164,7 @@ def test_dispenser_creation_without_minter(
     # Tests consumer requests data tokens but they are not minted
     with pytest.raises(exceptions.ContractLogicError) as err:
         dispenser.dispense(
-            datatoken=erc20_token.address,
+            datatoken=datatoken.address,
             amount=to_wei("1"),
             destination=consumer_wallet.address,
             from_wallet=consumer_wallet,
@@ -176,7 +176,7 @@ def test_dispenser_creation_without_minter(
 
     # Tests publisher mints tokens and transfer them to the dispenser.
 
-    erc20_token.mint(
+    datatoken.mint(
         from_wallet=publisher_wallet,
         account_address=dispenser.address,
         value=to_wei("1"),
@@ -184,16 +184,14 @@ def test_dispenser_creation_without_minter(
 
     # Tests consumer requests data tokens
     dispenser.dispense(
-        datatoken=erc20_token.address,
+        datatoken=datatoken.address,
         amount=to_wei("1"),
         destination=consumer_wallet.address,
         from_wallet=consumer_wallet,
     )
 
     # Tests publisher withdraws all datatokens
-    dispenser.owner_withdraw(
-        datatoken=erc20_token.address, from_wallet=publisher_wallet
-    )
+    dispenser.owner_withdraw(datatoken=datatoken.address, from_wallet=publisher_wallet)
 
-    status = dispenser.status(erc20_token.address)
+    status = dispenser.status(datatoken.address)
     assert status[5] == 0
diff --git a/ocean_lib/models/test/test_factory_router.py b/ocean_lib/models/test/test_factory_router.py
index 29702c86a..000190495 100644
--- a/ocean_lib/models/test/test_factory_router.py
+++ b/ocean_lib/models/test/test_factory_router.py
@@ -6,8 +6,8 @@
 from web3 import Web3
 
 from ocean_lib.config import Config
-from ocean_lib.models.erc20_token import ERC20Token
-from ocean_lib.models.erc721_factory import ERC721FactoryContract
+from ocean_lib.models.datatoken import Datatoken
+from ocean_lib.models.data_nft_factory import DataNFTFactoryContract
 from ocean_lib.models.factory_router import FactoryRouter
 from ocean_lib.web3_internal.constants import ZERO_ADDRESS
 from ocean_lib.web3_internal.currency import to_wei
@@ -137,7 +137,7 @@ def test_opc_collector(config: Config, factory_router: FactoryRouter):
 def test_buy_dt_batch(
     web3: Web3,
     config: Config,
-    ocean_token: ERC20Token,
+    ocean_token: Datatoken,
     factory_router: FactoryRouter,
     consumer_wallet: Wallet,
     factory_deployer_wallet: Wallet,
@@ -145,13 +145,13 @@ def test_buy_dt_batch(
 ):
     """Tests that a batch of tokens is successfully bought through the buy_dt_batch function"""
 
-    nft_factory = ERC721FactoryContract(
+    nft_factory = DataNFTFactoryContract(
         web3=web3,
-        address=get_address_of_type(config, ERC721FactoryContract.CONTRACT_NAME),
+        address=get_address_of_type(config, DataNFTFactoryContract.CONTRACT_NAME),
     )
 
     ocean_token.approve(
-        get_address_of_type(config, ERC721FactoryContract.CONTRACT_NAME),
+        get_address_of_type(config, DataNFTFactoryContract.CONTRACT_NAME),
         2**256 - 1,
         factory_deployer_wallet,
     )
@@ -183,7 +183,7 @@ def test_buy_dt_batch(
         pool_side_staking=get_address_of_type(config, "Staking"),
         pool_base_token=ocean_token.address,
         pool_base_token_sender=get_address_of_type(
-            config, ERC721FactoryContract.CONTRACT_NAME
+            config, DataNFTFactoryContract.CONTRACT_NAME
         ),
         pool_publisher=factory_deployer_wallet.address,
         pool_publish_market_swap_fee_collector=factory_deployer_wallet.address,
@@ -196,7 +196,7 @@ def test_buy_dt_batch(
         "TokenCreated", tx_receipt.blockNumber, web3.eth.block_number, None
     )
     erc_token = registered_event[0]["args"]["newTokenAddress"]
-    erc_token_contract = ERC20Token(web3=web3, address=erc_token)
+    erc_token_contract = Datatoken(web3=web3, address=erc_token)
     registered_event_pool = erc_token_contract.get_event_log(
         FactoryRouter.EVENT_NEW_POOL,
         tx_receipt.blockNumber,
@@ -229,7 +229,7 @@ def test_buy_dt_batch(
         pool_side_staking=get_address_of_type(config, "Staking"),
         pool_base_token=ocean_token.address,
         pool_base_token_sender=get_address_of_type(
-            config, ERC721FactoryContract.CONTRACT_NAME
+            config, DataNFTFactoryContract.CONTRACT_NAME
         ),
         pool_publisher=factory_deployer_wallet.address,
         pool_publish_market_swap_fee_collector=factory_deployer_wallet.address,
@@ -242,7 +242,7 @@ def test_buy_dt_batch(
         "TokenCreated", tx_receipt.blockNumber, web3.eth.block_number, None
     )
     erc_token2 = registered_event[0]["args"]["newTokenAddress"]
-    erc_token_contract2 = ERC20Token(web3=web3, address=erc_token2)
+    erc_token_contract2 = Datatoken(web3=web3, address=erc_token2)
     registered_event_pool = erc_token_contract2.get_event_log(
         FactoryRouter.EVENT_NEW_POOL,
         tx_receipt.blockNumber,
@@ -293,18 +293,18 @@ def test_buy_dt_batch(
 def test_stake_batch(
     web3: Web3,
     config: Config,
-    ocean_token: ERC20Token,
+    ocean_token: Datatoken,
     factory_router: FactoryRouter,
     consumer_wallet: Wallet,
     factory_deployer_wallet: Wallet,
 ):
-    nft_factory = ERC721FactoryContract(
+    nft_factory = DataNFTFactoryContract(
         web3=web3,
-        address=get_address_of_type(config, ERC721FactoryContract.CONTRACT_NAME),
+        address=get_address_of_type(config, DataNFTFactoryContract.CONTRACT_NAME),
     )
 
     ocean_token.approve(
-        get_address_of_type(config, ERC721FactoryContract.CONTRACT_NAME),
+        get_address_of_type(config, DataNFTFactoryContract.CONTRACT_NAME),
         2**256 - 1,
         factory_deployer_wallet,
     )
@@ -336,7 +336,7 @@ def test_stake_batch(
         pool_side_staking=get_address_of_type(config, "Staking"),
         pool_base_token=ocean_token.address,
         pool_base_token_sender=get_address_of_type(
-            config, ERC721FactoryContract.CONTRACT_NAME
+            config, DataNFTFactoryContract.CONTRACT_NAME
         ),
         pool_publisher=factory_deployer_wallet.address,
         pool_publish_market_swap_fee_collector=factory_deployer_wallet.address,
@@ -349,7 +349,7 @@ def test_stake_batch(
         "TokenCreated", tx_receipt.blockNumber, web3.eth.block_number, None
     )
     erc_token = registered_event[0]["args"]["newTokenAddress"]
-    erc_token_contract = ERC20Token(web3=web3, address=erc_token)
+    erc_token_contract = Datatoken(web3=web3, address=erc_token)
     registered_event_pool = erc_token_contract.get_event_log(
         FactoryRouter.EVENT_NEW_POOL,
         tx_receipt.blockNumber,
@@ -382,7 +382,7 @@ def test_stake_batch(
         pool_side_staking=get_address_of_type(config, "Staking"),
         pool_base_token=ocean_token.address,
         pool_base_token_sender=get_address_of_type(
-            config, ERC721FactoryContract.CONTRACT_NAME
+            config, DataNFTFactoryContract.CONTRACT_NAME
         ),
         pool_publisher=factory_deployer_wallet.address,
         pool_publish_market_swap_fee_collector=factory_deployer_wallet.address,
@@ -395,7 +395,7 @@ def test_stake_batch(
         "TokenCreated", tx_receipt.blockNumber, web3.eth.block_number, None
     )
     erc_token2 = registered_event[0]["args"]["newTokenAddress"]
-    erc_token_contract2 = ERC20Token(web3=web3, address=erc_token2)
+    erc_token_contract2 = Datatoken(web3=web3, address=erc_token2)
     registered_event_pool = erc_token_contract2.get_event_log(
         FactoryRouter.EVENT_NEW_POOL,
         tx_receipt.blockNumber,
@@ -407,14 +407,14 @@ def test_stake_batch(
     stake1 = {"poolAddress": pool1, "tokenAmountIn": to_wei("1"), "minPoolAmountOut": 0}
 
     stake2 = {"poolAddress": pool2, "tokenAmountIn": to_wei("1"), "minPoolAmountOut": 0}
-    bpool_token1 = ERC20Token(web3, pool1)
-    bpool_token2 = ERC20Token(web3, pool2)
+    bpool_token1 = Datatoken(web3, pool1)
+    bpool_token2 = Datatoken(web3, pool2)
 
     assert bpool_token1.balanceOf(consumer_wallet.address) == 0
     assert bpool_token2.balanceOf(consumer_wallet.address) == 0
 
     ocean_token.approve(
-        get_address_of_type(config, ERC721FactoryContract.CONTRACT_NAME),
+        get_address_of_type(config, DataNFTFactoryContract.CONTRACT_NAME),
         2**256 - 1,
         consumer_wallet,
     )
diff --git a/ocean_lib/models/test/test_fixed_rate_exchange.py b/ocean_lib/models/test/test_fixed_rate_exchange.py
index 2feda349e..9a270442e 100644
--- a/ocean_lib/models/test/test_fixed_rate_exchange.py
+++ b/ocean_lib/models/test/test_fixed_rate_exchange.py
@@ -5,7 +5,7 @@
 import pytest
 from web3 import exceptions
 
-from ocean_lib.models.erc721_factory import ERC721FactoryContract
+from ocean_lib.models.data_nft_factory import DataNFTFactoryContract
 from ocean_lib.models.fixed_rate_exchange import (
     FixedExchangeBaseInOutData,
     FixedRateExchange,
@@ -78,7 +78,7 @@ def test_exchange_rate_creation(
     another_consumer_wallet,
     consumer_addr,
     another_consumer_addr,
-    erc20_token,
+    datatoken,
 ):
     """Test exchange with baseToken(OCEAN) 18 Decimals and dataToken 18 Decimals, RATE = 1"""
     amount = to_wei("100000")
@@ -86,15 +86,15 @@ def test_exchange_rate_creation(
     no_limit = to_wei("100000000000000000000")
     rate = to_wei("1")
     publish_market_swap_fee = int(1e15)  # 0.1%
-    pmt_collector = erc20_token.get_payment_collector()
+    pmt_collector = datatoken.get_payment_collector()
 
     fixed_exchange = FixedRateExchange(web3, get_address_of_type(config, "FixedPrice"))
 
-    erc20_token.mint(consumer_addr, amount, publisher_wallet)
-    assert erc20_token.balanceOf(consumer_addr) == amount
+    datatoken.mint(consumer_addr, amount, publisher_wallet)
+    assert datatoken.balanceOf(consumer_addr) == amount
     number_of_exchanges_before = fixed_exchange.get_number_of_exchanges()
 
-    tx = erc20_token.create_fixed_rate(
+    tx = datatoken.create_fixed_rate(
         fixed_price_address=get_address_of_type(config, "FixedPrice"),
         base_token_address=ocean_token.address,
         owner=consumer_addr,
@@ -110,8 +110,8 @@ def test_exchange_rate_creation(
 
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
 
-    registered_event = erc20_token.get_event_log(
-        event_name=ERC721FactoryContract.EVENT_NEW_FIXED_RATE,
+    registered_event = datatoken.get_event_log(
+        event_name=DataNFTFactoryContract.EVENT_NEW_FIXED_RATE,
         from_block=tx_receipt.blockNumber,
         to_block=web3.eth.block_number,
         filters=None,
@@ -125,7 +125,7 @@ def test_exchange_rate_creation(
 
     # Generate exchange id works
     generated_exchange_id = fixed_exchange.generate_exchange_id(
-        base_token=ocean_token.address, datatoken=erc20_token.address
+        base_token=ocean_token.address, datatoken=datatoken.address
     )
     assert generated_exchange_id == exchange_id
 
@@ -146,7 +146,7 @@ def test_exchange_rate_creation(
 
     # Consumer_wallet approves how many DT tokens wants to sell
     # Consumer_wallet only approves an exact amount so we can check supply etc later in the test
-    erc20_token.approve(fixed_exchange.address, amount_dt_to_sell, consumer_wallet)
+    datatoken.approve(fixed_exchange.address, amount_dt_to_sell, consumer_wallet)
     # Another_consumer_wallet approves a big amount so that we don't need to re-approve during test
     ocean_token.approve(
         fixed_exchange.address, to_wei("1000000"), another_consumer_wallet
@@ -197,7 +197,7 @@ def test_exchange_rate_creation(
 
     # Test buy DT workflow
     ocean_balance_publisher_before_swap = ocean_token.balanceOf(consumer_addr)
-    erc20_dt_balance_consumer_before_swap = erc20_token.balanceOf(another_consumer_addr)
+    erc20_dt_balance_consumer_before_swap = datatoken.balanceOf(another_consumer_addr)
 
     assert ocean_balance_publisher_before_swap == 0
     assert erc20_dt_balance_consumer_before_swap == 0
@@ -228,14 +228,14 @@ def test_exchange_rate_creation(
         == event_log[0].args.datatokenSwappedAmount
     )
 
-    assert erc20_token.balanceOf(another_consumer_addr) == amount_dt_to_sell
+    assert datatoken.balanceOf(another_consumer_addr) == amount_dt_to_sell
     assert ocean_token.balanceOf(consumer_addr) > ocean_balance_publisher_before_swap
     # Test sell DT workflow
-    erc20_dt_balance_consumer_before_swap = erc20_token.balanceOf(another_consumer_addr)
-    erc20_token.approve(
+    erc20_dt_balance_consumer_before_swap = datatoken.balanceOf(another_consumer_addr)
+    datatoken.approve(
         fixed_exchange.address, erc20_dt_balance_consumer_before_swap, consumer_wallet
     )
-    erc20_balance_before = erc20_token.balanceOf(consumer_addr)
+    erc20_balance_before = datatoken.balanceOf(consumer_addr)
     ocean_balance_before = ocean_token.balanceOf(consumer_addr)
     fixed_exchange.sell_dt(
         exchange_id, amount_dt_to_sell, 0, ZERO_ADDRESS, 0, consumer_wallet
@@ -253,7 +253,7 @@ def test_exchange_rate_creation(
     )
 
     assert (
-        erc20_token.balanceOf(consumer_addr) == erc20_balance_before - amount_dt_to_sell
+        datatoken.balanceOf(consumer_addr) == erc20_balance_before - amount_dt_to_sell
     )
 
     exchange_details = fixed_exchange.get_exchange(exchange_id)
@@ -268,7 +268,7 @@ def test_exchange_rate_creation(
 
     # Fixed Rate Exchange owner withdraws DT balance
 
-    erc20_balance_before = erc20_token.balanceOf(pmt_collector)
+    erc20_balance_before = datatoken.balanceOf(pmt_collector)
 
     tx = fixed_exchange.collect_dt(
         exchange_id,
@@ -285,13 +285,12 @@ def test_exchange_rate_creation(
     )
 
     assert (
-        erc20_token.balanceOf(pmt_collector)
-        == erc20_balance_before + logs[0].args.amount
+        datatoken.balanceOf(pmt_collector) == erc20_balance_before + logs[0].args.amount
     )
 
     # Fixed Rate Exchange owner withdraws BT balance
     # Needs to buy because he sold all the DT amount and BT balance will be 0.
-    erc20_token.approve(fixed_exchange.address, to_wei(10), consumer_wallet)
+    datatoken.approve(fixed_exchange.address, to_wei(10), consumer_wallet)
 
     fixed_exchange.buy_dt(
         exchange_id,
@@ -301,9 +300,7 @@ def test_exchange_rate_creation(
         to_wei("0.1"),
         another_consumer_wallet,
     )
-    assert erc20_token.balanceOf(another_consumer_addr) == amount_dt_to_sell + to_wei(
-        10
-    )
+    assert datatoken.balanceOf(another_consumer_addr) == amount_dt_to_sell + to_wei(10)
     bt_balance_before = ocean_token.balanceOf(pmt_collector)
 
     tx = fixed_exchange.collect_bt(
diff --git a/ocean_lib/models/test/test_side_staking.py b/ocean_lib/models/test/test_side_staking.py
index f6b35695f..ed2ee1882 100644
--- a/ocean_lib/models/test/test_side_staking.py
+++ b/ocean_lib/models/test/test_side_staking.py
@@ -6,7 +6,7 @@
 from web3 import exceptions
 
 from ocean_lib.models.bpool import BPool
-from ocean_lib.models.erc721_factory import ERC721FactoryContract
+from ocean_lib.models.data_nft_factory import DataNFTFactoryContract
 from ocean_lib.models.side_staking import SideStaking
 from ocean_lib.web3_internal.currency import MAX_WEI, to_wei
 from tests.resources.helper_functions import (
@@ -29,8 +29,8 @@ def test_side_staking(
     another_consumer_wallet,
     factory_deployer_wallet,
     factory_router,
-    erc721_nft,
-    erc20_token,
+    data_nft,
+    datatoken,
 ):
     lp_swap_fee = int(1e15)
     publish_market_swap_fee = int(1e15)
@@ -38,10 +38,10 @@ def test_side_staking(
 
     side_staking = SideStaking(web3, get_address_of_type(config, "Staking"))
 
-    assert side_staking.get_base_token_balance(erc20_token.address) == 0
+    assert side_staking.get_base_token_balance(datatoken.address) == 0
 
     # Datatoken initial circulating supply should be 0
-    assert side_staking.get_datatoken_circulating_supply(erc20_token.address) == 0
+    assert side_staking.get_datatoken_circulating_supply(datatoken.address) == 0
 
     # Transfer ocean if needed
     transfer_base_token_if_balance_lte(
@@ -68,7 +68,7 @@ def test_side_staking(
         publisher_wallet,
     )
 
-    tx = erc20_token.deploy_pool(
+    tx = datatoken.deploy_pool(
         rate=to_wei(1),
         base_token_decimals=ocean_token.decimals(),
         base_token_amount=initial_ocean_liquidity,
@@ -87,17 +87,15 @@ def test_side_staking(
 
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
     pool_event = factory_router.get_event_log(
-        ERC721FactoryContract.EVENT_NEW_POOL,
+        DataNFTFactoryContract.EVENT_NEW_POOL,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
     )
 
+    assert side_staking.get_base_token_address(datatoken.address) == ocean_token.address
     assert (
-        side_staking.get_base_token_address(erc20_token.address) == ocean_token.address
-    )
-    assert (
-        side_staking.get_publisher_address(erc20_token.address)
+        side_staking.get_publisher_address(datatoken.address)
         == publisher_wallet.address
     )
 
@@ -106,11 +104,11 @@ def test_side_staking(
     bpool = BPool(web3, bpool_address)
 
     # Side staking pool address should match the newly created pool
-    assert side_staking.get_pool_address(erc20_token.address) == bpool_address
+    assert side_staking.get_pool_address(datatoken.address) == bpool_address
 
-    # Publisher fails to mints new erc20_token tokens even if it's minter
+    # Publisher fails to mints new datatoken tokens even if it's minter
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.mint(publisher_wallet.address, to_wei("1"), publisher_wallet)
+        datatoken.mint(publisher_wallet.address, to_wei("1"), publisher_wallet)
     assert (
         err.value.args[0]
         == "execution reverted: VM Exception while processing transaction: revert"
@@ -129,7 +127,7 @@ def test_side_staking(
 
     bpool.swap_exact_amount_in(
         token_in=ocean_token.address,
-        token_out=erc20_token.address,
+        token_out=datatoken.address,
         consume_market_swap_fee_address=publisher_wallet.address,
         token_amount_in=to_wei("1"),
         min_amount_out=to_wei("0"),
@@ -138,16 +136,16 @@ def test_side_staking(
         from_wallet=another_consumer_wallet,
     )
 
-    assert erc20_token.balanceOf(another_consumer_wallet.address) >= 0
+    assert datatoken.balanceOf(another_consumer_wallet.address) >= 0
 
     # Another consumer swaps some DT back to Ocean swapExactAmountIn
-    initial_erc20_token_balance = erc20_token.balanceOf(another_consumer_wallet.address)
+    initial_datatoken_balance = datatoken.balanceOf(another_consumer_wallet.address)
     initial_ocean_balance = ocean_token.balanceOf(another_consumer_wallet.address)
-    erc20_token.approve(bpool_address, to_wei("10000"), another_consumer_wallet)
+    datatoken.approve(bpool_address, to_wei("10000"), another_consumer_wallet)
 
     receipt = web3.eth.wait_for_transaction_receipt(
         bpool.swap_exact_amount_in(
-            token_in=erc20_token.address,
+            token_in=datatoken.address,
             token_out=ocean_token.address,
             consume_market_swap_fee_address=publisher_wallet.address,
             token_amount_in=to_wei("0.01"),
@@ -168,22 +166,17 @@ def test_side_staking(
     assert registered_event[0].event == BPool.EVENT_LOG_SWAP
 
     assert (
-        erc20_token.balanceOf(another_consumer_wallet.address)
-        < initial_erc20_token_balance
+        datatoken.balanceOf(another_consumer_wallet.address) < initial_datatoken_balance
     )
     assert (
         ocean_token.balanceOf(another_consumer_wallet.address) > initial_ocean_balance
     )
 
     # Publisher adds more liquidity with joinswapExternAmountIn
-    ss_contract_dt_balance = erc20_token.balanceOf(
-        get_address_of_type(config, "Staking")
-    )
+    ss_contract_dt_balance = datatoken.balanceOf(get_address_of_type(config, "Staking"))
     ss_contract_bpt_balance = bpool.balanceOf(get_address_of_type(config, "Staking"))
 
-    initial_erc20_token_balance_publisher = erc20_token.balanceOf(
-        publisher_wallet.address
-    )
+    initial_datatoken_balance_publisher = datatoken.balanceOf(publisher_wallet.address)
 
     ocean_token.approve(bpool.address, to_wei(1), publisher_wallet)
 
@@ -204,9 +197,9 @@ def test_side_staking(
     assert registered_event[0].event == BPool.EVENT_LOG_JOIN
     assert registered_event[0].args.tokenIn == ocean_token.address
     assert registered_event[0].args.tokenAmountIn == ocean_amount_in
-    assert registered_event[1].args.tokenIn == erc20_token.address
+    assert registered_event[1].args.tokenIn == datatoken.address
 
-    side_staking_amount_in = ss_contract_dt_balance - erc20_token.balanceOf(
+    side_staking_amount_in = ss_contract_dt_balance - datatoken.balanceOf(
         get_address_of_type(config, "Staking")
     )
 
@@ -215,9 +208,7 @@ def test_side_staking(
     # We check ssContract actually moved DT and got back BPT
     assert ss_contract_dt_balance - registered_event[
         1
-    ].args.tokenAmountIn == erc20_token.balanceOf(
-        get_address_of_type(config, "Staking")
-    )
+    ].args.tokenAmountIn == datatoken.balanceOf(get_address_of_type(config, "Staking"))
 
     registered_event2 = bpool.get_event_log(
         event_name=BPool.EVENT_LOG_BPT,
@@ -232,20 +223,16 @@ def test_side_staking(
         get_address_of_type(config, "Staking")
     )
     assert (
-        erc20_token.balanceOf(publisher_wallet.address)
-        == initial_erc20_token_balance_publisher
+        datatoken.balanceOf(publisher_wallet.address)
+        == initial_datatoken_balance_publisher
     )
 
     # Publisher removes liquidity with exitswapPoolAmountIn, receiving only OCEAN tokens
 
-    initial_erc20_token_balance_publisher = erc20_token.balanceOf(
-        publisher_wallet.address
-    )
+    initial_datatoken_balance_publisher = datatoken.balanceOf(publisher_wallet.address)
     initial_ocean_balance_publisher = ocean_token.balanceOf(publisher_wallet.address)
     initial_bpt_balance_publisher = bpool.balanceOf(publisher_wallet.address)
-    ss_contract_dt_balance = erc20_token.balanceOf(
-        get_address_of_type(config, "Staking")
-    )
+    ss_contract_dt_balance = datatoken.balanceOf(get_address_of_type(config, "Staking"))
     ss_contract_bpt_balance = bpool.balanceOf(get_address_of_type(config, "Staking"))
 
     bpt_amount_in = to_wei("1")
@@ -256,8 +243,8 @@ def test_side_staking(
     )
 
     assert (
-        erc20_token.balanceOf(publisher_wallet.address)
-        == initial_erc20_token_balance_publisher
+        datatoken.balanceOf(publisher_wallet.address)
+        == initial_datatoken_balance_publisher
     )
 
     registered_event = bpool.get_event_log(
@@ -269,7 +256,7 @@ def test_side_staking(
 
     assert registered_event[0].args.caller == publisher_wallet.address
     assert registered_event[0].args.tokenOut == ocean_token.address
-    assert registered_event[1].args.tokenOut == erc20_token.address
+    assert registered_event[1].args.tokenOut == datatoken.address
 
     assert registered_event[
         0
@@ -286,9 +273,7 @@ def test_side_staking(
     )
     assert ss_contract_dt_balance + registered_event[
         1
-    ].args.tokenAmountOut == erc20_token.balanceOf(
-        get_address_of_type(config, "Staking")
-    )
+    ].args.tokenAmountOut == datatoken.balanceOf(get_address_of_type(config, "Staking"))
 
 
 @pytest.mark.unit
@@ -297,7 +282,7 @@ def test_side_staking_steal(
     config,
     publisher_wallet,
     another_consumer_wallet,
-    erc20_token,
+    datatoken,
 ):
     """
     In this test we try to steal base token from the pool
@@ -312,12 +297,12 @@ def test_side_staking_steal(
     swap_fee = to_wei("0.0001")
     big_allowance = MAX_WEI
 
-    erc20_token.mint(publisher_wallet.address, MAX_WEI, publisher_wallet)
+    datatoken.mint(publisher_wallet.address, MAX_WEI, publisher_wallet)
 
     # We use an erc20 as ocean to have unlimited balance
-    ocean_token = erc20_token
+    ocean_token = datatoken
 
-    bpool, erc20_token2, _, pool_token = create_nft_erc20_with_pool(
+    bpool, datatoken2, _, pool_token = create_nft_erc20_with_pool(
         web3,
         config,
         publisher_wallet,
@@ -328,11 +313,11 @@ def test_side_staking_steal(
     )
 
     ocean_token.approve(bpool.address, big_allowance, another_consumer_wallet)
-    erc20_token2.approve(bpool.address, big_allowance, another_consumer_wallet)
+    datatoken2.approve(bpool.address, big_allowance, another_consumer_wallet)
 
-    erc20_token.transfer(
+    datatoken.transfer(
         another_consumer_wallet.address,
-        erc20_token.balanceOf(publisher_wallet.address),
+        datatoken.balanceOf(publisher_wallet.address),
         publisher_wallet,
     )
 
@@ -343,7 +328,7 @@ def test_side_staking_steal(
     for _ in range(10):
         swap_exact_amount_in_base_token(
             bpool,
-            erc20_token2,
+            datatoken2,
             ocean_token,
             another_consumer_wallet,
             to_wei(datatoken_buy_amount_basetoken_eth),
@@ -361,19 +346,19 @@ def test_side_staking_steal(
         )
         amounts_out.append(
             bpool.get_amount_out_exact_in(
-                erc20_token2.address,
+                datatoken2.address,
                 ocean_token.address,
-                erc20_token2.balanceOf(another_consumer_wallet.address),
+                datatoken2.balanceOf(another_consumer_wallet.address),
                 swap_market_fee,
             )[0]
         )
 
     swap_exact_amount_in_datatoken(
         bpool,
-        erc20_token2,
+        datatoken2,
         ocean_token,
         another_consumer_wallet,
-        erc20_token2.balanceOf(another_consumer_wallet.address),
+        datatoken2.balanceOf(another_consumer_wallet.address),
     )
 
     while pool_token.balanceOf(another_consumer_wallet.address) > to_wei("50"):
@@ -391,7 +376,7 @@ def test_side_staking_steal(
     )
 
     # Check that users hasn't made any profit
-    assert erc20_token2.balanceOf(another_consumer_wallet.address) == 0
+    assert datatoken2.balanceOf(another_consumer_wallet.address) == 0
 
     # Check that the the attacker is loosing money
     assert (
@@ -419,7 +404,7 @@ def test_side_staking_constant_rate(
 
     ocean_token.transfer(another_consumer_wallet.address, to_wei("50"), consumer_wallet)
 
-    bpool, erc20_token, _, _ = create_nft_erc20_with_pool(
+    bpool, datatoken, _, _ = create_nft_erc20_with_pool(
         web3,
         config,
         publisher_wallet,
@@ -430,16 +415,16 @@ def test_side_staking_constant_rate(
     )
 
     ocean_token.approve(bpool.address, big_allowance, another_consumer_wallet)
-    erc20_token.approve(bpool.address, big_allowance, another_consumer_wallet)
+    datatoken.approve(bpool.address, big_allowance, another_consumer_wallet)
 
     # End test initial values and setups
     initial_spot_price_basetoken_datatoken = bpool.get_spot_price(
-        ocean_token.address, erc20_token.address, swap_market_fee
+        ocean_token.address, datatoken.address, swap_market_fee
     )
     # join the pool max ratio
     join_pool_one_side(web3, bpool, ocean_token, another_consumer_wallet)
     final_spot_price_basetoken_datatoken = bpool.get_spot_price(
-        ocean_token.address, erc20_token.address, swap_market_fee
+        ocean_token.address, datatoken.address, swap_market_fee
     )
 
     # We check that the spot price is constant with a precision of 10^-10
diff --git a/ocean_lib/ocean/test/test_ocean.py b/ocean_lib/ocean/test/test_ocean.py
index 5d09c036a..0975c5f10 100644
--- a/ocean_lib/ocean/test/test_ocean.py
+++ b/ocean_lib/ocean/test/test_ocean.py
@@ -4,26 +4,24 @@
 #
 import pytest
 
-from ocean_lib.models.erc721_nft import ERC721NFT
+from ocean_lib.models.data_nft import DataNFT
 
 
 @pytest.mark.unit
-def test_nft_factory(
-    erc721_nft, erc20_token, publisher_ocean_instance, publisher_wallet
-):
+def test_nft_factory(data_nft, datatoken, publisher_ocean_instance, publisher_wallet):
     ocn = publisher_ocean_instance
     assert ocn.get_nft_factory()
 
-    assert ocn.get_nft_token(erc721_nft.address).address == erc721_nft.address
-    assert ocn.get_datatoken(erc20_token.address).address == erc20_token.address
+    assert ocn.get_nft_token(data_nft.address).address == data_nft.address
+    assert ocn.get_datatoken(datatoken.address).address == datatoken.address
 
-    created_nft = ocn.create_erc721_nft(
+    created_nft = ocn.create_data_nft(
         name="TEST",
         symbol="TEST2",
         token_uri="http://oceanprotocol.com/nft",
         from_wallet=publisher_wallet,
     )
-    assert isinstance(created_nft, ERC721NFT)
+    assert isinstance(created_nft, DataNFT)
     assert created_nft.contract.caller.name() == "TEST"
     assert created_nft.symbol() == "TEST2"
     assert created_nft.address
diff --git a/ocean_lib/ocean/test/test_ocean_assets.py b/ocean_lib/ocean/test/test_ocean_assets.py
index 6b40a7797..a0e87fff7 100644
--- a/ocean_lib/ocean/test/test_ocean_assets.py
+++ b/ocean_lib/ocean/test/test_ocean_assets.py
@@ -15,8 +15,8 @@
 from ocean_lib.assets.asset import Asset
 from ocean_lib.data_provider.data_service_provider import DataServiceProvider
 from ocean_lib.exceptions import AquariusError, ContractNotFound, InsufficientBalance
-from ocean_lib.models.erc721_factory import ERC721FactoryContract
-from ocean_lib.models.erc721_nft import ERC721NFT
+from ocean_lib.models.data_nft import DataNFT
+from ocean_lib.models.data_nft_factory import DataNFTFactoryContract
 from ocean_lib.services.service import Service
 from ocean_lib.web3_internal.constants import ZERO_ADDRESS
 from ocean_lib.web3_internal.wallet import Wallet
@@ -53,7 +53,9 @@ def test_update_metadata(publisher_ocean_instance, publisher_wallet):
     new_metadata["updated"] = datetime.utcnow().isoformat()
     ddo.metadata = new_metadata
 
-    with patch("ocean_lib.ocean.ocean_assets.ERC721FactoryContract.verify_nft") as mock:
+    with patch(
+        "ocean_lib.ocean.ocean_assets.DataNFTFactoryContract.verify_nft"
+    ) as mock:
         mock.return_value = False
         with pytest.raises(ContractNotFound):
             _asset = publisher_ocean_instance.assets.update(
@@ -94,7 +96,7 @@ def test_update_credentials(publisher_ocean_instance, publisher_wallet):
 
 @pytest.mark.integration
 def test_update_datatokens(
-    publisher_ocean_instance, publisher_wallet, config, erc20_token, file2
+    publisher_ocean_instance, publisher_wallet, config, datatoken, file2
 ):
     """Test the update of datatokens"""
     ddo = create_asset(publisher_ocean_instance, publisher_wallet)
@@ -108,16 +110,16 @@ def test_update_datatokens(
         service_id="3",
         service_type=ServiceTypes.ASSET_ACCESS,
         service_endpoint=data_provider.get_url(config),
-        datatoken=erc20_token.address,
+        datatoken=datatoken.address,
         files=encrypted_files,
         timeout=0,
     )
 
     ddo.datatokens.append(
         {
-            "address": erc20_token.address,
-            "name": erc20_token.contract.caller.name(),
-            "symbol": erc20_token.symbol(),
+            "address": datatoken.address,
+            "name": datatoken.contract.caller.name(),
+            "symbol": datatoken.symbol(),
             "serviceId": access_service.id,
         }
     )
@@ -130,10 +132,10 @@ def test_update_datatokens(
 
     assert len(_asset.datatokens) == len(old_asset.datatokens) + 1
     assert len(_asset.services) == len(old_asset.services) + 1
-    assert _asset.datatokens[1].get("address") == erc20_token.address
+    assert _asset.datatokens[1].get("address") == datatoken.address
     assert _asset.datatokens[0].get("address") == old_asset.datatokens[0].get("address")
     assert _asset.services[0].datatoken == old_asset.datatokens[0].get("address")
-    assert _asset.services[1].datatoken == erc20_token.address
+    assert _asset.services[1].datatoken == datatoken.address
 
     # Delete datatoken
     new_asset = new_metadata = copy.deepcopy(_asset)
@@ -168,7 +170,7 @@ def test_update_flags(publisher_ocean_instance, publisher_wallet):
     ddo = create_asset(publisher_ocean_instance, publisher_wallet)
 
     # Test compress & update flags
-    erc721_nft = ERC721NFT(publisher_ocean_instance.web3, ddo.nft_address)
+    data_nft = DataNFT(publisher_ocean_instance.web3, ddo.nft_address)
 
     _asset = publisher_ocean_instance.assets.update(
         asset=ddo,
@@ -177,8 +179,8 @@ def test_update_flags(publisher_ocean_instance, publisher_wallet):
         encrypt_flag=True,
     )
 
-    registered_token_event = erc721_nft.get_event_log(
-        ERC721NFT.EVENT_METADATA_UPDATED,
+    registered_token_event = data_nft.get_event_log(
+        DataNFT.EVENT_METADATA_UPDATED,
         _asset.event.get("block"),
         publisher_ocean_instance.web3.eth.block_number,
         None,
@@ -329,11 +331,11 @@ def test_create_bad_metadata(publisher_ocean_instance, publisher_wallet):
 
 @pytest.mark.unit
 def test_pay_for_access_service_insufficient_balance(
-    publisher_ocean_instance, config, publisher_wallet, erc20_token
+    publisher_ocean_instance, config, publisher_wallet, datatoken
 ):
     """Tests if balance is lower than the purchased amount."""
     ddo_dict = copy.deepcopy(get_sample_ddo())
-    ddo_dict["services"][0]["datatokenAddress"] = erc20_token.address
+    ddo_dict["services"][0]["datatokenAddress"] = datatoken.address
     asset = Asset.from_dict(ddo_dict)
 
     empty_account = publisher_ocean_instance.web3.eth.account.create()
@@ -350,7 +352,7 @@ def test_pay_for_access_service_insufficient_balance(
             asset,
             get_first_service_by_type(asset, "access"),
             consume_market_order_fee_address=empty_wallet.address,
-            consume_market_order_fee_token=erc20_token.address,
+            consume_market_order_fee_token=datatoken.address,
             consume_market_order_fee_amount=0,
             wallet=empty_wallet,
         )
@@ -363,12 +365,12 @@ def test_plain_asset_with_one_datatoken(
     web3 = publisher_ocean_instance.web3
     data_provider = DataServiceProvider
 
-    erc721_factory, metadata, encrypted_files = create_basics(
+    data_nft_factory, metadata, encrypted_files = create_basics(
         config, web3, data_provider
     )
 
     # Publisher deploys NFT contract
-    tx = erc721_factory.deploy_erc721_contract(
+    tx = data_nft_factory.deploy_erc721_contract(
         name="NFT1",
         symbol="NFTSYMBOL",
         template_index=1,
@@ -380,8 +382,8 @@ def test_plain_asset_with_one_datatoken(
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -421,11 +423,11 @@ def test_plain_asset_multiple_datatokens(
 ):
     web3 = publisher_ocean_instance.web3
     data_provider = DataServiceProvider
-    erc721_factory, metadata, encrypted_files = create_basics(
+    data_nft_factory, metadata, encrypted_files = create_basics(
         config, web3, data_provider
     )
 
-    tx = erc721_factory.deploy_erc721_contract(
+    tx = data_nft_factory.deploy_erc721_contract(
         name="NFT2",
         symbol="NFT2SYMBOL",
         template_index=1,
@@ -437,8 +439,8 @@ def test_plain_asset_multiple_datatokens(
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -488,7 +490,7 @@ def test_plain_asset_multiple_datatokens(
 
 @pytest.mark.integration
 def test_plain_asset_multiple_services(
-    publisher_ocean_instance, publisher_wallet, config, erc721_nft, erc20_token
+    publisher_ocean_instance, publisher_wallet, config, data_nft, datatoken
 ):
     web3 = publisher_ocean_instance.web3
     data_provider = DataServiceProvider
@@ -498,7 +500,7 @@ def test_plain_asset_multiple_services(
         service_id="0",
         service_type=ServiceTypes.ASSET_ACCESS,
         service_endpoint=data_provider.get_url(config),
-        datatoken=erc20_token.address,
+        datatoken=datatoken.address,
         files=encrypted_files,
         timeout=0,
     )
@@ -518,7 +520,7 @@ def test_plain_asset_multiple_services(
         service_id="1",
         service_type=ServiceTypes.CLOUD_COMPUTE,
         service_endpoint=data_provider.get_url(config),
-        datatoken=erc20_token.address,
+        datatoken=datatoken.address,
         files=encrypted_files,
         timeout=3600,
         compute_values=compute_values,
@@ -529,24 +531,24 @@ def test_plain_asset_multiple_services(
         publisher_wallet=publisher_wallet,
         encrypted_files=encrypted_files,
         services=[access_service, compute_service],
-        erc721_address=erc721_nft.address,
-        deployed_erc20_tokens=[erc20_token],
+        erc721_address=data_nft.address,
+        deployed_datatokens=[datatoken],
     )
     assert ddo, "The asset is not created."
     assert ddo.nft["name"] == "NFT"
     assert ddo.nft["symbol"] == "NFTSYMBOL"
-    assert ddo.nft["address"] == erc721_nft.address
+    assert ddo.nft["address"] == data_nft.address
     assert ddo.nft["owner"] == publisher_wallet.address
     assert ddo.datatokens[0]["name"] == "ERC20DT1"
     assert ddo.datatokens[0]["symbol"] == "ERC20DT1Symbol"
-    assert ddo.datatokens[0]["address"] == erc20_token.address
+    assert ddo.datatokens[0]["address"] == datatoken.address
     assert ddo.credentials == build_credentials_dict()
     assert ddo.services[1].compute_values == compute_values
 
 
 @pytest.mark.integration
 def test_encrypted_asset(
-    publisher_ocean_instance, publisher_wallet, config, erc721_nft, erc20_token
+    publisher_ocean_instance, publisher_wallet, config, data_nft, datatoken
 ):
     web3 = publisher_ocean_instance.web3
     data_provider = DataServiceProvider
@@ -556,23 +558,23 @@ def test_encrypted_asset(
         metadata=metadata,
         publisher_wallet=publisher_wallet,
         encrypted_files=encrypted_files,
-        erc721_address=erc721_nft.address,
-        deployed_erc20_tokens=[erc20_token],
+        erc721_address=data_nft.address,
+        deployed_datatokens=[datatoken],
         encrypt_flag=True,
     )
     assert ddo, "The asset is not created."
     assert ddo.nft["name"] == "NFT"
     assert ddo.nft["symbol"] == "NFTSYMBOL"
-    assert ddo.nft["address"] == erc721_nft.address
+    assert ddo.nft["address"] == data_nft.address
     assert ddo.nft["owner"] == publisher_wallet.address
     assert ddo.datatokens[0]["name"] == "ERC20DT1"
     assert ddo.datatokens[0]["symbol"] == "ERC20DT1Symbol"
-    assert ddo.datatokens[0]["address"] == erc20_token.address
+    assert ddo.datatokens[0]["address"] == datatoken.address
 
 
 @pytest.mark.integration
 def test_compressed_asset(
-    publisher_ocean_instance, publisher_wallet, config, erc721_nft, erc20_token
+    publisher_ocean_instance, publisher_wallet, config, data_nft, datatoken
 ):
     web3 = publisher_ocean_instance.web3
     data_provider = DataServiceProvider
@@ -582,23 +584,23 @@ def test_compressed_asset(
         metadata=metadata,
         publisher_wallet=publisher_wallet,
         encrypted_files=encrypted_files,
-        erc721_address=erc721_nft.address,
-        deployed_erc20_tokens=[erc20_token],
+        erc721_address=data_nft.address,
+        deployed_datatokens=[datatoken],
         compress_flag=True,
     )
     assert ddo, "The asset is not created."
     assert ddo.nft["name"] == "NFT"
     assert ddo.nft["symbol"] == "NFTSYMBOL"
-    assert ddo.nft["address"] == erc721_nft.address
+    assert ddo.nft["address"] == data_nft.address
     assert ddo.nft["owner"] == publisher_wallet.address
     assert ddo.datatokens[0]["name"] == "ERC20DT1"
     assert ddo.datatokens[0]["symbol"] == "ERC20DT1Symbol"
-    assert ddo.datatokens[0]["address"] == erc20_token.address
+    assert ddo.datatokens[0]["address"] == datatoken.address
 
 
 @pytest.mark.integration
 def test_compressed_and_encrypted_asset(
-    publisher_ocean_instance, publisher_wallet, config, erc721_nft, erc20_token
+    publisher_ocean_instance, publisher_wallet, config, data_nft, datatoken
 ):
     web3 = publisher_ocean_instance.web3
     data_provider = DataServiceProvider
@@ -608,8 +610,8 @@ def test_compressed_and_encrypted_asset(
         metadata=metadata,
         publisher_wallet=publisher_wallet,
         encrypted_files=encrypted_files,
-        erc721_address=erc721_nft.address,
-        deployed_erc20_tokens=[erc20_token],
+        erc721_address=data_nft.address,
+        deployed_datatokens=[datatoken],
         encrypt_flag=True,
         compress_flag=True,
     )
@@ -619,12 +621,12 @@ def test_compressed_and_encrypted_asset(
     assert ddo.nft["owner"] == publisher_wallet.address
     assert ddo.datatokens[0]["name"] == "ERC20DT1"
     assert ddo.datatokens[0]["symbol"] == "ERC20DT1Symbol"
-    assert ddo.datatokens[0]["address"] == erc20_token.address
+    assert ddo.datatokens[0]["address"] == datatoken.address
 
 
 @pytest.mark.unit
 def test_asset_creation_errors(
-    publisher_ocean_instance, publisher_wallet, config, erc721_nft, erc20_token
+    publisher_ocean_instance, publisher_wallet, config, data_nft, datatoken
 ):
     web3 = publisher_ocean_instance.web3
     data_provider = DataServiceProvider
@@ -637,7 +639,7 @@ def test_asset_creation_errors(
             publisher_wallet=publisher_wallet,
             encrypted_files=encrypted_files,
             erc721_address=some_random_address,
-            deployed_erc20_tokens=[erc20_token],
+            deployed_datatokens=[datatoken],
             encrypt_flag=True,
         )
 
@@ -648,7 +650,7 @@ def test_asset_creation_errors(
                 metadata=metadata,
                 publisher_wallet=publisher_wallet,
                 encrypted_files=encrypted_files,
-                erc721_address=erc721_nft.address,
-                deployed_erc20_tokens=[erc20_token],
+                erc721_address=data_nft.address,
+                deployed_datatokens=[datatoken],
                 encrypt_flag=True,
             )
diff --git a/ocean_lib/web3_internal/test/test_event_filter.py b/ocean_lib/web3_internal/test/test_event_filter.py
index 95fc6ff65..848eb713e 100644
--- a/ocean_lib/web3_internal/test/test_event_filter.py
+++ b/ocean_lib/web3_internal/test/test_event_filter.py
@@ -8,12 +8,12 @@
 
 
 @pytest.mark.unit
-def test_transfer_event_filter(alice_ocean, alice_wallet, bob_address, erc721_nft):
-    erc721_nft.transfer_from(alice_wallet.address, bob_address, 1, alice_wallet)
+def test_transfer_event_filter(alice_ocean, alice_wallet, bob_address, data_nft):
+    data_nft.transfer_from(alice_wallet.address, bob_address, 1, alice_wallet)
 
     block = alice_ocean.web3.eth.block_number
     event_filter = EventFilter(
-        erc721_nft.events.Transfer(), from_block=block, to_block=block
+        data_nft.events.Transfer(), from_block=block, to_block=block
     )
 
     assert event_filter.filter_id, "Event filter ID is None."
diff --git a/tests/flows/test_exchange_swap_fees.py b/tests/flows/test_exchange_swap_fees.py
index 40e8564f9..bd177a82f 100644
--- a/tests/flows/test_exchange_swap_fees.py
+++ b/tests/flows/test_exchange_swap_fees.py
@@ -8,7 +8,7 @@
 from web3 import Web3
 
 from ocean_lib.config import Config
-from ocean_lib.models.erc20_token import ERC20Token
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.models.factory_router import FactoryRouter
 from ocean_lib.models.fixed_rate_exchange import (
     FixedRateExchange,
@@ -63,7 +63,7 @@ def test_exchange_swap_fees(
     another_consumer_wallet: Wallet,
     publisher_wallet: Wallet,
     base_token_name: str,
-    erc20_token: ERC20Token,
+    datatoken: Datatoken,
     publish_market_swap_fee: str,
     consume_market_swap_fee: str,
     bt_per_dt: str,
@@ -84,7 +84,7 @@ def test_exchange_swap_fees(
         consume_market_swap_fee_collector=another_consumer_wallet,
         publisher_wallet=publisher_wallet,
         base_token_name=base_token_name,
-        datatoken=erc20_token,
+        datatoken=datatoken,
         publish_market_swap_fee=publish_market_swap_fee,
         consume_market_swap_fee=consume_market_swap_fee,
         bt_per_dt=bt_per_dt,
@@ -100,13 +100,13 @@ def exchange_swap_fees(
     consume_market_swap_fee_collector: Wallet,
     publisher_wallet: Wallet,
     base_token_name: str,
-    datatoken: ERC20Token,
+    datatoken: Datatoken,
     publish_market_swap_fee: str,
     consume_market_swap_fee: str,
     bt_per_dt: str,
     with_mint: int,
 ):
-    bt = ERC20Token(web3, get_address_of_type(config, base_token_name))
+    bt = Datatoken(web3, get_address_of_type(config, base_token_name))
     dt = datatoken
 
     transfer_base_token_if_balance_lte(
@@ -325,8 +325,8 @@ def buy_or_sell_dt_and_verify_balances_swap_fees(
     consumer_wallet: Wallet,
 ):
     exchange_info = exchange.get_exchange(exchange_id)
-    bt = ERC20Token(web3, exchange_info[FixedRateExchangeDetails.BASE_TOKEN])
-    dt = ERC20Token(web3, exchange_info[FixedRateExchangeDetails.DATATOKEN])
+    bt = Datatoken(web3, exchange_info[FixedRateExchangeDetails.BASE_TOKEN])
+    dt = Datatoken(web3, exchange_info[FixedRateExchangeDetails.DATATOKEN])
 
     # Get balances before swap
     consumer_bt_balance_before = bt.balanceOf(consumer_wallet.address)
@@ -464,7 +464,7 @@ def collect_bt_or_dt_and_verify_balances(
 ):
     """Collet BT or Collect DT and verify balances"""
     exchange_info = exchange.get_exchange(exchange_id)
-    dt = ERC20Token(web3, exchange_info[FixedRateExchangeDetails.DATATOKEN])
+    dt = Datatoken(web3, exchange_info[FixedRateExchangeDetails.DATATOKEN])
     publish_market = dt.get_payment_collector()
 
     if token_address == dt.address:
@@ -472,7 +472,7 @@ def collect_bt_or_dt_and_verify_balances(
         balance_index = FixedRateExchangeDetails.DT_BALANCE
         method = exchange.collect_dt
     else:
-        token = ERC20Token(web3, exchange_info[FixedRateExchangeDetails.BASE_TOKEN])
+        token = Datatoken(web3, exchange_info[FixedRateExchangeDetails.BASE_TOKEN])
         balance_index = FixedRateExchangeDetails.BT_BALANCE
         method = exchange.collect_bt
 
@@ -503,7 +503,7 @@ def collect_fee_and_verify_balances(
 ):
     """Collet publish market swap fees or ocean community swap fees and verify balances"""
     exchange_info = exchange.get_exchange(exchange_id)
-    bt = ERC20Token(web3, exchange_info[FixedRateExchangeDetails.BASE_TOKEN])
+    bt = Datatoken(web3, exchange_info[FixedRateExchangeDetails.BASE_TOKEN])
 
     fees_info = exchange.get_fees_info(exchange_id)
     exchange_fee_balance_before = fees_info[balance_index]
diff --git a/tests/flows/test_multiple_pools.py b/tests/flows/test_multiple_pools.py
index f142b4a14..c2d6cc370 100644
--- a/tests/flows/test_multiple_pools.py
+++ b/tests/flows/test_multiple_pools.py
@@ -10,7 +10,7 @@
 
 from ocean_lib.config import Config
 from ocean_lib.models.bpool import BPool
-from ocean_lib.models.erc20_token import ERC20Token
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.models.factory_router import FactoryRouter
 from ocean_lib.models.fixed_rate_exchange import FixedRateExchange
 from ocean_lib.models.side_staking import SideStaking
@@ -30,18 +30,18 @@
 def test_create_pool_and_exchange(
     web3: Web3,
     config: Config,
-    ocean_token: ERC20Token,
+    ocean_token: Datatoken,
     factory_deployer_wallet: Wallet,
     publisher_wallet: Wallet,
     consumer_wallet: Wallet,
     another_consumer_wallet: Wallet,
-    erc20_token: ERC20Token,
+    datatoken: Datatoken,
 ):
     """
     Test interactions between pools, exchange, and dispenser.
     """
     bt = ocean_token
-    dt = erc20_token
+    dt = datatoken
 
     transfer_base_token_if_balance_lte(
         web3=web3,
diff --git a/tests/flows/test_nft_creation.py b/tests/flows/test_nft_creation.py
index 8e6c6cb4b..f403fbbde 100644
--- a/tests/flows/test_nft_creation.py
+++ b/tests/flows/test_nft_creation.py
@@ -5,11 +5,10 @@
 import pytest
 from web3 import Web3, exceptions
 
-from ocean_lib.models.erc20_token import ERC20Token
-from ocean_lib.models.erc721_factory import ERC721FactoryContract
-from ocean_lib.models.erc721_nft import ERC721NFT, ERC721Permissions
+from ocean_lib.models.data_nft import DataNFT, DataNFTPermissions
+from ocean_lib.models.data_nft_factory import DataNFTFactoryContract
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.web3_internal.constants import ZERO_ADDRESS
-from ocean_lib.web3_internal.currency import to_wei
 from tests.resources.helper_functions import (
     deploy_erc721_erc20,
     get_address_of_type,
@@ -18,17 +17,17 @@
 
 
 @pytest.mark.unit
-def test_erc721_roles(
+def test_data_nft_roles(
     web3, config, publisher_wallet, consumer_wallet, another_consumer_wallet
 ):
     """Test erc721 implicit and explicit role assignments  as well as removing them"""
 
     # NFT Owner is also added as manager when deploying (first time), if transferred that doesn't apply
 
-    erc721_factory = ERC721FactoryContract(
+    data_nft_factory = DataNFTFactoryContract(
         web3, get_address_of_type(config, "ERC721Factory")
     )
-    tx = erc721_factory.deploy_erc721_contract(
+    tx = data_nft_factory.deploy_erc721_contract(
         name="NFT",
         symbol="NFTSYMBOL",
         template_index=1,
@@ -40,70 +39,66 @@ def test_erc721_roles(
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_event = erc721_factory.get_event_log(
-        event_name=ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_event = data_nft_factory.get_event_log(
+        event_name=DataNFTFactoryContract.EVENT_NFT_CREATED,
         from_block=tx_receipt.blockNumber,
         to_block=web3.eth.block_number,
         filters=None,
     )
-    assert registered_event[0].event == ERC721FactoryContract.EVENT_NFT_CREATED
+    assert registered_event[0].event == DataNFTFactoryContract.EVENT_NFT_CREATED
     assert registered_event[0].args.admin == publisher_wallet.address
     token_address = registered_event[0].args.newTokenAddress
-    erc721_nft = ERC721NFT(web3, token_address)
+    data_nft = DataNFT(web3, token_address)
 
     # Publisher should be a manager
-    assert erc721_nft.get_permissions(publisher_wallet.address)[
-        ERC721Permissions.MANAGER
+    assert data_nft.get_permissions(publisher_wallet.address)[
+        DataNFTPermissions.MANAGER
     ]
 
     # Consumer address should't be manager
-    assert not erc721_nft.get_permissions(consumer_wallet.address)[
-        ERC721Permissions.MANAGER
+    assert not data_nft.get_permissions(consumer_wallet.address)[
+        DataNFTPermissions.MANAGER
     ]
 
-    erc721_nft.add_manager(consumer_wallet.address, publisher_wallet)
+    data_nft.add_manager(consumer_wallet.address, publisher_wallet)
 
     # Consumer now should be manager
-    assert erc721_nft.get_permissions(consumer_wallet.address)[
-        ERC721Permissions.MANAGER
-    ]
+    assert data_nft.get_permissions(consumer_wallet.address)[DataNFTPermissions.MANAGER]
 
     # Check the rest of roles for another_consumer_wallet
-    assert not erc721_nft.get_permissions(another_consumer_wallet.address)[
-        ERC721Permissions.MANAGER
+    assert not data_nft.get_permissions(another_consumer_wallet.address)[
+        DataNFTPermissions.MANAGER
     ]
-    assert not erc721_nft.get_permissions(another_consumer_wallet.address)[
-        ERC721Permissions.DEPLOY_ERC20
+    assert not data_nft.get_permissions(another_consumer_wallet.address)[
+        DataNFTPermissions.DEPLOY_DATATOKEN
     ]
-    assert not erc721_nft.get_permissions(another_consumer_wallet.address)[
-        ERC721Permissions.UPDATE_METADATA
+    assert not data_nft.get_permissions(another_consumer_wallet.address)[
+        DataNFTPermissions.UPDATE_METADATA
     ]
-    assert not erc721_nft.get_permissions(another_consumer_wallet.address)[
-        ERC721Permissions.STORE
+    assert not data_nft.get_permissions(another_consumer_wallet.address)[
+        DataNFTPermissions.STORE
     ]
 
-    erc721_nft.add_to_create_erc20_list(
-        another_consumer_wallet.address, consumer_wallet
-    )
-    erc721_nft.add_to_725_store_list(another_consumer_wallet.address, consumer_wallet)
-    erc721_nft.add_to_metadata_list(another_consumer_wallet.address, consumer_wallet)
+    data_nft.add_to_create_erc20_list(another_consumer_wallet.address, consumer_wallet)
+    data_nft.add_to_725_store_list(another_consumer_wallet.address, consumer_wallet)
+    data_nft.add_to_metadata_list(another_consumer_wallet.address, consumer_wallet)
 
     # Test rest of add roles functions with newly added manager
-    assert erc721_nft.get_permissions(another_consumer_wallet.address)[
-        ERC721Permissions.DEPLOY_ERC20
+    assert data_nft.get_permissions(another_consumer_wallet.address)[
+        DataNFTPermissions.DEPLOY_DATATOKEN
     ]
-    assert erc721_nft.get_permissions(another_consumer_wallet.address)[
-        ERC721Permissions.UPDATE_METADATA
+    assert data_nft.get_permissions(another_consumer_wallet.address)[
+        DataNFTPermissions.UPDATE_METADATA
     ]
-    assert erc721_nft.get_permissions(another_consumer_wallet.address)[
-        ERC721Permissions.STORE
+    assert data_nft.get_permissions(another_consumer_wallet.address)[
+        DataNFTPermissions.STORE
     ]
 
     # Remove the manager
-    erc721_nft.remove_manager(consumer_wallet.address, publisher_wallet)
+    data_nft.remove_manager(consumer_wallet.address, publisher_wallet)
 
-    assert not erc721_nft.get_permissions(consumer_wallet.address)[
-        ERC721Permissions.MANAGER
+    assert not data_nft.get_permissions(consumer_wallet.address)[
+        DataNFTPermissions.MANAGER
     ]
 
 
@@ -111,23 +106,24 @@ def test_erc721_roles(
 def test_properties(web3, config):
     """Tests the events' properties."""
 
-    erc721_factory = ERC721FactoryContract(
+    data_nft_factory = DataNFTFactoryContract(
         web3, get_address_of_type(config, "ERC721Factory")
     )
     assert (
-        erc721_factory.event_NFTCreated.abi["name"]
-        == ERC721FactoryContract.EVENT_NFT_CREATED
+        data_nft_factory.event_NFTCreated.abi["name"]
+        == DataNFTFactoryContract.EVENT_NFT_CREATED
     )
     assert (
-        erc721_factory.event_TokenCreated.abi["name"]
-        == ERC721FactoryContract.EVENT_TOKEN_CREATED
+        data_nft_factory.event_TokenCreated.abi["name"]
+        == DataNFTFactoryContract.EVENT_TOKEN_CREATED
     )
     assert (
-        erc721_factory.event_NewPool.abi["name"] == ERC721FactoryContract.EVENT_NEW_POOL
+        data_nft_factory.event_NewPool.abi["name"]
+        == DataNFTFactoryContract.EVENT_NEW_POOL
     )
     assert (
-        erc721_factory.event_NewFixedRate.abi["name"]
-        == ERC721FactoryContract.EVENT_NEW_FIXED_RATE
+        data_nft_factory.event_NewFixedRate.abi["name"]
+        == DataNFTFactoryContract.EVENT_NEW_FIXED_RATE
     )
 
 
@@ -135,17 +131,17 @@ def test_properties(web3, config):
 def test_nonexistent_template_index(web3, config, publisher_wallet):
     """Test erc721 non existent template creation fail"""
 
-    erc721_factory = ERC721FactoryContract(
+    data_nft_factory = DataNFTFactoryContract(
         web3, get_address_of_type(config, "ERC721Factory")
     )
 
     non_existent_nft_template = get_non_existent_nft_template(
-        erc721_factory, check_first=10
+        data_nft_factory, check_first=10
     )
     assert non_existent_nft_template >= 0, "Non existent NFT template not found."
 
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_factory.deploy_erc721_contract(
+        data_nft_factory.deploy_erc721_contract(
             name="DT1",
             symbol="DTSYMBOL",
             template_index=non_existent_nft_template,
@@ -164,13 +160,13 @@ def test_nonexistent_template_index(web3, config, publisher_wallet):
 
 
 @pytest.mark.unit
-def test_successful_erc721_creation(web3, config, publisher_wallet):
-    """Test erc721 successful creation"""
+def test_successful_data_nft_creation(web3, config, publisher_wallet):
+    """Test data NFT successful creation"""
 
-    erc721_factory = ERC721FactoryContract(
+    data_nft_factory = DataNFTFactoryContract(
         web3, get_address_of_type(config, "ERC721Factory")
     )
-    tx = erc721_factory.deploy_erc721_contract(
+    tx = data_nft_factory.deploy_erc721_contract(
         name="NFT",
         symbol="NFTSYMBOL",
         template_index=1,
@@ -182,19 +178,19 @@ def test_successful_erc721_creation(web3, config, publisher_wallet):
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_event = erc721_factory.get_event_log(
-        event_name=ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_event = data_nft_factory.get_event_log(
+        event_name=DataNFTFactoryContract.EVENT_NFT_CREATED,
         from_block=tx_receipt.blockNumber,
         to_block=web3.eth.block_number,
         filters=None,
     )
-    assert registered_event[0].event == ERC721FactoryContract.EVENT_NFT_CREATED
+    assert registered_event[0].event == DataNFTFactoryContract.EVENT_NFT_CREATED
     assert registered_event[0].args.admin == publisher_wallet.address
     token_address = registered_event[0].args.newTokenAddress
-    erc721_nft = ERC721NFT(web3, token_address)
-    owner_balance = erc721_nft.balance_of(publisher_wallet.address)
-    assert erc721_nft.contract.caller.name() == "NFT"
-    assert erc721_nft.symbol() == "NFTSYMBOL"
+    data_nft = DataNFT(web3, token_address)
+    owner_balance = data_nft.balance_of(publisher_wallet.address)
+    assert data_nft.contract.caller.name() == "NFT"
+    assert data_nft.symbol() == "NFTSYMBOL"
     assert owner_balance == 1
 
 
@@ -202,11 +198,11 @@ def test_successful_erc721_creation(web3, config, publisher_wallet):
 def test_nft_count(web3, config, publisher_wallet):
     """Test  erc721 factory NFT count"""
 
-    erc721_factory = ERC721FactoryContract(
+    data_nft_factory = DataNFTFactoryContract(
         web3, get_address_of_type(config, "ERC721Factory")
     )
-    current_nft_count = erc721_factory.get_current_nft_count()
-    erc721_factory.deploy_erc721_contract(
+    current_nft_count = data_nft_factory.get_current_nft_count()
+    data_nft_factory.deploy_erc721_contract(
         name="NFT",
         symbol="NFTSYMBOL",
         template_index=1,
@@ -217,17 +213,17 @@ def test_nft_count(web3, config, publisher_wallet):
         owner=publisher_wallet.address,
         from_wallet=publisher_wallet,
     )
-    assert erc721_factory.get_current_nft_count() == current_nft_count + 1
+    assert data_nft_factory.get_current_nft_count() == current_nft_count + 1
 
 
 @pytest.mark.unit
 def test_nft_template(web3, config):
     """Tests get NFT template"""
 
-    erc721_factory = ERC721FactoryContract(
+    data_nft_factory = DataNFTFactoryContract(
         web3, get_address_of_type(config, "ERC721Factory")
     )
-    nft_template = erc721_factory.get_nft_template(1)
+    nft_template = data_nft_factory.get_nft_template(1)
     assert nft_template[0] == get_address_of_type(config, "ERC721Template")
     assert nft_template[1] is True
 
@@ -238,10 +234,10 @@ def test_erc20_creation(
 ):
     """Test erc20 successful creation with owner assigned as minter"""
 
-    erc721_factory = ERC721FactoryContract(
+    data_nft_factory = DataNFTFactoryContract(
         web3, get_address_of_type(config, "ERC721Factory")
     )
-    tx = erc721_factory.deploy_erc721_contract(
+    tx = data_nft_factory.deploy_erc721_contract(
         name="NFT",
         symbol="NFTSYMBOL",
         template_index=1,
@@ -253,16 +249,16 @@ def test_erc20_creation(
         from_wallet=publisher_wallet,
     )
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_event = erc721_factory.get_event_log(
-        event_name=ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_event = data_nft_factory.get_event_log(
+        event_name=DataNFTFactoryContract.EVENT_NFT_CREATED,
         from_block=tx_receipt.blockNumber,
         to_block=web3.eth.block_number,
         filters=None,
     )
     token_address = registered_event[0].args.newTokenAddress
-    erc721_nft = ERC721NFT(web3, token_address)
-    erc721_nft.add_to_create_erc20_list(consumer_wallet.address, publisher_wallet)
-    tx_result = erc721_nft.create_erc20(
+    data_nft = DataNFT(web3, token_address)
+    data_nft.add_to_create_erc20_list(consumer_wallet.address, publisher_wallet)
+    tx_result = data_nft.create_erc20(
         template_index=1,
         name="ERC20DT1",
         symbol="ERC20DT1Symbol",
@@ -276,8 +272,8 @@ def test_erc20_creation(
     )
     tx_receipt2 = web3.eth.wait_for_transaction_receipt(tx_result)
 
-    registered_event2 = erc721_factory.get_event_log(
-        event_name=ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_event2 = data_nft_factory.get_event_log(
+        event_name=DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         from_block=tx_receipt2.blockNumber,
         to_block=web3.eth.block_number,
         filters=None,
@@ -285,16 +281,16 @@ def test_erc20_creation(
 
     erc20_address = registered_event2[0].args.newTokenAddress
 
-    erc20_token = ERC20Token(web3, erc20_address)
+    datatoken = Datatoken(web3, erc20_address)
 
-    permissions = erc20_token.get_permissions(publisher_wallet.address)
+    permissions = datatoken.get_permissions(publisher_wallet.address)
 
     assert permissions[0], "Not a minter"
     assert tx_result, "Error creating ERC20 token."
 
     # Tests failed creation of ERC20
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.create_erc20(
+        data_nft.create_erc20(
             template_index=1,
             name="ERC20DT1",
             symbol="ERC20DT1Symbol",
@@ -315,18 +311,18 @@ def test_erc20_creation(
 
 @pytest.mark.unit
 def test_erc20_mint_function(
-    web3, config, publisher_wallet, consumer_wallet, erc20_token
+    web3, config, publisher_wallet, consumer_wallet, datatoken
 ):
     """Test erc20 failed/successful mint function"""
-    erc20_token.mint(publisher_wallet.address, 10, publisher_wallet)
-    erc20_token.mint(consumer_wallet.address, 20, publisher_wallet)
+    datatoken.mint(publisher_wallet.address, 10, publisher_wallet)
+    datatoken.mint(consumer_wallet.address, 20, publisher_wallet)
 
-    assert erc20_token.balanceOf(publisher_wallet.address) == 10
-    assert erc20_token.balanceOf(consumer_wallet.address) == 20
+    assert datatoken.balanceOf(publisher_wallet.address) == 10
+    assert datatoken.balanceOf(consumer_wallet.address) == 20
 
     # Tests failed mint
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.mint(publisher_wallet.address, 10, consumer_wallet)
+        datatoken.mint(publisher_wallet.address, 10, consumer_wallet)
     assert (
         err.value.args[0]
         == "execution reverted: VM Exception while processing transaction: revert ERC20Template: NOT MINTER"
@@ -338,62 +334,62 @@ def test_erc20_mint_function(
     erc20_2.mint(publisher_wallet.address, 10, consumer_wallet)
     erc20_2.mint(consumer_wallet.address, 20, consumer_wallet)
 
-    assert erc20_token.balanceOf(publisher_wallet.address) == 10
-    assert erc20_token.balanceOf(consumer_wallet.address) == 20
+    assert datatoken.balanceOf(publisher_wallet.address) == 10
+    assert datatoken.balanceOf(consumer_wallet.address) == 20
 
 
 @pytest.mark.unit
-def test_erc20_set_data(web3, config, publisher_wallet, erc721_nft, erc20_token):
+def test_erc20_set_data(web3, config, publisher_wallet, data_nft, datatoken):
     """Test erc20 data set functions"""
 
     """This is a special metadata, it's callable only from the erc20Token contract and
     can be done only by who has deployERC20 rights(rights to create new erc20 token contract)
     the value is stored into the 725Y standard with a predefined key which is the erc20Token address"""
 
-    key = Web3.keccak(hexstr=erc20_token.address)
+    key = Web3.keccak(hexstr=datatoken.address)
 
     value = Web3.toHex(text="SomeData")
 
-    assert Web3.toHex(erc721_nft.get_data(key)) == "0x"
-    erc20_token.set_data(value, publisher_wallet)
+    assert Web3.toHex(data_nft.get_data(key)) == "0x"
+    datatoken.set_data(value, publisher_wallet)
 
-    assert Web3.toHex(erc721_nft.get_data(key)) == value
+    assert Web3.toHex(data_nft.get_data(key)) == value
     """This one is the generic version of updating data into the key-value story.
     Only users with 'store' permission can do that.
     NOTE: in this function the key is chosen by the caller."""
 
-    erc721_nft.set_new_data(Web3.keccak(text="arbitrary text"), value, publisher_wallet)
+    data_nft.set_new_data(Web3.keccak(text="arbitrary text"), value, publisher_wallet)
 
-    res = erc721_nft.get_data(Web3.keccak(text="arbitrary text"))
+    res = data_nft.get_data(Web3.keccak(text="arbitrary text"))
 
     assert Web3.toHex(res) == value
 
 
 @pytest.mark.unit
 def test_nft_owner_transfer(
-    web3, config, publisher_wallet, consumer_wallet, erc721_nft, erc20_token
+    web3, config, publisher_wallet, consumer_wallet, data_nft, datatoken
 ):
     """Test erc721 ownership transfer on token transfer"""
 
-    assert erc721_nft.owner_of(1) == publisher_wallet.address
+    assert data_nft.owner_of(1) == publisher_wallet.address
 
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.transfer_from(
+        data_nft.transfer_from(
             consumer_wallet.address, publisher_wallet.address, 1, publisher_wallet
         )
     assert (
         err.value.args[0]
         == "execution reverted: VM Exception while processing transaction: revert ERC721: transfer of token that is not own"
     )
-    erc721_nft.transfer_from(
+    data_nft.transfer_from(
         publisher_wallet.address, consumer_wallet.address, 1, publisher_wallet
     )
 
-    assert erc721_nft.balance_of(publisher_wallet.address) == 0
-    assert erc721_nft.owner_of(1) == consumer_wallet.address
+    assert data_nft.balance_of(publisher_wallet.address) == 0
+    assert data_nft.owner_of(1) == consumer_wallet.address
     # Owner is not NFT owner anymore, nor has any other role, neither older users
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc721_nft.create_erc20(
+        data_nft.create_erc20(
             template_index=1,
             name="ERC20DT1",
             symbol="ERC20DT1Symbol",
@@ -410,14 +406,14 @@ def test_nft_owner_transfer(
         == "execution reverted: VM Exception while processing transaction: revert ERC721Template: NOT ERC20DEPLOYER_ROLE"
     )
     with pytest.raises(exceptions.ContractLogicError) as err:
-        erc20_token.mint(publisher_wallet.address, 10, publisher_wallet)
+        datatoken.mint(publisher_wallet.address, 10, publisher_wallet)
     assert (
         err.value.args[0]
         == "execution reverted: VM Exception while processing transaction: revert ERC20Template: NOT MINTER"
     )
 
     # NewOwner now owns the NFT, is already Manager by default and has all roles
-    erc721_nft.create_erc20(
+    data_nft.create_erc20(
         template_index=1,
         name="ERC20DT1",
         symbol="ERC20DT1Symbol",
@@ -429,8 +425,8 @@ def test_nft_owner_transfer(
         bytess=[b""],
         from_wallet=consumer_wallet,
     )
-    erc20_token.add_minter(consumer_wallet.address, consumer_wallet)
+    datatoken.add_minter(consumer_wallet.address, consumer_wallet)
 
-    erc20_token.mint(consumer_wallet.address, 20, consumer_wallet)
+    datatoken.mint(consumer_wallet.address, 20, consumer_wallet)
 
-    assert erc20_token.balanceOf(consumer_wallet.address) == 20
+    assert datatoken.balanceOf(consumer_wallet.address) == 20
diff --git a/tests/flows/test_pool_swap_fees.py b/tests/flows/test_pool_swap_fees.py
index a79de13c4..933be9cf8 100644
--- a/tests/flows/test_pool_swap_fees.py
+++ b/tests/flows/test_pool_swap_fees.py
@@ -11,7 +11,7 @@
 
 from ocean_lib.config import Config
 from ocean_lib.models.bpool import BPool
-from ocean_lib.models.erc20_token import ERC20Token
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.models.factory_router import FactoryRouter
 from ocean_lib.models.side_staking import SideStaking
 from ocean_lib.models.test.test_factory_router import (
@@ -68,7 +68,7 @@ def test_pool_swap_fees(
     another_consumer_wallet: Wallet,
     publisher_wallet: Wallet,
     base_token_name: str,
-    erc20_token: ERC20Token,
+    datatoken: Datatoken,
     publish_market_swap_fee: str,
     consume_market_swap_fee: str,
     lp_swap_fee: str,
@@ -89,7 +89,7 @@ def test_pool_swap_fees(
         consume_market_swap_fee_collector=another_consumer_wallet,
         publisher_wallet=publisher_wallet,
         base_token_name=base_token_name,
-        datatoken=erc20_token,
+        datatoken=datatoken,
         publish_market_swap_fee=publish_market_swap_fee,
         consume_market_swap_fee=consume_market_swap_fee,
         lp_swap_fee=lp_swap_fee,
@@ -105,13 +105,13 @@ def pool_swap_fees(
     consume_market_swap_fee_collector: Wallet,
     publisher_wallet: Wallet,
     base_token_name: str,
-    datatoken: ERC20Token,
+    datatoken: Datatoken,
     publish_market_swap_fee: str,
     consume_market_swap_fee: str,
     lp_swap_fee: str,
     dt_per_bt: str,
 ):
-    bt = ERC20Token(web3, get_address_of_type(config, base_token_name))
+    bt = Datatoken(web3, get_address_of_type(config, base_token_name))
     dt = datatoken
 
     transfer_base_token_if_balance_lte(
@@ -298,8 +298,8 @@ def buy_dt_exact_amount_in(
     bt_in: int,
 ):
     """Tests consumer buys some DT - exactAmountIn"""
-    bt = ERC20Token(web3, bpool.get_base_token_address())
-    dt = ERC20Token(web3, bpool.get_datatoken_address())
+    bt = Datatoken(web3, bpool.get_base_token_address())
+    dt = Datatoken(web3, bpool.get_datatoken_address())
 
     consumer_bt_balance = bt.balanceOf(consumer_wallet.address)
     consumer_dt_balance = dt.balanceOf(consumer_wallet.address)
@@ -389,8 +389,8 @@ def buy_dt_exact_amount_out(
     dt_out: int,
 ):
     """Tests consumer buys some DT - exactAmountOut"""
-    bt = ERC20Token(web3, bpool.get_base_token_address())
-    dt = ERC20Token(web3, bpool.get_datatoken_address())
+    bt = Datatoken(web3, bpool.get_base_token_address())
+    dt = Datatoken(web3, bpool.get_datatoken_address())
 
     consumer_bt_balance = bt.balanceOf(consumer_wallet.address)
     consumer_dt_balance = dt.balanceOf(consumer_wallet.address)
@@ -480,8 +480,8 @@ def buy_bt_exact_amount_in(
     dt_in: int,
 ):
     """Tests consumer buys some BT - exactAmountIn"""
-    bt = ERC20Token(web3, bpool.get_base_token_address())
-    dt = ERC20Token(web3, bpool.get_datatoken_address())
+    bt = Datatoken(web3, bpool.get_base_token_address())
+    dt = Datatoken(web3, bpool.get_datatoken_address())
 
     consumer_bt_balance = bt.balanceOf(consumer_wallet.address)
     consumer_dt_balance = dt.balanceOf(consumer_wallet.address)
@@ -573,8 +573,8 @@ def buy_bt_exact_amount_out(
     bt_out: int,
 ):
     """Tests consumer buys some DT - exactAmountOut"""
-    bt = ERC20Token(web3, bpool.get_base_token_address())
-    dt = ERC20Token(web3, bpool.get_datatoken_address())
+    bt = Datatoken(web3, bpool.get_base_token_address())
+    dt = Datatoken(web3, bpool.get_datatoken_address())
 
     consumer_bt_balance = bt.balanceOf(consumer_wallet.address)
     consumer_dt_balance = dt.balanceOf(consumer_wallet.address)
@@ -658,8 +658,8 @@ def buy_bt_exact_amount_out(
 
 
 def check_calc_methods(web3: Web3, bpool: BPool, dt_per_bt_in_wei: int):
-    bt = ERC20Token(web3, bpool.get_base_token_address())
-    dt = ERC20Token(web3, bpool.get_datatoken_address())
+    bt = Datatoken(web3, bpool.get_base_token_address())
+    dt = Datatoken(web3, bpool.get_datatoken_address())
 
     bt_amount = parse_units("100", bt.decimals())
     dt_amount = base_token_to_datatoken(bt_amount, bt.decimals(), dt_per_bt_in_wei)
@@ -770,8 +770,8 @@ def check_balances_and_fees(
     )
     log_swap_event_args = log_swap_event[0].args
 
-    bt = ERC20Token(web3, bpool.get_base_token_address())
-    dt = ERC20Token(web3, bpool.get_datatoken_address())
+    bt = Datatoken(web3, bpool.get_base_token_address())
+    dt = Datatoken(web3, bpool.get_datatoken_address())
 
     consumer_bt_balance = bt.balanceOf(consumer_address)
     consumer_dt_balance = dt.balanceOf(consumer_address)
@@ -908,8 +908,8 @@ def collect_fee_and_verify_balances(
     bpool: BPool,
     wallet: Wallet,
 ):
-    bt = ERC20Token(web3, bpool.get_base_token_address())
-    dt = ERC20Token(web3, bpool.get_datatoken_address())
+    bt = Datatoken(web3, bpool.get_base_token_address())
+    dt = Datatoken(web3, bpool.get_datatoken_address())
 
     if method == bpool.collect_market_fee:
         fee_collector = bpool.get_publish_market_collector()
@@ -957,11 +957,11 @@ def test_swap_calculations(
     config: Config,
     factory_deployer_wallet: Wallet,
     publisher_wallet: Wallet,
-    erc20_token: ERC20Token,
+    datatoken: Datatoken,
     base_token_name: str,
 ):
-    bt = ERC20Token(web3, get_address_of_type(config, base_token_name))
-    dt = erc20_token
+    bt = Datatoken(web3, get_address_of_type(config, base_token_name))
+    dt = datatoken
 
     transfer_base_token_if_balance_lte(
         web3=web3,
diff --git a/tests/flows/test_reuse_order_fees.py b/tests/flows/test_reuse_order_fees.py
index 9b4c5ffd5..c0d6f1bbd 100644
--- a/tests/flows/test_reuse_order_fees.py
+++ b/tests/flows/test_reuse_order_fees.py
@@ -9,8 +9,8 @@
 from web3 import Web3
 
 from ocean_lib.config import Config
-from ocean_lib.models.erc20_token import ERC20Token
-from ocean_lib.models.erc721_nft import ERC721NFT
+from ocean_lib.models.data_nft import DataNFT
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.structures.file_objects import FilesType
 from ocean_lib.web3_internal.currency import MAX_WEI, parse_units, to_wei
 from ocean_lib.web3_internal.wallet import Wallet
@@ -51,12 +51,12 @@ def test_reuse_order_fees(
     factory_deployer_wallet: Wallet,
     publish_market_wallet: Wallet,
     consume_market_wallet: Wallet,
-    erc721_nft: ERC721NFT,
+    data_nft: DataNFT,
     file1: FilesType,
     base_token_name: str,
     provider_fee_in_unit: str,
 ):
-    bt = ERC20Token(web3, get_address_of_type(config, base_token_name))
+    bt = Datatoken(web3, get_address_of_type(config, base_token_name))
 
     # Send base tokens to the consumer so they can pay for fees
     transfer_base_token_if_balance_lte(
@@ -73,7 +73,7 @@ def test_reuse_order_fees(
         web3=web3,
         config=config,
         file=file1,
-        erc721_nft=erc721_nft,
+        data_nft=data_nft,
         publisher_wallet=publisher_wallet,
         publish_market_order_fee_address=publish_market_wallet.address,
         publish_market_order_fee_token=bt.address,
@@ -195,8 +195,8 @@ def test_reuse_order_fees(
 def reuse_order_with_mock_provider_fees(
     provider_fee_in_unit: str,
     start_order_tx_id: str,
-    bt: ERC20Token,
-    dt: ERC20Token,
+    bt: Datatoken,
+    dt: Datatoken,
     publisher_wallet: Wallet,
     publish_market_wallet: Wallet,
     consume_market_wallet: Wallet,
diff --git a/tests/flows/test_start_order_fees.py b/tests/flows/test_start_order_fees.py
index 9bfb0bb77..b69048a5d 100644
--- a/tests/flows/test_start_order_fees.py
+++ b/tests/flows/test_start_order_fees.py
@@ -12,8 +12,8 @@
 from ocean_lib.assets.asset import Asset
 from ocean_lib.config import Config
 from ocean_lib.data_provider.data_service_provider import DataServiceProvider
-from ocean_lib.models.erc20_token import ERC20Token
-from ocean_lib.models.erc721_nft import ERC721NFT
+from ocean_lib.models.data_nft import DataNFT
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.models.factory_router import FactoryRouter
 from ocean_lib.ocean.ocean_assets import OceanAssets
 from ocean_lib.services.service import Service
@@ -64,7 +64,7 @@ def test_start_order_fees(
     factory_deployer_wallet: Wallet,
     publish_market_wallet: Wallet,
     consume_market_wallet: Wallet,
-    erc721_nft: ERC721NFT,
+    data_nft: DataNFT,
     file1: FilesType,
     factory_router: FactoryRouter,
     base_token_name: str,
@@ -72,7 +72,7 @@ def test_start_order_fees(
     consume_market_order_fee_in_unit: str,
     provider_fee_in_unit: str,
 ):
-    bt = ERC20Token(web3, get_address_of_type(config, base_token_name))
+    bt = Datatoken(web3, get_address_of_type(config, base_token_name))
 
     # Send base tokens to the consumer so they can pay for fees
     transfer_base_token_if_balance_lte(
@@ -92,7 +92,7 @@ def test_start_order_fees(
         web3=web3,
         config=config,
         file=file1,
-        erc721_nft=erc721_nft,
+        data_nft=data_nft,
         publisher_wallet=publisher_wallet,
         publish_market_order_fee_address=publish_market_wallet.address,
         publish_market_order_fee_token=bt.address,
@@ -216,16 +216,16 @@ def create_asset_with_order_fee_and_timeout(
     web3: Web3,
     config: Config,
     file: FilesType,
-    erc721_nft: ERC721NFT,
+    data_nft: DataNFT,
     publisher_wallet: Wallet,
     publish_market_order_fee_address: str,
     publish_market_order_fee_token: str,
     publish_market_order_fee_amount: int,
     timeout: int,
-) -> Tuple[Asset, Service, ERC20Token]:
+) -> Tuple[Asset, Service, Datatoken]:
 
     # Create datatoken with order fee
-    datatoken = erc721_nft.create_datatoken(
+    datatoken = data_nft.create_datatoken(
         template_index=1,
         name="Datatoken 1",
         symbol="DT1",
@@ -269,11 +269,11 @@ def create_asset_with_order_fee_and_timeout(
         metadata=metadata,
         publisher_wallet=publisher_wallet,
         services=[service],
-        erc721_address=erc721_nft.address,
-        deployed_erc20_tokens=[datatoken],
+        erc721_address=data_nft.address,
+        deployed_datatokens=[datatoken],
     )
 
     service = get_first_service_by_type(asset, ServiceTypes.ASSET_ACCESS)
-    dt = ERC20Token(web3, asset.datatokens[0]["address"])
+    dt = Datatoken(web3, asset.datatokens[0]["address"])
 
     return asset, service, dt
diff --git a/tests/integration/test_compute_flow.py b/tests/integration/test_compute_flow.py
index 4d78b8cdf..c378a3f11 100644
--- a/tests/integration/test_compute_flow.py
+++ b/tests/integration/test_compute_flow.py
@@ -13,7 +13,7 @@
 from ocean_lib.assets.asset import Asset
 from ocean_lib.exceptions import DataProviderException
 from ocean_lib.models.compute_input import ComputeInput
-from ocean_lib.models.erc20_token import ERC20Token
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.ocean.ocean import Ocean
 from ocean_lib.structures.algorithm_metadata import AlgorithmMetadata
 from ocean_lib.web3_internal.currency import to_wei
@@ -145,19 +145,19 @@ def _mint_and_build_compute_input(
     ocean_instance: Ocean,
 ) -> ComputeInput:
     service = get_first_service_by_type(dataset_and_userdata.asset, service_type)
-    erc20_token = ERC20Token(ocean_instance.web3, service.datatoken)
+    datatoken = Datatoken(ocean_instance.web3, service.datatoken)
     minter = (
         consumer_wallet
-        if erc20_token.is_minter(consumer_wallet.address)
+        if datatoken.is_minter(consumer_wallet.address)
         else publisher_wallet
     )
-    erc20_token.mint(consumer_wallet.address, to_wei(10), minter)
+    datatoken.mint(consumer_wallet.address, to_wei(10), minter)
 
     return ComputeInput(
         dataset_and_userdata.asset,
         service,
         userdata=dataset_and_userdata.userdata,
-        consume_market_order_fee_token=erc20_token.address,
+        consume_market_order_fee_token=datatoken.address,
         consume_market_order_fee_amount=0,
     )
 
diff --git a/tests/integration/test_consume_flow.py b/tests/integration/test_consume_flow.py
index 11321df40..788057c7b 100644
--- a/tests/integration/test_consume_flow.py
+++ b/tests/integration/test_consume_flow.py
@@ -11,8 +11,8 @@
 from ocean_lib.agreements.service_types import ServiceTypes
 from ocean_lib.config import Config
 from ocean_lib.data_provider.data_service_provider import DataServiceProvider
-from ocean_lib.models.erc20_token import ERC20Token
-from ocean_lib.models.erc721_nft import ERC721NFT
+from ocean_lib.models.data_nft import DataNFT
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.ocean.ocean_assets import OceanAssets
 from ocean_lib.structures.file_objects import FilesType
 from ocean_lib.web3_internal.constants import ZERO_ADDRESS
@@ -27,7 +27,7 @@ def test_consume_flow(
     config: Config,
     publisher_wallet: Wallet,
     consumer_wallet: Wallet,
-    erc721_nft: ERC721NFT,
+    data_nft: DataNFT,
     file1: FilesType,
 ):
     data_provider = DataServiceProvider
@@ -52,7 +52,7 @@ def test_consume_flow(
         metadata=metadata,
         publisher_wallet=publisher_wallet,
         encrypted_files=encrypted_files,
-        erc721_address=erc721_nft.address,
+        erc721_address=data_nft.address,
         erc20_templates=[1],
         erc20_names=["Datatoken 1"],
         erc20_symbols=["DT1"],
@@ -67,13 +67,13 @@ def test_consume_flow(
     assert asset, "The asset is not created."
     assert asset.nft["name"] == "NFT"
     assert asset.nft["symbol"] == "NFTSYMBOL"
-    assert asset.nft["address"] == erc721_nft.address
+    assert asset.nft["address"] == data_nft.address
     assert asset.nft["owner"] == publisher_wallet.address
     assert asset.datatokens[0]["name"] == "Datatoken 1"
     assert asset.datatokens[0]["symbol"] == "DT1"
 
     service = get_first_service_by_type(asset, ServiceTypes.ASSET_ACCESS)
-    dt = ERC20Token(web3, asset.datatokens[0]["address"])
+    dt = Datatoken(web3, asset.datatokens[0]["address"])
 
     # Mint 50 ERC20 tokens in consumer wallet from publisher. Max cap = 100
     dt.mint(
diff --git a/tests/integration/test_market_flow.py b/tests/integration/test_market_flow.py
index 0b6240189..d85dc6af2 100644
--- a/tests/integration/test_market_flow.py
+++ b/tests/integration/test_market_flow.py
@@ -32,17 +32,17 @@ def test_market_flow(
 
     asset = get_registered_asset_with_access_service(publisher_ocean, publisher_wallet)
     service = asset.services[0]
-    erc20_token = publisher_ocean.get_datatoken(service.datatoken)
+    datatoken = publisher_ocean.get_datatoken(service.datatoken)
 
     # Mint data tokens and assign to publisher
-    erc20_token.mint(
+    datatoken.mint(
         account_address=publisher_wallet.address,
         value=to_wei(50),
         from_wallet=publisher_wallet,
     )
 
     # Give the consumer some datatokens so they can order the service
-    erc20_token.transfer(consumer_wallet.address, to_wei(10), publisher_wallet)
+    datatoken.transfer(consumer_wallet.address, to_wei(10), publisher_wallet)
 
     # Place order for the download service
     if consumer_type == "publisher":
@@ -50,7 +50,7 @@ def test_market_flow(
             asset,
             service,
             consume_market_order_fee_address=consumer_wallet.address,
-            consume_market_order_fee_token=erc20_token.address,
+            consume_market_order_fee_token=datatoken.address,
             consume_market_order_fee_amount=0,
             wallet=consumer_wallet,
         )
@@ -66,7 +66,7 @@ def test_market_flow(
             asset,
             service,
             consume_market_order_fee_address=another_consumer_wallet.address,
-            consume_market_order_fee_token=erc20_token.address,
+            consume_market_order_fee_token=datatoken.address,
             consume_market_order_fee_amount=0,
             wallet=consumer_wallet,
             consumer_address=another_consumer_wallet.address,
@@ -81,22 +81,20 @@ def test_market_flow(
 
     assert len(os.listdir(asset_folder)) >= 1, "The asset folder is empty."
 
-    orders = consumer_ocean.get_user_orders(
-        consumer_wallet.address, erc20_token.address
-    )
+    orders = consumer_ocean.get_user_orders(consumer_wallet.address, datatoken.address)
     assert (
         orders
-    ), f"no orders found using the order history: datatoken {erc20_token.address}, consumer {consumer_wallet.address}"
+    ), f"no orders found using the order history: datatoken {datatoken.address}, consumer {consumer_wallet.address}"
 
     orders = consumer_ocean.get_user_orders(
         consumer_wallet.address,
-        consumer_ocean.web3.toChecksumAddress(erc20_token.address),
+        consumer_ocean.web3.toChecksumAddress(datatoken.address),
     )
     assert (
         orders
-    ), f"no orders found using the order history: datatoken {erc20_token.address}, consumer {consumer_wallet.address}"
+    ), f"no orders found using the order history: datatoken {datatoken.address}, consumer {consumer_wallet.address}"
 
     orders = consumer_ocean.get_user_orders(consumer_wallet.address)
     assert (
         orders
-    ), f"no orders found using the order history: datatoken {erc20_token.address}, consumer {consumer_wallet.address}"
+    ), f"no orders found using the order history: datatoken {datatoken.address}, consumer {consumer_wallet.address}"
diff --git a/tests/integration/test_swap_fees_fuzzing.py b/tests/integration/test_swap_fees_fuzzing.py
index 1e2470437..49936c6eb 100644
--- a/tests/integration/test_swap_fees_fuzzing.py
+++ b/tests/integration/test_swap_fees_fuzzing.py
@@ -10,7 +10,7 @@
 from time import time
 
 from ocean_lib.models.bpool import BPool
-from ocean_lib.models.erc20_token import ERC20Token
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.web3_internal.currency import from_wei, to_wei
 from tests.resources.helper_functions import approx_from_wei, create_nft_erc20_with_pool
 
@@ -18,7 +18,7 @@
 
 
 def get_random_max_token_amount_in(
-    token_in: ERC20Token, bpool: BPool, wallet_address: str
+    token_in: Datatoken, bpool: BPool, wallet_address: str
 ) -> int:
     """Returns a random amount of tokens of token_in that is less than the max_in_ratio_in of the pool and
     less than the balance of the wallet in the token_in"""
@@ -37,7 +37,7 @@ def get_random_max_token_amount_in(
 
 
 def get_random_max_token_amount_out(
-    token_in: ERC20Token, token_out: ERC20Token, bpool: BPool, wallet_address: str
+    token_in: Datatoken, token_out: Datatoken, bpool: BPool, wallet_address: str
 ) -> int:
     """Returns a random amount of tokens of token_out that is less than the max_out_ratio_out of the pool and
     and less than the maximum amount of token_out that can be purchased by the wallet_address"""
@@ -108,7 +108,7 @@ def test_fuzzing_pool_ocean(
 
             ss_rate = to_wei(Decimal(random.uniform(1 / 10**6, 10**4)))
 
-            bpool, erc20_token, _, _ = create_nft_erc20_with_pool(
+            bpool, datatoken, _, _ = create_nft_erc20_with_pool(
                 web3=web3,
                 config=config,
                 publisher_wallet=consumer_wallet,
@@ -125,14 +125,14 @@ def test_fuzzing_pool_ocean(
             )
 
             assert ocean_token.balanceOf(bpool.address) == ss_OCEAN_init_liquidity
-            assert erc20_token.balanceOf(publisher_wallet.address) == 0
+            assert datatoken.balanceOf(publisher_wallet.address) == 0
 
-            publisher_dt_balance = erc20_token.balanceOf(publisher_wallet.address)
+            publisher_dt_balance = datatoken.balanceOf(publisher_wallet.address)
             publisher_ocean_balance = ocean_token.balanceOf(publisher_wallet.address)
 
             # Large approvals for the rest of tests
             ocean_token.approve(bpool.address, to_wei(big_allowance), publisher_wallet)
-            erc20_token.approve(bpool.address, to_wei(big_allowance), publisher_wallet)
+            datatoken.approve(bpool.address, to_wei(big_allowance), publisher_wallet)
 
             swap_in_one_amount_in = get_random_max_token_amount_in(
                 ocean_token, bpool, publisher_wallet.address
@@ -140,7 +140,7 @@ def test_fuzzing_pool_ocean(
 
             tx = bpool.swap_exact_amount_in(
                 token_in=ocean_token.address,
-                token_out=erc20_token.address,
+                token_out=datatoken.address,
                 consume_market_swap_fee_address=another_consumer_wallet.address,
                 token_amount_in=swap_in_one_amount_in,
                 min_amount_out=1,
@@ -151,7 +151,7 @@ def test_fuzzing_pool_ocean(
 
             tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
 
-            assert (erc20_token.balanceOf(publisher_wallet.address) > 0) is True
+            assert (datatoken.balanceOf(publisher_wallet.address) > 0) is True
 
             swap_fee_event = bpool.get_event_log(
                 bpool.EVENT_LOG_SWAP,
@@ -169,24 +169,24 @@ def test_fuzzing_pool_ocean(
                 == publisher_ocean_balance
             )
             assert (
-                erc20_token.balanceOf(publisher_wallet.address)
+                datatoken.balanceOf(publisher_wallet.address)
                 == publisher_dt_balance + swap_event_args.tokenAmountOut
             )
 
             # Tests publisher buys some DT - exactAmountOut
-            publisher_dt_balance = erc20_token.balanceOf(publisher_wallet.address)
+            publisher_dt_balance = datatoken.balanceOf(publisher_wallet.address)
             publisher_ocean_balance = ocean_token.balanceOf(publisher_wallet.address)
-            dt_market_fee_balance = bpool.publish_market_fee(erc20_token.address)
+            dt_market_fee_balance = bpool.publish_market_fee(datatoken.address)
             ocean_market_fee_balance = bpool.publish_market_fee(ocean_token.address)
 
             swap_out_one_amount_out = get_random_max_token_amount_out(
-                ocean_token, erc20_token, bpool, publisher_wallet.address
+                ocean_token, datatoken, bpool, publisher_wallet.address
             )
             swap_out_one_balance = ocean_token.balanceOf(publisher_wallet.address)
 
             tx = bpool.swap_exact_amount_out(
                 token_in=ocean_token.address,
-                token_out=erc20_token.address,
+                token_out=datatoken.address,
                 consume_market_swap_fee_address=another_consumer_wallet.address,
                 max_amount_in=swap_out_one_balance,
                 token_amount_out=swap_out_one_amount_out,
@@ -212,7 +212,7 @@ def test_fuzzing_pool_ocean(
                 == publisher_ocean_balance
             )
             assert (
-                erc20_token.balanceOf(publisher_wallet.address)
+                datatoken.balanceOf(publisher_wallet.address)
                 == publisher_dt_balance + swap_event_args.tokenAmountOut
             )
 
@@ -226,23 +226,21 @@ def test_fuzzing_pool_ocean(
                 ocean_market_fee_balance + swap_fees_event_args.marketFeeAmount
                 == bpool.publish_market_fee(swap_fees_event_args.tokenFeeAddress)
             )
-            assert dt_market_fee_balance == bpool.publish_market_fee(
-                erc20_token.address
-            )
+            assert dt_market_fee_balance == bpool.publish_market_fee(datatoken.address)
 
             # Tests publisher swaps some DT back to Ocean with swapExactAmountIn, check swap custom fees
             assert bpool.is_finalized() is True
 
-            erc20_token.approve(bpool.address, to_wei(big_allowance), publisher_wallet)
-            publisher_dt_balance = erc20_token.balanceOf(publisher_wallet.address)
-            dt_market_fee_balance = bpool.publish_market_fee(erc20_token.address)
+            datatoken.approve(bpool.address, to_wei(big_allowance), publisher_wallet)
+            publisher_dt_balance = datatoken.balanceOf(publisher_wallet.address)
+            dt_market_fee_balance = bpool.publish_market_fee(datatoken.address)
 
             swap_in_two_amount_in = get_random_max_token_amount_in(
-                erc20_token, bpool, publisher_wallet.address
+                datatoken, bpool, publisher_wallet.address
             )
 
             tx = bpool.swap_exact_amount_in(
-                token_in=erc20_token.address,
+                token_in=datatoken.address,
                 token_out=ocean_token.address,
                 consume_market_swap_fee_address=another_consumer_wallet.address,
                 token_amount_in=swap_in_two_amount_in,
@@ -280,7 +278,7 @@ def test_fuzzing_pool_ocean(
             swap_event_args = swap_event[0].args
 
             assert (
-                erc20_token.balanceOf(publisher_wallet.address)
+                datatoken.balanceOf(publisher_wallet.address)
                 + swap_event_args.tokenAmountIn
                 == publisher_dt_balance
             )
@@ -299,18 +297,18 @@ def test_fuzzing_pool_ocean(
 
             # Tests publisher swaps some DT back to Ocean with swapExactAmountOut, check swap custom fees
 
-            erc20_token.approve(bpool.address, to_wei(big_allowance), publisher_wallet)
-            publisher_dt_balance = erc20_token.balanceOf(publisher_wallet.address)
+            datatoken.approve(bpool.address, to_wei(big_allowance), publisher_wallet)
+            publisher_dt_balance = datatoken.balanceOf(publisher_wallet.address)
             publisher_ocean_balance = ocean_token.balanceOf(publisher_wallet.address)
-            dt_market_fee_balance = bpool.publish_market_fee(erc20_token.address)
+            dt_market_fee_balance = bpool.publish_market_fee(datatoken.address)
 
             swap_out_two_amount_out = get_random_max_token_amount_out(
-                erc20_token, ocean_token, bpool, publisher_wallet.address
+                datatoken, ocean_token, bpool, publisher_wallet.address
             )
-            swap_out_two_balance = erc20_token.balanceOf(publisher_wallet.address)
+            swap_out_two_balance = datatoken.balanceOf(publisher_wallet.address)
 
             tx = bpool.swap_exact_amount_out(
-                token_in=erc20_token.address,
+                token_in=datatoken.address,
                 token_out=ocean_token.address,
                 consume_market_swap_fee_address=another_consumer_wallet.address,
                 max_amount_in=swap_out_two_balance,
@@ -342,7 +340,7 @@ def test_fuzzing_pool_ocean(
             swap_event_args = swap_event[0].args
 
             assert (
-                erc20_token.balanceOf(publisher_wallet.address)
+                datatoken.balanceOf(publisher_wallet.address)
                 + swap_event_args.tokenAmountIn
                 == publisher_dt_balance
             )
@@ -367,7 +365,7 @@ def test_fuzzing_pool_ocean(
             error = traceback.format_exc()
 
             dt_balance = (
-                erc20_token.balanceOf(publisher_wallet.address) if erc20_token else 0
+                datatoken.balanceOf(publisher_wallet.address) if datatoken else 0
             )
             ocean_balance = (
                 ocean_token.balanceOf(publisher_wallet.address) if ocean_token else 0
@@ -393,18 +391,18 @@ def test_fuzzing_pool_ocean(
 
             errors.append([error, params])
         finally:
-            final_datatoken_balance = erc20_token.balanceOf(publisher_wallet.address)
+            final_datatoken_balance = datatoken.balanceOf(publisher_wallet.address)
             # sell all the datatokens before ending
-            if final_datatoken_balance > 0 and erc20_token and bpool:
+            if final_datatoken_balance > 0 and datatoken and bpool:
                 tx = bpool.swap_exact_amount_in(
-                    token_in=erc20_token.address,
+                    token_in=datatoken.address,
                     token_out=ocean_token.address,
                     consume_market_swap_fee_address=another_consumer_wallet.address,
                     token_amount_in=min(
-                        erc20_token.balanceOf(publisher_wallet.address),
+                        datatoken.balanceOf(publisher_wallet.address),
                         to_wei(
                             from_wei(bpool.get_max_in_ratio())
-                            * from_wei(bpool.get_balance(erc20_token.address))
+                            * from_wei(bpool.get_balance(datatoken.address))
                         ),
                     ),
                     min_amount_out=1,
@@ -414,7 +412,7 @@ def test_fuzzing_pool_ocean(
                 )
 
                 web3.eth.wait_for_transaction_receipt(tx)
-                last = erc20_token.balanceOf(publisher_wallet.address)
+                last = datatoken.balanceOf(publisher_wallet.address)
                 print(last)
 
     # print errors
diff --git a/tests/readmes/test_c2d_flow.py b/tests/readmes/test_c2d_flow.py
index 13239c95e..6fe639393 100644
--- a/tests/readmes/test_c2d_flow.py
+++ b/tests/readmes/test_c2d_flow.py
@@ -76,13 +76,13 @@ def c2d_flow_readme(
     assert alice_wallet.web3.eth.get_balance(alice_wallet.address) > 0, "need ETH"
 
     # Publish the data NFT token
-    erc721_nft = ocean.create_erc721_nft("NFTToken1", "NFT1", alice_wallet)
-    assert erc721_nft.address
-    assert erc721_nft.token_name()
-    assert erc721_nft.symbol()
+    data_nft = ocean.create_data_nft("NFTToken1", "NFT1", alice_wallet)
+    assert data_nft.address
+    assert data_nft.token_name()
+    assert data_nft.symbol()
 
     # Publish the datatoken
-    DATA_datatoken = erc721_nft.create_datatoken(
+    DATA_datatoken = data_nft.create_datatoken(
         "Datatoken 1",
         "DT1",
         from_wallet=alice_wallet,
@@ -133,8 +133,8 @@ def c2d_flow_readme(
         publisher_wallet=alice_wallet,
         encrypted_files=DATA_encrypted_files,
         services=[DATA_compute_service],
-        erc721_address=erc721_nft.address,
-        deployed_erc20_tokens=[DATA_datatoken],
+        erc721_address=data_nft.address,
+        deployed_datatokens=[DATA_datatoken],
     )
 
     assert DATA_asset.did, "create dataset with compute service unsuccessful"
@@ -142,7 +142,7 @@ def c2d_flow_readme(
     # 3. Alice publishes algorithm
 
     # Publish the algorithm NFT token
-    ALGO_nft_token = ocean.create_erc721_nft("NFTToken1", "NFT1", alice_wallet)
+    ALGO_nft_token = ocean.create_data_nft("NFTToken1", "NFT1", alice_wallet)
     assert ALGO_nft_token.address
 
     # Publish the datatoken
@@ -190,7 +190,7 @@ def c2d_flow_readme(
         publisher_wallet=alice_wallet,
         encrypted_files=ALGO_encrypted_files,
         erc721_address=ALGO_nft_token.address,
-        deployed_erc20_tokens=[ALGO_datatoken],
+        deployed_datatokens=[ALGO_datatoken],
     )
 
     assert ALGO_asset.did, "create algorithm unsuccessful"
diff --git a/tests/resources/ddo_helpers.py b/tests/resources/ddo_helpers.py
index 950f8b0c3..c766e945a 100644
--- a/tests/resources/ddo_helpers.py
+++ b/tests/resources/ddo_helpers.py
@@ -14,8 +14,8 @@
 from ocean_lib.assets.asset import Asset
 from ocean_lib.data_provider.data_service_provider import DataServiceProvider
 from ocean_lib.models.bpool import BPool
-from ocean_lib.models.erc20_token import ERC20Token
-from ocean_lib.models.erc721_factory import ERC721FactoryContract
+from ocean_lib.models.datatoken import Datatoken
+from ocean_lib.models.data_nft_factory import DataNFTFactoryContract
 from ocean_lib.models.factory_router import FactoryRouter
 from ocean_lib.models.fixed_rate_exchange import FixedRateExchange
 from ocean_lib.ocean.ocean import Ocean
@@ -153,10 +153,10 @@ def create_basics(
     :param asset_type: used to populate metadata.type, optionally set to "algorithm"
     :param files: list of file objects creates with FilesTypeFactory
     """
-    erc721_factory_address = get_address_of_type(
-        config, ERC721FactoryContract.CONTRACT_NAME
+    data_nft_factory_address = get_address_of_type(
+        config, DataNFTFactoryContract.CONTRACT_NAME
     )
-    erc721_factory = ERC721FactoryContract(web3, erc721_factory_address)
+    data_nft_factory = DataNFTFactoryContract(web3, data_nft_factory_address)
 
     metadata = {
         "created": "2020-11-15T12:27:48Z",
@@ -175,7 +175,7 @@ def create_basics(
     encrypt_response = data_provider.encrypt(files, config.provider_url)
     encrypted_files = encrypt_response.content.decode("utf-8")
 
-    return erc721_factory, metadata, encrypted_files
+    return data_nft_factory, metadata, encrypted_files
 
 
 def get_registered_asset_with_access_service(ocean_instance, publisher_wallet):
@@ -189,7 +189,7 @@ def get_registered_asset_with_compute_service(
     trusted_algorithms: List[Asset] = [],
     trusted_algorithm_publishers: List[str] = [],
 ):
-    erc721_nft, erc20_token = deploy_erc721_erc20(
+    data_nft, datatoken = deploy_erc721_erc20(
         ocean_instance.web3, ocean_instance.config, publisher_wallet, publisher_wallet
     )
 
@@ -215,7 +215,7 @@ def get_registered_asset_with_compute_service(
         service_id="2",
         service_type=ServiceTypes.CLOUD_COMPUTE,
         service_endpoint=data_provider.get_url(config),
-        datatoken=erc20_token.address,
+        datatoken=datatoken.address,
         files=encrypted_files,
         timeout=3600,
         compute_values=compute_values,
@@ -231,8 +231,8 @@ def get_registered_asset_with_compute_service(
         metadata=metadata,
         publisher_wallet=publisher_wallet,
         services=[compute_service],
-        erc721_address=erc721_nft.address,
-        deployed_erc20_tokens=[erc20_token],
+        erc721_address=data_nft.address,
+        deployed_datatokens=[datatoken],
         encrypt_flag=True,
         compress_flag=True,
     )
@@ -334,7 +334,7 @@ def get_first_service_by_type(asset, service_type: str) -> Service:
 
 def get_opc_collector_address_from_pool(pool: BPool) -> str:
     return FactoryRouter(
-        pool.web3, ERC20Token(pool.web3, pool.get_datatoken_address()).router()
+        pool.web3, Datatoken(pool.web3, pool.get_datatoken_address()).router()
     ).get_opc_collector()
 
 
@@ -342,5 +342,5 @@ def get_opc_collector_address_from_exchange(exchange: FixedRateExchange) -> str:
     return FactoryRouter(exchange.web3, exchange.router()).get_opc_collector()
 
 
-def get_opc_collector_address_from_erc20(erc20_token: ERC20Token) -> str:
-    return FactoryRouter(erc20_token.web3, erc20_token.router()).get_opc_collector()
+def get_opc_collector_address_from_erc20(datatoken: Datatoken) -> str:
+    return FactoryRouter(datatoken.web3, datatoken.router()).get_opc_collector()
diff --git a/tests/resources/helper_functions.py b/tests/resources/helper_functions.py
index 1febc33fb..61595cc1e 100644
--- a/tests/resources/helper_functions.py
+++ b/tests/resources/helper_functions.py
@@ -20,9 +20,9 @@
 from ocean_lib.config import Config
 from ocean_lib.example_config import ExampleConfig
 from ocean_lib.models.bpool import BPool
-from ocean_lib.models.erc20_token import ERC20Token
-from ocean_lib.models.erc721_factory import ERC721FactoryContract
-from ocean_lib.models.erc721_nft import ERC721NFT
+from ocean_lib.models.data_nft import DataNFT
+from ocean_lib.models.data_nft_factory import DataNFTFactoryContract
+from ocean_lib.models.datatoken import Datatoken
 from ocean_lib.ocean.ocean import Ocean
 from ocean_lib.ocean.util import get_contracts_addresses
 from ocean_lib.ocean.util import get_web3 as util_get_web3
@@ -230,17 +230,17 @@ def deploy_erc721_erc20(
     erc721_publisher: Wallet,
     erc20_minter: Optional[Wallet] = None,
     template_index: Optional[int] = 1,
-) -> Union[ERC721NFT, Tuple[ERC721NFT, ERC20Token]]:
-    """Helper function to deploy an ERC721NFT using erc721_publisher Wallet
-    and an ERC20Token data token with the newly ERC721NFT using erc20_minter Wallet
+) -> Union[DataNFT, Tuple[DataNFT, Datatoken]]:
+    """Helper function to deploy an DataNFT using erc721_publisher Wallet
+    and an Datatoken data token with the newly DataNFT using erc20_minter Wallet
     if the wallet is provided.
-    :rtype: Union[ERC721NFT, Tuple[ERC721NFT, ERC20Token]]
+    :rtype: Union[DataNFT, Tuple[DataNFT, Datatoken]]
     """
 
-    erc721_factory = ERC721FactoryContract(
+    data_nft_factory = DataNFTFactoryContract(
         web3, get_address_of_type(config, "ERC721Factory")
     )
-    tx = erc721_factory.deploy_erc721_contract(
+    tx = data_nft_factory.deploy_erc721_contract(
         name="NFT",
         symbol="NFTSYMBOL",
         template_index=1,
@@ -251,12 +251,12 @@ def deploy_erc721_erc20(
         owner=erc721_publisher.address,
         from_wallet=erc721_publisher,
     )
-    token_address = erc721_factory.get_token_address(tx)
-    erc721_nft = ERC721NFT(web3, token_address)
+    token_address = data_nft_factory.get_token_address(tx)
+    data_nft = DataNFT(web3, token_address)
     if not erc20_minter:
-        return erc721_nft
+        return data_nft
 
-    tx_result = erc721_nft.create_erc20(
+    tx_result = data_nft.create_erc20(
         template_index=template_index,
         name="ERC20DT1",
         symbol="ERC20DT1Symbol",
@@ -270,8 +270,8 @@ def deploy_erc721_erc20(
     )
     tx_receipt2 = web3.eth.wait_for_transaction_receipt(tx_result)
 
-    registered_event2 = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_event2 = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt2.blockNumber,
         web3.eth.block_number,
         None,
@@ -279,20 +279,20 @@ def deploy_erc721_erc20(
 
     erc20_address = registered_event2[0].args.newTokenAddress
 
-    erc20_token = ERC20Token(web3, erc20_address)
+    datatoken = Datatoken(web3, erc20_address)
 
-    return erc721_nft, erc20_token
+    return data_nft, datatoken
 
 
 @enforce_types
 def get_non_existent_nft_template(
-    erc721_factory: ERC721FactoryContract, check_first=20
+    data_nft_factory: DataNFTFactoryContract, check_first=20
 ) -> int:
     """Helper function to find a non existent ERC721 template among the first *check_first* templates
-    of an ERC721 Factory contract. Returns -1 if template was found.
+    of an Data NFT Factory contract. Returns -1 if template was found.
     """
     for template_nbr in range(check_first):
-        [address, _] = erc721_factory.get_nft_template(template_nbr)
+        [address, _] = data_nft_factory.get_nft_template(template_nbr)
         if address == ZERO_ADDRESS:
             return template_nbr
 
@@ -308,7 +308,7 @@ def send_mock_usdc_to_address(
     """
     factory_deployer = get_factory_deployer_wallet(config.network_name)
 
-    mock_usdc = ERC20Token(web3, get_address_of_type(config, "MockUSDC"))
+    mock_usdc = Datatoken(web3, get_address_of_type(config, "MockUSDC"))
     initial_recipient_balance = mock_usdc.balanceOf(recipient)
 
     if mock_usdc.balanceOf(factory_deployer.address) >= amount:
@@ -330,7 +330,7 @@ def transfer_base_token_if_balance_lte(
     is less or equal to min_balance and from_wallet has enough ocean balance to send.
     Returns the transferred ocean amount.
     """
-    base_token = ERC20Token(web3, base_token_address)
+    base_token = Datatoken(web3, base_token_address)
     initial_recipient_balance = base_token.balanceOf(recipient)
     if (
         initial_recipient_balance <= min_balance
@@ -440,16 +440,18 @@ def create_nft_erc20_with_pool(
     initial_pool_liquidity=to_wei("100"),
     pool_initial_rate=to_wei("1"),
 ):
-    erc721_factory_address = get_address_of_type(
-        config, ERC721FactoryContract.CONTRACT_NAME
+    data_nft_factory_address = get_address_of_type(
+        config, DataNFTFactoryContract.CONTRACT_NAME
     )
-    erc721_factory = ERC721FactoryContract(web3, erc721_factory_address)
+    data_nft_factory = DataNFTFactoryContract(web3, data_nft_factory_address)
     side_staking_address = get_address_of_type(config, "Staking")
     pool_template_address = get_address_of_type(config, "poolTemplate")
 
-    base_token.approve(erc721_factory_address, initial_pool_liquidity, publisher_wallet)
+    base_token.approve(
+        data_nft_factory_address, initial_pool_liquidity, publisher_wallet
+    )
 
-    tx = erc721_factory.create_nft_erc20_with_pool(
+    tx = data_nft_factory.create_nft_erc20_with_pool(
         nft_name="72120Bundle",
         nft_symbol="72Bundle",
         nft_template=1,
@@ -471,7 +473,7 @@ def create_nft_erc20_with_pool(
         pool_side_staking=side_staking_address,
         pool_base_token=base_token.address,
         pool_base_token_sender=get_address_of_type(
-            config, ERC721FactoryContract.CONTRACT_NAME
+            config, DataNFTFactoryContract.CONTRACT_NAME
         ),
         pool_publisher=publisher_wallet.address,
         pool_publish_market_swap_fee_collector=publisher_wallet.address,
@@ -482,27 +484,27 @@ def create_nft_erc20_with_pool(
     )
 
     tx_receipt = web3.eth.wait_for_transaction_receipt(tx)
-    registered_nft_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_NFT_CREATED,
+    registered_nft_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_NFT_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
     )
-    erc721_token_address = registered_nft_event[0].args.newTokenAddress
-    erc721_token = ERC721NFT(web3, erc721_token_address)
+    data_nft_token_address = registered_nft_event[0].args.newTokenAddress
+    data_nft_token = DataNFT(web3, data_nft_token_address)
 
-    registered_token_event = erc721_factory.get_event_log(
-        ERC721FactoryContract.EVENT_TOKEN_CREATED,
+    registered_token_event = data_nft_factory.get_event_log(
+        DataNFTFactoryContract.EVENT_TOKEN_CREATED,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
     )
 
     erc20_address = registered_token_event[0].args.newTokenAddress
-    erc20_token = ERC20Token(web3, erc20_address)
+    datatoken = Datatoken(web3, erc20_address)
 
-    registered_pool_event = erc20_token.get_event_log(
-        ERC721FactoryContract.EVENT_NEW_POOL,
+    registered_pool_event = datatoken.get_event_log(
+        DataNFTFactoryContract.EVENT_NEW_POOL,
         tx_receipt.blockNumber,
         web3.eth.block_number,
         None,
@@ -510,9 +512,9 @@ def create_nft_erc20_with_pool(
 
     pool_address = registered_pool_event[0].args.poolAddress
     bpool = BPool(web3, pool_address)
-    pool_token = ERC20Token(web3, pool_address)
+    pool_token = Datatoken(web3, pool_address)
 
-    return bpool, erc20_token, erc721_token, pool_token
+    return bpool, datatoken, data_nft_token, pool_token
 
 
 def join_pool_with_max_base_token(bpool, web3, base_token, wallet, amt: int = 0):
diff --git a/tests/stress/compute_flow_with_threads.py b/tests/stress/compute_flow_with_threads.py
index 687361e64..2bfd6f57b 100644
--- a/tests/stress/compute_flow_with_threads.py
+++ b/tests/stress/compute_flow_with_threads.py
@@ -30,13 +30,13 @@ def c2d_flow_readme(
 ):
     consumer_wallet = publisher_wallet = generate_wallet()
     # Publish the data NFT token
-    erc721_nft = ocean.create_erc721_nft("NFTToken1", "NFT1", publisher_wallet)
-    assert erc721_nft.address
-    assert erc721_nft.token_name()
-    assert erc721_nft.symbol()
+    data_nft = ocean.create_data_nft("NFTToken1", "NFT1", publisher_wallet)
+    assert data_nft.address
+    assert data_nft.token_name()
+    assert data_nft.symbol()
 
     # Publish the datatoken
-    DATA_datatoken = erc721_nft.create_datatoken(
+    DATA_datatoken = data_nft.create_datatoken(
         "Datatoken 1",
         "DT1",
         from_wallet=publisher_wallet,
@@ -87,14 +87,14 @@ def c2d_flow_readme(
         publisher_wallet=publisher_wallet,
         encrypted_files=DATA_encrypted_files,
         services=[DATA_compute_service],
-        erc721_address=erc721_nft.address,
-        deployed_erc20_tokens=[DATA_datatoken],
+        erc721_address=data_nft.address,
+        deployed_datatokens=[DATA_datatoken],
     )
 
     assert DATA_asset.did, "create dataset with compute service unsuccessful"
 
     # Publish the algorithm NFT token
-    ALGO_nft_token = ocean.create_erc721_nft("NFTToken1", "NFT1", publisher_wallet)
+    ALGO_nft_token = ocean.create_data_nft("NFTToken1", "NFT1", publisher_wallet)
     assert ALGO_nft_token.address
 
     # Publish the datatoken
@@ -142,7 +142,7 @@ def c2d_flow_readme(
         publisher_wallet=publisher_wallet,
         encrypted_files=ALGO_encrypted_files,
         erc721_address=ALGO_nft_token.address,
-        deployed_erc20_tokens=[ALGO_datatoken],
+        deployed_datatokens=[ALGO_datatoken],
     )
 
     assert ALGO_asset.did, "create algorithm unsuccessful"
diff --git a/tests/stress/consume_flow_with_threads_test.py b/tests/stress/consume_flow_with_threads_test.py
index 9f246e8c5..40bff16c1 100644
--- a/tests/stress/consume_flow_with_threads_test.py
+++ b/tests/stress/consume_flow_with_threads_test.py
@@ -36,7 +36,7 @@ def consume_flow(ocean: Ocean, config: Config, tmpdir, files):
     }
     data_provider = DataServiceProvider
 
-    erc721_nft, erc20_token = deploy_erc721_erc20(
+    data_nft, datatoken = deploy_erc721_erc20(
         ocean.web3, config, publisher_wallet, publisher_wallet
     )
     encrypt_response = data_provider.encrypt(
@@ -48,7 +48,7 @@ def consume_flow(ocean: Ocean, config: Config, tmpdir, files):
         metadata=metadata,
         publisher_wallet=publisher_wallet,
         encrypted_files=encrypted_files,
-        erc721_address=erc721_nft.address,
+        erc721_address=data_nft.address,
         erc20_templates=[1],
         erc20_names=["Datatoken 1"],
         erc20_symbols=["DT1"],
@@ -63,7 +63,7 @@ def consume_flow(ocean: Ocean, config: Config, tmpdir, files):
     assert ddo, "The asset is not created."
     assert ddo.nft["name"] == "NFT"
     assert ddo.nft["symbol"] == "NFTSYMBOL"
-    assert ddo.nft["address"] == erc721_nft.address
+    assert ddo.nft["address"] == data_nft.address
     assert ddo.nft["owner"] == publisher_wallet.address
     assert ddo.datatokens[0]["name"] == "Datatoken 1"
     assert ddo.datatokens[0]["symbol"] == "DT1"
@@ -79,14 +79,14 @@ def consume_flow(ocean: Ocean, config: Config, tmpdir, files):
     assert response.status_code == 200
     assert response.json()["providerFee"]
 
-    erc20_token.mint(
+    datatoken.mint(
         account_address=consumer_wallet.address,
         value=ocean.to_wei(20),
         from_wallet=publisher_wallet,
     )
     # Start order for consumer
     provider_fees = response.json()["providerFee"]
-    tx_id = erc20_token.start_order(
+    tx_id = datatoken.start_order(
         consumer=consumer_wallet.address,
         service_index=ddo.get_index_of_service(service),
         provider_fee_address=provider_fees["providerFeeAddress"],
@@ -98,7 +98,7 @@ def consume_flow(ocean: Ocean, config: Config, tmpdir, files):
         valid_until=provider_fees["validUntil"],
         provider_data=provider_fees["providerData"],
         consume_market_order_fee_address=consumer_wallet.address,
-        consume_market_order_fee_token=erc20_token.address,
+        consume_market_order_fee_token=datatoken.address,
         consume_market_order_fee_amount=0,
         from_wallet=consumer_wallet,
     )
diff --git a/tests/stress/pool_creation_with_threads_test.py b/tests/stress/pool_creation_with_threads_test.py
index 98f19d7c9..b48572407 100644
--- a/tests/stress/pool_creation_with_threads_test.py
+++ b/tests/stress/pool_creation_with_threads_test.py
@@ -18,8 +18,8 @@
 
 def asset_displayed_on_sale(ocean: Ocean):
     publisher_wallet = generate_wallet()
-    erc721_nft = ocean.create_erc721_nft("NFTToken1", "NFT1", publisher_wallet)
-    token_address = erc721_nft.address
+    data_nft = ocean.create_data_nft("NFTToken1", "NFT1", publisher_wallet)
+    token_address = data_nft.address
     assert token_address
 
     # Specify metadata and services, using the Branin test dataset
@@ -48,7 +48,7 @@ def asset_displayed_on_sale(ocean: Ocean):
         metadata=metadata,
         publisher_wallet=publisher_wallet,
         encrypted_files=encrypted_files,
-        erc721_address=erc721_nft.address,
+        erc721_address=data_nft.address,
         erc20_templates=[1],
         erc20_names=["Datatoken 1"],
         erc20_symbols=["DT1"],
@@ -63,13 +63,13 @@ def asset_displayed_on_sale(ocean: Ocean):
     did = asset.did  # did contains the datatoken address
     assert did
 
-    erc20_token = ocean.get_datatoken(
+    datatoken = ocean.get_datatoken(
         get_first_service_by_type(asset, "access").datatoken
     )
     OCEAN_token = ocean.OCEAN_token
 
     bpool = ocean.create_pool(
-        erc20_token=erc20_token,
+        datatoken=datatoken,
         base_token=OCEAN_token,
         rate=ocean.to_wei(1),
         base_token_amount=ocean.to_wei(2000),
@@ -81,7 +81,7 @@ def asset_displayed_on_sale(ocean: Ocean):
     assert bpool.address
 
     prices = bpool.get_amount_in_exact_out(
-        OCEAN_token.address, erc20_token.address, ocean.to_wei(1), ocean.to_wei("0.01")
+        OCEAN_token.address, datatoken.address, ocean.to_wei(1), ocean.to_wei("0.01")
     )
     price_in_OCEAN = prices[0]
     formatted_price = pretty_ether_and_wei(price_in_OCEAN, "OCEAN")
diff --git a/tests/stress/publish_flow_with_threads_test.py b/tests/stress/publish_flow_with_threads_test.py
index 782789f02..61f1c02ae 100644
--- a/tests/stress/publish_flow_with_threads_test.py
+++ b/tests/stress/publish_flow_with_threads_test.py
@@ -17,17 +17,17 @@
 
 
 def _get_publishing_requirements(ocean: Ocean, wallet: Wallet, config: Config):
-    erc721_nft, erc20_token = deploy_erc721_erc20(ocean.web3, config, wallet, wallet)
+    data_nft, datatoken = deploy_erc721_erc20(ocean.web3, config, wallet, wallet)
     data_provider = DataServiceProvider
     _, metadata, encrypted_files = create_basics(config, ocean.web3, data_provider)
-    return erc721_nft, erc20_token, metadata, encrypted_files
+    return data_nft, datatoken, metadata, encrypted_files
 
 
 def publish_flow(ocean: Ocean, config: Config):
     publisher_wallet = generate_wallet()
     (
-        erc721_nft,
-        erc20_token,
+        data_nft,
+        datatoken,
         metadata,
         encrypted_files,
     ) = _get_publishing_requirements(ocean, publisher_wallet, config)
@@ -35,8 +35,8 @@ def publish_flow(ocean: Ocean, config: Config):
         metadata=metadata,
         publisher_wallet=publisher_wallet,
         encrypted_files=encrypted_files,
-        erc721_address=erc721_nft.address,
-        deployed_erc20_tokens=[erc20_token],
+        erc721_address=data_nft.address,
+        deployed_datatokens=[datatoken],
         encrypt_flag=True,
         compress_flag=True,
     )
@@ -44,11 +44,11 @@ def publish_flow(ocean: Ocean, config: Config):
     assert asset, "The asset is not created."
     assert asset.nft["name"] == "NFT"
     assert asset.nft["symbol"] == "NFTSYMBOL"
-    assert asset.nft["address"] == erc721_nft.address
+    assert asset.nft["address"] == data_nft.address
     assert asset.nft["owner"] == publisher_wallet.address
     assert asset.datatokens[0]["name"] == "ERC20DT1"
     assert asset.datatokens[0]["symbol"] == "ERC20DT1Symbol"
-    assert asset.datatokens[0]["address"] == erc20_token.address
+    assert asset.datatokens[0]["address"] == datatoken.address
 
 
 def concurrent_publish_flow(concurrent_flows: int, repetitions: int):
diff --git a/tests/test_readmes.py b/tests/test_readmes.py
index 8641db532..65bd16b20 100644
--- a/tests/test_readmes.py
+++ b/tests/test_readmes.py
@@ -34,7 +34,7 @@ def test_script_execution(script, monkeypatch):
     runs_with_prerequisites = [
         "c2d-flow",
         "dispenser-flow",
-        "erc20-enterprise",
+        "datatoken-enterprise",
         "fixed-rate-exchange-flow",
         "marketplace-flow",
         "key-value-flow",
@@ -57,15 +57,15 @@ def test_script_execution(script, monkeypatch):
                 "config",
                 "ocean",
                 "alice_wallet",
-                "erc721_nft",
-                "erc20_token",
+                "data_nft",
+                "datatoken",
             ]:
                 globs[key] = result[key]
 
     runs_with_publish = [
         "marketplace-flow",
         "consume-flow",
-        "erc20-enterprise",
+        "datatoken-enterprise",
     ]
     for item in runs_with_publish:
         if item in script.name: