dkg.js 6.5.3 → 6.5.4

package/constants.js

@@ -78,6 +78,12 @@ const BLOCKCHAINS = {
 
 const INCENTIVE_TYPE = {
     NEUROWEB: 'Neuroweb',
+    NEUROWEB_ERC20: 'NeurowebERC20',
+};
+
+const INCENTIVE_MULTIPLIER = {
+    Neuroweb: 10n ** 12n,
+    NeurowebERC20: 10n ** 18n,
 };
 
 const BLOCKCHAINS_RENAME_PAIRS = {
@@ -240,6 +246,8 @@ const BID_SUGGESTION_RANGE_ENUM = [
     ALL_BID_SUGGESTION,
 ];
 
+const NEUROWEB_BLOCKCHAIN_PREFIX = 'otp';
+
 module.exports = {
     MAX_FILE_SIZE,
     DID_PREFIX,
@@ -256,6 +264,7 @@ module.exports = {
     CONTENT_TYPES,
     GET_OUTPUT_FORMATS,
     INCENTIVE_TYPE,
+    INCENTIVE_MULTIPLIER,
     ASSET_STATES,
     STORE_TYPES,
     GRAPH_LOCATIONS,
@@ -273,4 +282,5 @@ module.exports = {
     HIGH_BID_SUGGESTION,
     ALL_BID_SUGGESTION,
     BID_SUGGESTION_RANGE_ENUM,
+    NEUROWEB_BLOCKCHAIN_PREFIX,
 };

package/managers/assertion-operations-manager.js

@@ -26,7 +26,7 @@ class AssertionOperationsManager {
      */
     async getPublicAssertionId(content) {
         const assertions = await formatGraph(content);
-        return calculateRoot(assertions.public);
+        return await calculateRoot(assertions.public);
     }
 
     /**

package/managers/asset-operations-manager.js

@@ -319,7 +319,7 @@ class AssetOperationsManager {
                     ? 0
                     : assertionMetadata.getAssertionSizeInBytes(privateAssertion)),
         );
-        const publicAssertionId = calculateRoot(publicAssertion);
+        const publicAssertionId = await calculateRoot(publicAssertion);
 
         const contentAssetStorageAddress = await this.blockchainService.getContractAddress(
             'ContentAssetStorage',
@@ -395,7 +395,7 @@ class AssetOperationsManager {
         if (privateAssertion?.length) {
             assertions.push({
                 ...resolvedUAL,
-                assertionId: calculateRoot(privateAssertion),
+                assertionId: await calculateRoot(privateAssertion),
                 assertion: privateAssertion,
                 storeType: STORE_TYPES.TRIPLE,
             });
@@ -613,7 +613,7 @@ class AssetOperationsManager {
 
         const publicAssertion = getPublicOperationResult.data.assertion;
 
-        if (validate === true && calculateRoot(publicAssertion) !== publicAssertionId) {
+        if (validate === true && (await calculateRoot(publicAssertion)) !== publicAssertionId) {
             getPublicOperationResult.data = {
                 errorType: 'DKG_CLIENT_ERROR',
                 errorMessage: "Calculated root hashes don't match!",
@@ -713,7 +713,7 @@ class AssetOperationsManager {
                 if (
                     privateAssertion.length &&
                     validate === true &&
-                    calculateRoot(privateAssertion) !== privateAssertionId
+                    (await calculateRoot(privateAssertion)) !== privateAssertionId
                 ) {
                     queryPrivateOperationResult.data = {
                         errorType: 'DKG_CLIENT_ERROR',
@@ -809,7 +809,7 @@ class AssetOperationsManager {
                     ? 0
                     : assertionMetadata.getAssertionSizeInBytes(privateAssertion)),
         );
-        const publicAssertionId = calculateRoot(publicAssertion);
+        const publicAssertionId = await calculateRoot(publicAssertion);
 
         const contentAssetStorageAddress = await this.blockchainService.getContractAddress(
             'ContentAssetStorage',
@@ -861,7 +861,7 @@ class AssetOperationsManager {
         if (privateAssertion?.length) {
             assertions.push({
                 ...resolvedUAL,
-                assertionId: calculateRoot(privateAssertion),
+                assertionId: await calculateRoot(privateAssertion),
                 assertion: privateAssertion,
                 storeType: STORE_TYPES.PENDING,
             });

package/managers/paranet-operations-manager.js

@@ -1,8 +1,6 @@
 const { ethers } = require('ethers');
 const { resolveUAL } = require('../services/utilities.js');
-const {
-    INCENTIVE_TYPE,
-} = require('../constants.js');
+const { INCENTIVE_TYPE, INCENTIVE_MULTIPLIER } = require('../constants.js');
 
 class ParanetOperationsManager {
     constructor(services) {
@@ -27,11 +25,8 @@ class ParanetOperationsManager {
      * });
      */
     async create(UAL, options = {}) {
-        const {
-            blockchain,
-            paranetName,
-            paranetDescription,
-        } = this.inputService.getParanetCreateArguments(options);
+        const { blockchain, paranetName, paranetDescription } =
+            this.inputService.getParanetCreateArguments(options);
 
         this.validationService.validateParanetCreate(
             UAL,
@@ -42,18 +37,19 @@ class ParanetOperationsManager {
 
         const { contract, tokenId } = resolveUAL(UAL);
 
-       const receipt = await this.blockchainService.registerParanet({
+        const receipt = await this.blockchainService.registerParanet(
+            {
                 contract,
                 tokenId,
                 paranetName,
                 paranetDescription,
             },
-            blockchain
+            blockchain,
         );
 
         return {
             paranetUAL: UAL,
-            operation: receipt
+            operation: receipt,
         };
     }
 
@@ -89,29 +85,37 @@ class ParanetOperationsManager {
             operatorRewardPercentage,
             incentivizationProposalVotersRewardPercentage,
         );
-        if(incentiveType === INCENTIVE_TYPE.NEUROWEB) {
-            const {contract, tokenId} = resolveUAL(paranetUAL);
+        if ([INCENTIVE_TYPE.NEUROWEB, INCENTIVE_TYPE.NEUROWEB_ERC20].includes(incentiveType)) {
+            const { contract, tokenId } = resolveUAL(paranetUAL);
+
+            const isNativeReward = incentiveType === INCENTIVE_TYPE.NEUROWEB;
+
+            const emissionMultiplier =
+                BigInt(tracToNeuroEmissionMultiplier) * INCENTIVE_MULTIPLIER[incentiveType];
 
-            const receipt = await this.blockchainService.deployNeuroIncentivesPool({
+            const receipt = await this.blockchainService.deployNeuroIncentivesPool(
+                {
+                    isNativeReward,
                     contract,
                     tokenId,
-                    tracToNeuroEmissionMultiplier,
+                    tracToNeuroEmissionMultiplier: emissionMultiplier,
                     operatorRewardPercentage,
                     incentivizationProposalVotersRewardPercentage,
                 },
-                blockchain
+                blockchain,
             );
 
             const paranetId = ethers.keccak256(
                 ethers.solidityPacked(['address', 'uint256'], [contract, tokenId]),
             );
 
-            const neuroIncentivesPoolAddress = await this.blockchainService.getNeuroIncentivesPoolAddress(paranetId, blockchain);
+            const neuroIncentivesPoolAddress =
+                await this.blockchainService.getNeuroIncentivesPoolAddress(paranetId, blockchain);
 
             return {
                 paranetUAL,
                 incentivesPoolContractAddress: neuroIncentivesPoolAddress,
-                operation: receipt
+                operation: receipt,
             };
         }
 
@@ -148,19 +152,20 @@ class ParanetOperationsManager {
 
         const { contract, tokenId } = resolveUAL(UAL);
 
-        const receipt = await this.blockchainService.registerParanetService({
+        const receipt = await this.blockchainService.registerParanetService(
+            {
                 contract,
                 tokenId,
                 paranetServiceName,
                 paranetServiceDescription,
                 paranetServiceAddresses,
             },
-            blockchain
+            blockchain,
         );
 
         return {
             serviceUAL: UAL,
-            operation: receipt
+            operation: receipt,
         };
     }
 
@@ -184,23 +189,24 @@ class ParanetOperationsManager {
         const { contract, tokenId } = resolveUAL(paranetUAL);
 
         const processedServicesArray = [];
-        for(const serviceUAL of paranetServiceUALs) {
-            const { contract: serviceContract, tokenId: serviceTokenId } = resolveUAL(serviceUAL)
-            processedServicesArray.push([ serviceContract, serviceTokenId ]);
+        for (const serviceUAL of paranetServiceUALs) {
+            const { contract: serviceContract, tokenId: serviceTokenId } = resolveUAL(serviceUAL);
+            processedServicesArray.push([serviceContract, serviceTokenId]);
         }
 
-        const receipt = await this.blockchainService.addParanetServices({
+        const receipt = await this.blockchainService.addParanetServices(
+            {
                 contract,
                 tokenId,
-                processedServicesArray
+                processedServicesArray,
             },
-            blockchain
+            blockchain,
         );
 
         return {
             paranetUAL,
             paranetServiceUALs,
-            operation: receipt
+            operation: receipt,
         };
     }
 
@@ -215,17 +221,17 @@ class ParanetOperationsManager {
      */
     async claimMinerReward(paranetUAL, options = {}) {
         const blockchain = this.inputService.getBlockchain(options);
-        this.validationService.validateParanetRewardArguments(
-            paranetUAL,
-            blockchain,
-        );
+        this.validationService.validateParanetRewardArguments(paranetUAL, blockchain);
 
         const { contract, tokenId } = resolveUAL(paranetUAL);
         const paranetId = ethers.keccak256(
             ethers.solidityPacked(['address', 'uint256'], [contract, tokenId]),
         );
 
-        const receipt = await this.blockchainService.claimKnowledgeMinerReward(paranetId, blockchain);
+        const receipt = await this.blockchainService.claimKnowledgeMinerReward(
+            paranetId,
+            blockchain,
+        );
 
         return {
             operation: receipt,
@@ -245,10 +251,7 @@ class ParanetOperationsManager {
      */
     async claimVoterReward(paranetUAL, options = {}) {
         const blockchain = this.inputService.getBlockchain(options);
-        this.validationService.validateParanetRewardArguments(
-            paranetUAL,
-            blockchain,
-        );
+        this.validationService.validateParanetRewardArguments(paranetUAL, blockchain);
 
         const { contract, tokenId } = resolveUAL(paranetUAL);
         const paranetId = ethers.keccak256(
@@ -275,10 +278,7 @@ class ParanetOperationsManager {
      */
     async claimOperatorReward(paranetUAL, options = {}) {
         const blockchain = this.inputService.getBlockchain(options);
-        this.validationService.validateParanetRewardArguments(
-            paranetUAL,
-            blockchain,
-        );
+        this.validationService.validateParanetRewardArguments(paranetUAL, blockchain);
 
         const { contract, tokenId } = resolveUAL(paranetUAL);
         const paranetId = ethers.keccak256(
@@ -304,17 +304,17 @@ class ParanetOperationsManager {
      */
     async getClaimableMinerReward(paranetUAL, options = {}) {
         const blockchain = this.inputService.getBlockchain(options);
-        this.validationService.validateParanetRewardArguments(
-            paranetUAL,
-            blockchain,
-        );
+        this.validationService.validateParanetRewardArguments(paranetUAL, blockchain);
 
         const { contract, tokenId } = resolveUAL(paranetUAL);
         const paranetId = ethers.keccak256(
             ethers.solidityPacked(['address', 'uint256'], [contract, tokenId]),
         );
 
-        const claimableValue = await this.blockchainService.getClaimableKnowledgeMinerReward(paranetId, blockchain);
+        const claimableValue = await this.blockchainService.getClaimableKnowledgeMinerReward(
+            paranetId,
+            blockchain,
+        );
 
         return claimableValue;
     }
@@ -330,17 +330,17 @@ class ParanetOperationsManager {
      */
     async getClaimableAllMinersReward(paranetUAL, options = {}) {
         const blockchain = this.inputService.getBlockchain(options);
-        this.validationService.validateParanetRewardArguments(
-            paranetUAL,
-            blockchain,
-        );
+        this.validationService.validateParanetRewardArguments(paranetUAL, blockchain);
 
         const { contract, tokenId } = resolveUAL(paranetUAL);
         const paranetId = ethers.keccak256(
             ethers.solidityPacked(['address', 'uint256'], [contract, tokenId]),
         );
 
-        const claimableValue = await this.blockchainService.getClaimableAllKnowledgeMinersReward(paranetId, blockchain);
+        const claimableValue = await this.blockchainService.getClaimableAllKnowledgeMinersReward(
+            paranetId,
+            blockchain,
+        );
 
         return claimableValue;
     }
@@ -356,17 +356,17 @@ class ParanetOperationsManager {
      */
     async getClaimableVoterReward(paranetUAL, options = {}) {
         const blockchain = this.inputService.getBlockchain(options);
-        this.validationService.validateParanetRewardArguments(
-            paranetUAL,
-            blockchain,
-        );
+        this.validationService.validateParanetRewardArguments(paranetUAL, blockchain);
 
-        const {contract, tokenId} = resolveUAL(paranetUAL);
+        const { contract, tokenId } = resolveUAL(paranetUAL);
         const paranetId = ethers.keccak256(
             ethers.solidityPacked(['address', 'uint256'], [contract, tokenId]),
         );
 
-        const claimableValue = await this.blockchainService.getClaimableVoterReward(paranetId, blockchain);
+        const claimableValue = await this.blockchainService.getClaimableVoterReward(
+            paranetId,
+            blockchain,
+        );
 
         return claimableValue;
     }
@@ -382,17 +382,17 @@ class ParanetOperationsManager {
      */
     async getClaimableAllVotersReward(paranetUAL, options = {}) {
         const blockchain = this.inputService.getBlockchain(options);
-        this.validationService.validateParanetRewardArguments(
-            paranetUAL,
-            blockchain,
-        );
+        this.validationService.validateParanetRewardArguments(paranetUAL, blockchain);
 
-        const {contract, tokenId} = resolveUAL(paranetUAL);
+        const { contract, tokenId } = resolveUAL(paranetUAL);
         const paranetId = ethers.keccak256(
             ethers.solidityPacked(['address', 'uint256'], [contract, tokenId]),
         );
 
-        const claimableValue = await this.blockchainService.getClaimableAllVotersReward(paranetId, blockchain);
+        const claimableValue = await this.blockchainService.getClaimableAllVotersReward(
+            paranetId,
+            blockchain,
+        );
 
         return claimableValue;
     }
@@ -408,17 +408,17 @@ class ParanetOperationsManager {
      */
     async getClaimableOperatorReward(paranetUAL, options = {}) {
         const blockchain = this.inputService.getBlockchain(options);
-        this.validationService.validateParanetRewardArguments(
-            paranetUAL,
-            blockchain,
-        );
+        this.validationService.validateParanetRewardArguments(paranetUAL, blockchain);
 
-        const {contract, tokenId} = resolveUAL(paranetUAL);
+        const { contract, tokenId } = resolveUAL(paranetUAL);
         const paranetId = ethers.keccak256(
             ethers.solidityPacked(['address', 'uint256'], [contract, tokenId]),
         );
 
-        const claimableValue = await this.blockchainService.getClaimableOperatorReward(paranetId, blockchain);
+        const claimableValue = await this.blockchainService.getClaimableOperatorReward(
+            paranetId,
+            blockchain,
+        );
 
         return claimableValue;
     }
@@ -434,24 +434,28 @@ class ParanetOperationsManager {
      */
     async updateClaimableRewards(paranetUAL, options = {}) {
         const blockchain = this.inputService.getBlockchain(options);
-        this.validationService.validateParanetRewardArguments(
-            paranetUAL,
-            blockchain,
-        );
+        this.validationService.validateParanetRewardArguments(paranetUAL, blockchain);
 
         const { contract, tokenId } = resolveUAL(paranetUAL);
         const paranetId = ethers.keccak256(
             ethers.solidityPacked(['address', 'uint256'], [contract, tokenId]),
         );
 
-        const updatingKnowledgeAssetStates = await this.blockchainService.getUpdatingKnowledgeAssetStates({ miner: blockchain.publicKey, paranetId }, blockchain);
-        if(updatingKnowledgeAssetStates.length > 0) {
-            const receipt = await this.blockchainService.updateClaimableRewards({
-                contract,
-                tokenId,
-                start: 0,
-                end: updatingKnowledgeAssetStates.length
-            }, blockchain);
+        const updatingKnowledgeAssetStates =
+            await this.blockchainService.getUpdatingKnowledgeAssetStates(
+                { miner: blockchain.publicKey, paranetId },
+                blockchain,
+            );
+        if (updatingKnowledgeAssetStates.length > 0) {
+            const receipt = await this.blockchainService.updateClaimableRewards(
+                {
+                    contract,
+                    tokenId,
+                    start: 0,
+                    end: updatingKnowledgeAssetStates.length,
+                },
+                blockchain,
+            );
 
             return {
                 operation: receipt,
@@ -461,7 +465,7 @@ class ParanetOperationsManager {
         }
 
         return {
-            status: 'No updated knowledge assets.'
+            status: 'No updated knowledge assets.',
         };
     }
 
@@ -476,7 +480,7 @@ class ParanetOperationsManager {
      */
     async isKnowledgeMiner(paranetUAL, options = {}) {
         // eslint-disable-next-line prefer-const
-        let { blockchain, roleAddress }  = this.inputService.getParanetRoleCheckArguments(options);
+        let { blockchain, roleAddress } = this.inputService.getParanetRoleCheckArguments(options);
         if (roleAddress == null) {
             roleAddress = blockchain.publicKey;
         }
@@ -486,12 +490,16 @@ class ParanetOperationsManager {
             blockchain,
         );
 
-        const {contract, tokenId} = resolveUAL(paranetUAL);
+        const { contract, tokenId } = resolveUAL(paranetUAL);
         const paranetId = ethers.keccak256(
             ethers.solidityPacked(['address', 'uint256'], [contract, tokenId]),
         );
 
-        const isParanetKnowledgeMiner = await this.blockchainService.isParanetKnowledgeMiner(roleAddress ,paranetId, blockchain);
+        const isParanetKnowledgeMiner = await this.blockchainService.isParanetKnowledgeMiner(
+            roleAddress,
+            paranetId,
+            blockchain,
+        );
 
         return isParanetKnowledgeMiner;
     }
@@ -507,7 +515,7 @@ class ParanetOperationsManager {
      */
     async isParanetOperator(paranetUAL, options = {}) {
         // eslint-disable-next-line prefer-const
-        let { blockchain, roleAddress }  = this.inputService.getParanetRoleCheckArguments(options);
+        let { blockchain, roleAddress } = this.inputService.getParanetRoleCheckArguments(options);
         if (roleAddress == null) {
             roleAddress = blockchain.publicKey;
         }
@@ -517,12 +525,16 @@ class ParanetOperationsManager {
             blockchain,
         );
 
-        const {contract, tokenId} = resolveUAL(paranetUAL);
+        const { contract, tokenId } = resolveUAL(paranetUAL);
         const paranetId = ethers.keccak256(
             ethers.solidityPacked(['address', 'uint256'], [contract, tokenId]),
         );
 
-        const isParanetOperator = await this.blockchainService.isParanetOperator(roleAddress ,paranetId, blockchain);
+        const isParanetOperator = await this.blockchainService.isParanetOperator(
+            roleAddress,
+            paranetId,
+            blockchain,
+        );
 
         return isParanetOperator;
     }
@@ -538,7 +550,7 @@ class ParanetOperationsManager {
      */
     async isProposalVoter(paranetUAL, options = {}) {
         // eslint-disable-next-line prefer-const
-        let { blockchain, roleAddress }  = this.inputService.getParanetRoleCheckArguments(options);
+        let { blockchain, roleAddress } = this.inputService.getParanetRoleCheckArguments(options);
         if (roleAddress == null) {
             roleAddress = blockchain.publicKey;
         }
@@ -548,15 +560,18 @@ class ParanetOperationsManager {
             blockchain,
         );
 
-        const {contract, tokenId} = resolveUAL(paranetUAL);
+        const { contract, tokenId } = resolveUAL(paranetUAL);
         const paranetId = ethers.keccak256(
             ethers.solidityPacked(['address', 'uint256'], [contract, tokenId]),
         );
 
-        const isProposalVoter = await this.blockchainService.isParanetProposalVoter(roleAddress ,paranetId, blockchain);
+        const isProposalVoter = await this.blockchainService.isParanetProposalVoter(
+            roleAddress,
+            paranetId,
+            blockchain,
+        );
 
         return isProposalVoter;
     }
-
 }
 module.exports = ParanetOperationsManager;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dkg.js",
-    "version": "6.5.3",
+    "version": "6.5.4",
     "description": "Javascript library for interaction with the OriginTrail Decentralized Knowledge Graph",
     "main": "index.js",
     "scripts": {
@@ -29,9 +29,9 @@
     },
     "homepage": "https://github.com/OriginTrail/dkg.js/tree/main#readme",
     "dependencies": {
-        "assertion-tools": "^2.1.0",
+        "assertion-tools": "^2.2.1",
         "axios": "^0.27.2",
-        "dkg-evm-module": "^4.3.3",
+        "dkg-evm-module": "^4.4.0",
         "ethers": "^6.1.0",
         "jsonld": "^8.1.0",
         "web3": "^1.7.3"

package/services/blockchain-service/blockchain-service-base.js

@@ -15,7 +15,11 @@ const ParanetsRegistryAbi = require('dkg-evm-module/abi/ParanetsRegistry.json');
 const ParanetIncentivesPoolFactoryAbi = require('dkg-evm-module/abi/ParanetIncentivesPoolFactory.json');
 const ParanetNeuroIncentivesPoolAbi = require('dkg-evm-module/abi/ParanetNeuroIncentivesPool.json');
 const ParanetKnowledgeMinersRegistryAbi = require('dkg-evm-module/abi/ParanetKnowledgeMinersRegistry.json');
-const { OPERATIONS_STEP_STATUS, DEFAULT_GAS_PRICE } = require('../../constants');
+const {
+    OPERATIONS_STEP_STATUS,
+    DEFAULT_GAS_PRICE,
+    NEUROWEB_BLOCKCHAIN_PREFIX,
+} = require('../../constants');
 const emptyHooks = require('../../util/empty-hooks.js');
 const { sleepForMilliseconds } = require('../utilities.js');
 
@@ -74,8 +78,9 @@ class BlockchainServiceBase {
 
             const web3Instance = await this.getWeb3Instance(blockchain);
             this[blockchain.name].contracts[blockchain.hubContract].Hub =
-                    new web3Instance.eth.Contract(this.abis.Hub, blockchain.hubContract, { from: blockchain.publicKey });
-    
+                new web3Instance.eth.Contract(this.abis.Hub, blockchain.hubContract, {
+                    from: blockchain.publicKey,
+                });
         }
     }
 
@@ -167,7 +172,7 @@ class BlockchainServiceBase {
         let gasLimit = Number(
             await contractInstance.methods[functionName](...args).estimateGas({
                 from: publicKey,
-            })
+            }),
         );
         gasLimit = Math.round(gasLimit * blockchain.gasLimitMultiplier);
 
@@ -188,7 +193,9 @@ class BlockchainServiceBase {
 
                 // Search for pending tx in the pending block
                 const pendingTx = Object.values(pendingBlock.transactions).find(
-                    tx => tx.from.toLowerCase() === publicKey.toLowerCase() && tx.nonce === confirmedNonce
+                    (tx) =>
+                        tx.from.toLowerCase() === publicKey.toLowerCase() &&
+                        tx.nonce === confirmedNonce,
                 );
 
                 if (pendingTx) {
@@ -197,7 +204,9 @@ class BlockchainServiceBase {
                 } else {
                     // If not found, use default/network gas price increased by 20%
                     // Theoretically this should never happen
-                    gasPrice = Math.round((blockchain.gasPrice || (await this.getNetworkGasPrice(blockchain))) * 1.2);
+                    gasPrice = Math.round(
+                        (blockchain.gasPrice || (await this.getNetworkGasPrice(blockchain))) * 1.2,
+                    );
                 }
             }
         } else {
@@ -231,31 +240,50 @@ class BlockchainServiceBase {
         let reminingTime = 0;
         let receipt = initialReceipt;
         let finalized = false;
-      
+
         try {
-            while (!finalized && (Date.now() - startTime + reminingTime) < blockchain.transactionFinalityMaxWaitTime) {
+            while (
+                !finalized &&
+                Date.now() - startTime + reminingTime < blockchain.transactionFinalityMaxWaitTime
+            ) {
                 try {
                     // Check if the block containing the transaction is finalized
-                    const finalizedBlockNumber = (await web3Instance.eth.getBlock('finalized')).number;
+                    const finalizedBlockNumber = (await web3Instance.eth.getBlock('finalized'))
+                        .number;
                     if (finalizedBlockNumber >= receipt.blockNumber) {
                         finalized = true;
                         break;
                     } else {
-                        let currentReceipt = await web3Instance.eth.getTransactionReceipt(receipt.transactionHash);
+                        let currentReceipt = await web3Instance.eth.getTransactionReceipt(
+                            receipt.transactionHash,
+                        );
                         if (currentReceipt && currentReceipt.blockNumber === receipt.blockNumber) {
                             // Transaction is still in the same block, wait and check again
-                        } else if (currentReceipt && currentReceipt.blockNumber !== receipt.blockNumber) {
+                        } else if (
+                            currentReceipt &&
+                            currentReceipt.blockNumber !== receipt.blockNumber
+                        ) {
                             // Transaction has been re-included in a different block
                             receipt = currentReceipt; // Update the receipt with the new block information
                         } else {
                             // Transaction is no longer mined, wait for it to be mined again
                             const reminingStartTime = Date.now();
-                            while (!currentReceipt && (Date.now() - reminingStartTime) < blockchain.transactionReminingMaxWaitTime) {
-                                await sleepForMilliseconds(blockchain.transactionReminingPollingInterval);
-                                currentReceipt = await web3Instance.eth.getTransactionReceipt(receipt.transactionHash);
+                            while (
+                                !currentReceipt &&
+                                Date.now() - reminingStartTime <
+                                    blockchain.transactionReminingMaxWaitTime
+                            ) {
+                                await sleepForMilliseconds(
+                                    blockchain.transactionReminingPollingInterval,
+                                );
+                                currentReceipt = await web3Instance.eth.getTransactionReceipt(
+                                    receipt.transactionHash,
+                                );
                             }
                             if (!currentReceipt) {
-                                throw new Error('Transaction was not re-mined within the expected time frame.');
+                                throw new Error(
+                                    'Transaction was not re-mined within the expected time frame.',
+                                );
                             }
                             reminingTime = Date.now() - reminingStartTime;
                             receipt = currentReceipt; // Update the receipt
@@ -267,11 +295,11 @@ class BlockchainServiceBase {
                     throw new Error(`Error during finality polling: ${error.message}`);
                 }
             }
-      
+
             if (!finalized) {
                 throw new Error('Transaction was not finalized within the expected time frame.');
             }
-      
+
             return receipt;
         } catch (error) {
             throw new Error(`Failed to wait for transaction finalization: ${error.message}`);
@@ -318,7 +346,12 @@ class BlockchainServiceBase {
         return this[blockchain.name].contracts[blockchain.hubContract][contractName];
     }
 
-    async increaseServiceAgreementV1Allowance(sender, serviceAgreementV1Address, tokenAmount, blockchain) {
+    async increaseServiceAgreementV1Allowance(
+        sender,
+        serviceAgreementV1Address,
+        tokenAmount,
+        blockchain,
+    ) {
         const allowance = await this.callContractFunction(
             'Token',
             'allowance',
@@ -345,12 +378,18 @@ class BlockchainServiceBase {
         return {
             allowanceIncreased: false,
             allowanceGap,
-        }
+        };
     }
 
     // Knowledge assets operations
 
-    async createAsset(requestData, paranetKaContract, paranetTokenId, blockchain, stepHooks = emptyHooks) {
+    async createAsset(
+        requestData,
+        paranetKaContract,
+        paranetTokenId,
+        blockchain,
+        stepHooks = emptyHooks,
+    ) {
         const sender = await this.getPublicKey(blockchain);
         let serviceAgreementV1Address;
         let allowanceIncreased = false;
@@ -366,7 +405,7 @@ class BlockchainServiceBase {
                 sender,
                 serviceAgreementV1Address,
                 requestData.tokenAmount,
-                blockchain
+                blockchain,
             ));
 
             stepHooks.afterHook({
@@ -374,7 +413,7 @@ class BlockchainServiceBase {
             });
 
             let receipt;
-            if(paranetKaContract == null && paranetTokenId == null) {
+            if (paranetKaContract == null && paranetTokenId == null) {
                 receipt = await this.executeContractFunction(
                     'ContentAsset',
                     'createAsset',
@@ -437,7 +476,7 @@ class BlockchainServiceBase {
                 sender,
                 serviceAgreementV1Address,
                 tokenAmount,
-                blockchain
+                blockchain,
             ));
 
             return this.executeContractFunction(
@@ -526,7 +565,7 @@ class BlockchainServiceBase {
                 sender,
                 serviceAgreementV1Address,
                 tokenAmount,
-                blockchain
+                blockchain,
             ));
 
             return this.executeContractFunction(
@@ -564,7 +603,7 @@ class BlockchainServiceBase {
                 sender,
                 serviceAgreementV1Address,
                 tokenAmount,
-                blockchain
+                blockchain,
             ));
 
             return this.executeContractFunction(
@@ -602,7 +641,7 @@ class BlockchainServiceBase {
                 sender,
                 serviceAgreementV1Address,
                 tokenAmount,
-                blockchain
+                blockchain,
             ));
 
             return this.executeContractFunction(
@@ -753,33 +792,46 @@ class BlockchainServiceBase {
         );
     }
 
-    async getNeuroIncentivesPoolAddress(paranetId,blockchain) {
+    async getNeuroIncentivesPoolAddress(paranetId, blockchain) {
         return this.getIncentivesPoolAddress(
             {
                 paranetId,
-                incentivesPoolType: 'Neuroweb',
+                incentivesPoolType: blockchain.name.includes(NEUROWEB_BLOCKCHAIN_PREFIX)
+                    ? 'Neuroweb'
+                    : 'NeurowebERC20',
             },
-            blockchain
-        )
+            blockchain,
+        );
     }
 
-    async setIncentivesPool(contractAddress, blockchain){
+    async setIncentivesPool(contractAddress, blockchain) {
         await this.ensureBlockchainInfo(blockchain);
 
-        if (this[blockchain.name].contractAddresses[blockchain.hubContract]['ParanetNeuroIncentivesPool'] !== contractAddress) {
-            this[blockchain.name].contractAddresses[blockchain.hubContract]['ParanetNeuroIncentivesPool'] = contractAddress;
+        if (
+            this[blockchain.name].contractAddresses[blockchain.hubContract][
+                'ParanetNeuroIncentivesPool'
+            ] !== contractAddress
+        ) {
+            this[blockchain.name].contractAddresses[blockchain.hubContract][
+                'ParanetNeuroIncentivesPool'
+            ] = contractAddress;
             const web3Instance = await this.getWeb3Instance(blockchain);
             this[blockchain.name].contracts[blockchain.hubContract]['ParanetNeuroIncentivesPool'] =
                 await new web3Instance.eth.Contract(
                     this.abis['ParanetNeuroIncentivesPool'],
-                    this[blockchain.name].contractAddresses[blockchain.hubContract]['ParanetNeuroIncentivesPool'],
+                    this[blockchain.name].contractAddresses[blockchain.hubContract][
+                        'ParanetNeuroIncentivesPool'
+                    ],
                     { from: blockchain.publicKey },
                 );
         }
     }
 
     async claimKnowledgeMinerReward(paranetId, blockchain) {
-        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(paranetId, blockchain);
+        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(
+            paranetId,
+            blockchain,
+        );
 
         await this.setIncentivesPool(neuroIncentivesPoolAddress, blockchain);
 
@@ -792,7 +844,10 @@ class BlockchainServiceBase {
     }
 
     async claimVoterReward(paranetId, blockchain) {
-        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(paranetId, blockchain);
+        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(
+            paranetId,
+            blockchain,
+        );
 
         await this.setIncentivesPool(neuroIncentivesPoolAddress, blockchain);
 
@@ -805,7 +860,10 @@ class BlockchainServiceBase {
     }
 
     async claimOperatorReward(paranetId, blockchain) {
-        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(paranetId, blockchain);
+        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(
+            paranetId,
+            blockchain,
+        );
 
         await this.setIncentivesPool(neuroIncentivesPoolAddress, blockchain);
 
@@ -818,7 +876,10 @@ class BlockchainServiceBase {
     }
 
     async getClaimableKnowledgeMinerReward(paranetId, blockchain) {
-        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(paranetId, blockchain);
+        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(
+            paranetId,
+            blockchain,
+        );
 
         await this.setIncentivesPool(neuroIncentivesPoolAddress, blockchain);
 
@@ -831,7 +892,10 @@ class BlockchainServiceBase {
     }
 
     async getClaimableAllKnowledgeMinersReward(paranetId, blockchain) {
-        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(paranetId, blockchain);
+        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(
+            paranetId,
+            blockchain,
+        );
 
         await this.setIncentivesPool(neuroIncentivesPoolAddress, blockchain);
 
@@ -844,7 +908,10 @@ class BlockchainServiceBase {
     }
 
     async getClaimableVoterReward(paranetId, blockchain) {
-        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(paranetId, blockchain);
+        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(
+            paranetId,
+            blockchain,
+        );
 
         await this.setIncentivesPool(neuroIncentivesPoolAddress, blockchain);
 
@@ -857,7 +924,10 @@ class BlockchainServiceBase {
     }
 
     async getClaimableAllVotersReward(paranetId, blockchain) {
-        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(paranetId, blockchain);
+        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(
+            paranetId,
+            blockchain,
+        );
 
         await this.setIncentivesPool(neuroIncentivesPoolAddress, blockchain);
 
@@ -870,7 +940,10 @@ class BlockchainServiceBase {
     }
 
     async getClaimableOperatorReward(paranetId, blockchain) {
-        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(paranetId, blockchain);
+        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(
+            paranetId,
+            blockchain,
+        );
 
         await this.setIncentivesPool(neuroIncentivesPoolAddress, blockchain);
 
@@ -882,8 +955,11 @@ class BlockchainServiceBase {
         );
     }
 
-    async isParanetKnowledgeMiner(address ,paranetId, blockchain) {
-        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(paranetId, blockchain);
+    async isParanetKnowledgeMiner(address, paranetId, blockchain) {
+        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(
+            paranetId,
+            blockchain,
+        );
 
         await this.setIncentivesPool(neuroIncentivesPoolAddress, blockchain);
 
@@ -895,8 +971,11 @@ class BlockchainServiceBase {
         );
     }
 
-    async isParanetOperator(address ,paranetId, blockchain) {
-        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(paranetId, blockchain);
+    async isParanetOperator(address, paranetId, blockchain) {
+        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(
+            paranetId,
+            blockchain,
+        );
 
         await this.setIncentivesPool(neuroIncentivesPoolAddress, blockchain);
 
@@ -908,8 +987,11 @@ class BlockchainServiceBase {
         );
     }
 
-    async isParanetProposalVoter(address ,paranetId, blockchain) {
-        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(paranetId, blockchain);
+    async isParanetProposalVoter(address, paranetId, blockchain) {
+        const neuroIncentivesPoolAddress = await this.getNeuroIncentivesPoolAddress(
+            paranetId,
+            blockchain,
+        );
 
         await this.setIncentivesPool(neuroIncentivesPoolAddress, blockchain);
 

package/services/node-api-service/implementations/http-service.js

@@ -5,13 +5,25 @@ const { sleepForMilliseconds } = require('../../utilities.js');
 class HttpService {
     constructor(config = {}) {
         this.config = config;
+
+        if (
+            !(
+                config.nodeApiVersion === '/' ||
+                config.nodeApiVersion === '/latest' ||
+                /^\/v\d+$/.test(config.nodeApiVersion)
+            )
+        ) {
+            throw Error(`Version must be '/latest', '/' or in '/v{digits}' format.`);
+        }
+
+        this.apiVersion = config.nodeApiVersion ?? '/v0';
     }
 
     async info(endpoint, port, authToken) {
         try {
             const response = await axios({
                 method: 'get',
-                url: `${endpoint}:${port}/info`,
+                url: `${this.getBaseUrl(endpoint, port)}/info`,
                 headers: this.prepareRequestConfig(authToken),
             });
 
@@ -47,7 +59,7 @@ class HttpService {
             }
             const response = await axios({
                 method: 'get',
-                url: `${endpoint}:${port}/bid-suggestion`,
+                url: `${this.getBaseUrl(endpoint, port)}/bid-suggestion`,
                 params,
                 headers: this.prepareRequestConfig(authToken),
             });
@@ -62,7 +74,7 @@ class HttpService {
         try {
             const response = await axios({
                 method: 'post',
-                url: `${endpoint}:${port}/local-store`,
+                url: `${this.getBaseUrl(endpoint, port)}/local-store`,
                 data: assertions,
                 headers: this.prepareRequestConfig(authToken),
             });
@@ -87,7 +99,7 @@ class HttpService {
         try {
             const response = await axios({
                 method: 'post',
-                url: `${endpoint}:${port}/publish`,
+                url: `${this.getBaseUrl(endpoint, port)}/publish`,
                 data: {
                     assertionId,
                     assertion,
@@ -109,7 +121,7 @@ class HttpService {
         try {
             const response = await axios({
                 method: 'post',
-                url: `${endpoint}:${port}/get`,
+                url: `${this.getBaseUrl(endpoint, port)}/get`,
                 data: {
                     id: UAL,
                     state,
@@ -138,7 +150,7 @@ class HttpService {
         try {
             const response = await axios({
                 method: 'post',
-                url: `${endpoint}:${port}/update`,
+                url: `${this.getBaseUrl(endpoint, port)}/update`,
                 data: {
                     assertionId,
                     assertion,
@@ -160,7 +172,7 @@ class HttpService {
         try {
             const response = await axios({
                 method: 'post',
-                url: `${endpoint}:${port}/query`,
+                url: `${this.getBaseUrl(endpoint, port)}/query`,
                 data: { query, type, repository },
                 headers: this.prepareRequestConfig(authToken),
             });
@@ -187,7 +199,7 @@ class HttpService {
 
         const axios_config = {
             method: 'get',
-            url: `${endpoint}:${port}/${operation}/${operationId}`,
+            url: `${this.getBaseUrl(endpoint, port)}/${operation}/${operationId}`,
             headers: this.prepareRequestConfig(authToken),
         };
         do {
@@ -220,5 +232,9 @@ class HttpService {
 
         return {};
     }
+
+    getBaseUrl(endpoint, port) {
+        return `${endpoint}:${port}${this.apiVersion}`;
+    }
 }
 module.exports = HttpService;