dkg.js 6.0.0 → 6.0.2

package/managers/graph-operations-manager.js

@@ -1,15 +1,64 @@
+const { OPERATIONS } = require('../constants');
+const { deriveRepository } = require('../services/utilities.js');
+
 class GraphOperationsManager {
     constructor(config, services) {
         this.nodeApiService = services.nodeApiService;
+        this.validationService = services.validationService;
+        this.inputService = services.inputService;
     }
 
-    async query(queryString, type, options = {}) {
-        const operationId = await this.nodeApiService.query({ query: queryString, type }, options);
+    /**
+     * An asynchronous function that executes a SPARQL query using an API endpoint and returns the query result.
+     * @async
+     * @param {string} queryString - The string representation of the SPARQL query to be executed.
+     * @param {string} queryType - The type of the SPARQL query, "CONSTRUCT" or "SELECT".
+     * @param {Object} [options={}] - An object containing additional options for the query execution.
+     * @returns {Promise} A Promise that resolves to the query result.
+     */
+    async query(queryString, queryType, options = {}) {
+        const {
+            graphLocation,
+            graphState,
+            endpoint,
+            port,
+            maxNumberOfRetries,
+            frequency,
+            authToken,
+        } = this.inputService.getQueryArguments(options);
+
+        this.validationService.validateGraphQuery(
+            queryString,
+            queryType,
+            graphLocation,
+            graphState,
+            endpoint,
+            port,
+            maxNumberOfRetries,
+            frequency,
+            authToken,
+        );
+
+        const repository = deriveRepository(graphLocation, graphState);
+
+        const operationId = await this.nodeApiService.query(
+            endpoint,
+            port,
+            authToken,
+            queryString,
+            queryType,
+            repository,
+        );
 
-        return this.nodeApiService.getOperationResult(operationId, {
-            ...options,
-            operation: 'query',
-        });
+        return this.nodeApiService.getOperationResult(
+            endpoint,
+            port,
+            authToken,
+            OPERATIONS.QUERY,
+            maxNumberOfRetries,
+            frequency,
+            operationId,
+        );
     }
 }
 module.exports = GraphOperationsManager;

package/managers/node-operations-manager.js

@@ -1,10 +1,24 @@
 class NodeOperationsManager {
     constructor(config, services) {
         this.nodeApiService = services.nodeApiService;
+        this.inputService = services.inputService;
     }
 
-    async info() {
-        const response = await this.nodeApiService.info();
+    /**
+     * Gets the node info from the specified endpoint using the provided options.
+     * @async
+     * @param {Object} [options={}] - The options for the request.
+     * @param {string} [options.endpoint] - The endpoint URL to send the request to.
+     * @param {number} [options.port] - The port number to use for the request.
+     * @param {string} [options.authToken] - The authentication token to include in the request headers.
+     * @returns {Promise} - A promise that resolves to the node info data returned from the API.
+     */
+    async info(options = {}) {
+        const endpoint = this.inputService.getEndpoint(options);
+        const port = this.inputService.getPort(options);
+        const authToken = this.inputService.getAuthToken(options);
+
+        const response = await this.nodeApiService.info(endpoint, port, authToken);
 
         return response.data;
     }

package/package.json

@@ -1,11 +1,10 @@
 {
     "name": "dkg.js",
-    "version": "6.0.0",
+    "version": "6.0.2",
     "description": "Javascript library for interaction with the OriginTrail Decentralized Knowledge Graph",
     "main": "index.js",
     "scripts": {
-        "compile-contracts": "cd ./node_modules/dkg-evm-module && truffle compile",
-        "test": "npm run test",
+        "compile-contracts": "cd ./node_modules/dkg-evm-module && npm run compile",
         "build": "npx webpack --config webpack.config.js",
         "watch": "npx webpack --config webpack.config.js --watch --progress",
         "lint": "eslint ."
@@ -32,23 +31,22 @@
     "dependencies": {
         "assertion-tools": "^2.0.2",
         "axios": "^0.27.2",
-        "dkg-evm-module": "^3.2.1",
+        "dkg-evm-module": "^4.0.4",
+        "ethers": "^6.1.0",
         "jsonld": "^8.1.0",
         "web3": "^1.7.3"
     },
     "devDependencies": {
-        "assert": "^2.0.0",
-        "stream-browserify": "^3.0.0",
-        "stream-http": "^3.2.0",
-        "url": "^0.11.0",
         "crypto-browserify": "^3.12.0",
-        "https-browserify": "^1.0.0",
-        "terser-webpack-plugin": "^5.3.6",
-        "webpack": "^5.69.0",
-        "webpack-cli": "^4.9.2",
         "eslint": "^8.23.0",
         "eslint-config-airbnb": "^19.0.4",
         "eslint-config-prettier": "^8.5.0",
-        "prettier": "^2.7.1"
+        "https-browserify": "^1.0.0",
+        "prettier": "^2.7.1",
+        "stream-browserify": "^3.0.0",
+        "stream-http": "^3.2.0",
+        "terser-webpack-plugin": "^5.3.6",
+        "webpack": "^5.75.0",
+        "webpack-cli": "^4.9.2"
     }
 }

package/services/base-service-manager.js

@@ -4,6 +4,7 @@ const BlockchainInterface = require('./blockchain-service/blockchain-interface.j
 // services
 const ValidationService = require('./validation-service.js');
 const Utilities = require('./utilities.js');
+const InputService = require('./input-service.js');
 
 class BaseServiceManager {
     constructor(config) {
@@ -13,6 +14,7 @@ class BaseServiceManager {
     initializeServices(config) {
         this.blockchainService = this.initializeBlockchainService(config);
         this.nodeApiService = this.initializeNodeApiService(config);
+        this.inputService = new InputService(config);
         this.validationService = new ValidationService();
     }
 
@@ -21,6 +23,7 @@ class BaseServiceManager {
             blockchainService: this.blockchainService,
             nodeApiService: this.nodeApiService,
             validationService: this.validationService,
+            inputService: this.inputService,
         };
     }
 

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

@@ -1,11 +1,13 @@
 const Web3 = require('web3');
-const HubAbi = require('dkg-evm-module/build/contracts/Hub.json').abi;
-const ServiceAgreementV1Abi = require('dkg-evm-module/build/contracts/ServiceAgreementV1.json').abi;
-const ContentAssetStorageAbi =
-    require('dkg-evm-module/build/contracts/ContentAssetStorage.json').abi;
-const ContentAssetAbi = require('dkg-evm-module/build/contracts/ContentAsset.json').abi;
-const TokenAbi = require('dkg-evm-module/build/contracts/ERC20Token.json').abi;
-const { BLOCKCHAINS, OPERATIONS_STEP_STATUS } = require('../../constants');
+const AssertionStorageAbi = require('dkg-evm-module/abi/AssertionStorage.json');
+const HubAbi = require('dkg-evm-module/abi/Hub.json');
+const ServiceAgreementV1Abi = require('dkg-evm-module/abi/ServiceAgreementV1.json');
+const ServiceAgreementStorageProxyAbi = require('dkg-evm-module/abi/ServiceAgreementStorageProxy.json');
+const ContentAssetStorageAbi = require('dkg-evm-module/abi/ContentAssetStorage.json');
+const UnfinalizedStateStorageAbi = require('dkg-evm-module/abi/UnfinalizedStateStorage.json');
+const ContentAssetAbi = require('dkg-evm-module/abi/ContentAsset.json');
+const TokenAbi = require('dkg-evm-module/abi/Token.json');
+const { OPERATIONS_STEP_STATUS } = require('../../constants');
 const emptyHooks = require('../../util/empty-hooks.js');
 
 const FIXED_GAS_LIMIT_METHODS = {
@@ -15,20 +17,14 @@ const FIXED_GAS_LIMIT_METHODS = {
 class BlockchainServiceBase {
     constructor() {
         this.abis = {};
+        this.abis.AssertionStorage = AssertionStorageAbi;
         this.abis.Hub = HubAbi;
         this.abis.ServiceAgreementV1 = ServiceAgreementV1Abi;
+        this.abis.ServiceAgreementStorageProxy = ServiceAgreementStorageProxyAbi;
         this.abis.ContentAssetStorage = ContentAssetStorageAbi;
+        this.abis.UnfinalizedStateStorage = UnfinalizedStateStorageAbi;
         this.abis.ContentAsset = ContentAssetAbi;
         this.abis.Token = TokenAbi;
-
-        for (const blockchainName of Object.keys(BLOCKCHAINS)) {
-            this[blockchainName] = {
-                contracts: {},
-                contractAddresses: {
-                    Hub: BLOCKCHAINS[blockchainName].hubContract,
-                },
-            };
-        }
     }
 
     initializeWeb3() {
@@ -36,28 +32,18 @@ class BlockchainServiceBase {
         return {};
     }
 
-    getBlockchain() {
-        // overridden by subclasses
-        return {};
-    }
-
     async decodeEventLogs() {
         // overridden by subclasses
         return {};
     }
 
     async callContractFunction(contractName, functionName, args, blockchain) {
-        const contractInstance = await this.getContractInstance(
-            blockchain.name,
-            contractName,
-            blockchain.rpc,
-        );
-
+        const contractInstance = await this.getContractInstance(contractName, blockchain);
         return contractInstance.methods[functionName](...args).call();
     }
 
     async prepareTransaction(contractInstance, functionName, args, blockchain) {
-        const web3Instance = await this.getWeb3Instance(blockchain.name, blockchain.rpc);
+        const web3Instance = await this.getWeb3Instance(blockchain);
         let gasLimit;
         if (FIXED_GAS_LIMIT_METHODS[functionName]) {
             gasLimit = FIXED_GAS_LIMIT_METHODS[functionName];
@@ -82,70 +68,81 @@ class BlockchainServiceBase {
             to: contractInstance.options.address,
             data: encodedABI,
             gasPrice,
-            gas: gasLimit ?? Web3.utils.toWei('900', 'Kwei'),
+            gas: gasLimit,
         };
     }
 
-    async getWeb3Instance(blockchainName, blockchainRpc) {
-        if (!this[blockchainName].web3) {
-            this.initializeWeb3(blockchainName, blockchainRpc);
+    ensureBlockchainInfo(blockchain) {
+        if (!this[blockchain.name]) {
+            this[blockchain.name] = {
+                contracts: { [blockchain.hubContract]: {} },
+                contractAddresses: {
+                    [blockchain.hubContract]: {
+                        Hub: blockchain.hubContract,
+                    },
+                },
+            };
         }
+    }
 
-        return this[blockchainName].web3;
+    async getWeb3Instance(blockchain) {
+        this.ensureBlockchainInfo(blockchain);
+        if (!this[blockchain.name].web3) {
+            this.initializeWeb3(blockchain.name, blockchain.rpc);
+        }
+
+        return this[blockchain.name].web3;
     }
 
-    async getContractAddress(blockchainName, contractName, blockchainRpc) {
-        if (!this[blockchainName].contracts.Hub) {
-            const web3Instance = await this.getWeb3Instance(blockchainName, blockchainRpc);
-            this[blockchainName].contracts.Hub = new web3Instance.eth.Contract(
-                this.abis.Hub,
-                this[blockchainName].contractAddresses.Hub,
-            );
+    async getContractAddress(contractName, blockchain) {
+        this.ensureBlockchainInfo(blockchain);
+        if (!this[blockchain.name].contracts[blockchain.hubContract]) {
+            this[blockchain.name].contracts[blockchain.hubContract] = {};
+        }
+        if (!this[blockchain.name].contracts[blockchain.hubContract].Hub) {
+            const web3Instance = await this.getWeb3Instance(blockchain);
+            this[blockchain.name].contracts[blockchain.hubContract].Hub =
+                new web3Instance.eth.Contract(this.abis.Hub, blockchain.hubContract);
         }
 
-        if (!this[blockchainName].contractAddresses[contractName]) {
-            this[blockchainName].contractAddresses[contractName] = await this.callContractFunction(
-                'Hub',
-                contractName.includes('AssetStorage')
-                    ? 'getAssetStorageAddress'
-                    : 'getContractAddress',
-                [contractName],
-                {
-                    name: blockchainName,
-                    rpc: blockchainRpc,
-                },
-            );
+        if (!this[blockchain.name].contractAddresses[blockchain.hubContract][contractName]) {
+            this[blockchain.name].contractAddresses[blockchain.hubContract][contractName] =
+                await this.callContractFunction(
+                    'Hub',
+                    contractName.includes('AssetStorage')
+                        ? 'getAssetStorageAddress'
+                        : 'getContractAddress',
+                    [contractName],
+                    blockchain,
+                );
         }
-        return this[blockchainName].contractAddresses[contractName];
+        return this[blockchain.name].contractAddresses[blockchain.hubContract][contractName];
     }
 
-    async getContractInstance(blockchainName, contractName, blockchainRpc) {
-        if (!this[blockchainName].contractAddresses[contractName]) {
-            this[blockchainName].contractAddresses[contractName] = await this.getContractAddress(
-                blockchainName,
-                contractName,
-                blockchainRpc,
-            );
+    async getContractInstance(contractName, blockchain) {
+        this.ensureBlockchainInfo(blockchain);
+        if (!this[blockchain.name].contractAddresses[blockchain.hubContract][contractName]) {
+            this[blockchain.name].contractAddresses[blockchain.hubContract][contractName] =
+                await this.getContractAddress(contractName, blockchain);
         }
-        if (!this[blockchainName].contracts[contractName]) {
-            const web3Instance = await this.getWeb3Instance(blockchainName, blockchainRpc);
-            this[blockchainName].contracts[contractName] = new web3Instance.eth.Contract(
-                this.abis[contractName],
-                this[blockchainName].contractAddresses[contractName],
-            );
+        if (!this[blockchain.name].contracts[blockchain.hubContract][contractName]) {
+            const web3Instance = await this.getWeb3Instance(blockchain);
+            this[blockchain.name].contracts[blockchain.hubContract][contractName] =
+                new web3Instance.eth.Contract(
+                    this.abis[contractName],
+                    this[blockchain.name].contractAddresses[blockchain.hubContract][contractName],
+                );
         }
 
-        return this[blockchainName].contracts[contractName];
+        return this[blockchain.name].contracts[blockchain.hubContract][contractName];
     }
 
-    async createAsset(requestData, options, stepHooks = emptyHooks) {
-        const blockchain = this.getBlockchain(options);
-
+    async createAsset(requestData, blockchain, stepHooks = emptyHooks) {
         const serviceAgreementV1Address = await this.getContractAddress(
-            blockchain.name,
             'ServiceAgreementV1',
-            blockchain.rpc,
+            blockchain,
         );
+
         await this.executeContractFunction(
             'Token',
             'increaseAllowance',
@@ -165,7 +162,9 @@ class BlockchainServiceBase {
                 blockchain,
             );
 
-            const { tokenId } = await this.decodeEventLogs(receipt, 'AssetMinted', blockchain);
+            let { tokenId } = await this.decodeEventLogs(receipt, 'AssetMinted', blockchain);
+
+            tokenId = parseInt(tokenId, 10);
 
             stepHooks.afterHook({
                 status: OPERATIONS_STEP_STATUS.CREATE_ASSET_COMPLETED,
@@ -184,54 +183,71 @@ class BlockchainServiceBase {
         }
     }
 
-    async updateAsset(tokenId, requestData, options) {
-        const blockchain = this.getBlockchain(options);
-
+    async updateAsset(
+        tokenId,
+        publicAssertionId,
+        assertionSize,
+        triplesNumber,
+        chunksNumber,
+        tokenAmount,
+        blockchain,
+    ) {
         const serviceAgreementV1Address = await this.getContractAddress(
-            blockchain.name,
             'ServiceAgreementV1',
-            blockchain.rpc,
+            blockchain,
         );
 
         await this.executeContractFunction(
             'Token',
             'increaseAllowance',
-            [serviceAgreementV1Address, requestData.tokenAmount],
+            [serviceAgreementV1Address, tokenAmount],
             blockchain,
         );
 
         try {
             return this.executeContractFunction(
                 'ContentAsset',
-                'updateAsset',
-                [tokenId, Object.values(requestData)],
+                'updateAssetState',
+                [
+                    tokenId,
+                    publicAssertionId,
+                    assertionSize,
+                    triplesNumber,
+                    chunksNumber,
+                    tokenAmount,
+                ],
                 blockchain,
             );
         } catch (e) {
             await this.executeContractFunction(
                 'Token',
                 'decreaseAllowance',
-                [serviceAgreementV1Address, requestData.tokenAmount],
+                [serviceAgreementV1Address, tokenAmount],
                 blockchain,
             );
             throw e;
         }
     }
 
-    async getAssertionIdsLength(tokenId, options = {}) {
-        const blockchain = this.getBlockchain(options);
-
+    async hasPendingUpdate(tokenId, blockchain) {
         return this.callContractFunction(
-            'ContentAssetStorage',
-            'getAssertionIdsLength',
+            'UnfinalizedStateStorage',
+            'hasPendingUpdate',
             [tokenId],
             blockchain,
         );
     }
 
-    async getLatestAssertionId(tokenId, options = {}) {
-        const blockchain = this.getBlockchain(options);
+    async cancelAssetUpdate(tokenId, blockchain) {
+        return this.executeContractFunction(
+            'ContentAsset',
+            'cancelAssetStateUpdate',
+            [tokenId],
+            blockchain,
+        );
+    }
 
+    async getLatestAssertionId(tokenId, blockchain) {
         return this.callContractFunction(
             'ContentAssetStorage',
             'getLatestAssertionId',
@@ -240,12 +256,167 @@ class BlockchainServiceBase {
         );
     }
 
-    async getAssetOwner(tokenId, options = {}) {
-        const blockchain = this.getBlockchain(options);
+    async getUnfinalizedState(tokenId, blockchain) {
+        return this.callContractFunction(
+            'UnfinalizedStateStorage',
+            'getUnfinalizedState',
+            [tokenId],
+            blockchain,
+        );
+    }
 
+    async getAssetOwner(tokenId, blockchain) {
         return this.callContractFunction('ContentAssetStorage', 'ownerOf', [tokenId], blockchain);
     }
 
+    async burnAsset(tokenId, blockchain) {
+        return this.executeContractFunction('ContentAsset', 'burnAsset', [tokenId], blockchain);
+    }
+
+    async extendAssetStoringPeriod(tokenId, epochsNumber, tokenAmount, blockchain) {
+        const serviceAgreementV1Address = await this.getContractAddress(
+            'ServiceAgreementV1',
+            blockchain,
+        );
+
+        await this.executeContractFunction(
+            'Token',
+            'increaseAllowance',
+            [serviceAgreementV1Address, tokenAmount],
+            blockchain,
+        );
+
+        try {
+            return this.executeContractFunction(
+                'ContentAsset',
+                'extendAssetStoringPeriod',
+                [tokenId, epochsNumber, tokenAmount],
+                blockchain,
+            );
+        } catch (e) {
+            await this.executeContractFunction(
+                'Token',
+                'decreaseAllowance',
+                [serviceAgreementV1Address, tokenAmount],
+                blockchain,
+            );
+            throw e;
+        }
+    }
+
+    async addTokens(tokenId, tokenAmount, blockchain) {
+        const serviceAgreementV1Address = await this.getContractAddress(
+            'ServiceAgreementV1',
+            blockchain,
+        );
+
+        await this.executeContractFunction(
+            'Token',
+            'increaseAllowance',
+            [serviceAgreementV1Address, tokenAmount],
+            blockchain,
+        );
+
+        try {
+            return this.executeContractFunction(
+                'ContentAsset',
+                'increaseAssetTokenAmount',
+                [tokenId, tokenAmount],
+                blockchain,
+            );
+        } catch (e) {
+            await this.executeContractFunction(
+                'Token',
+                'decreaseAllowance',
+                [serviceAgreementV1Address, tokenAmount],
+                blockchain,
+            );
+            throw e;
+        }
+    }
+
+    async addUpdateTokens(tokenId, tokenAmount, blockchain) {
+        const serviceAgreementV1Address = await this.getContractAddress(
+            'ServiceAgreementV1',
+            blockchain,
+        );
+
+        await this.executeContractFunction(
+            'Token',
+            'increaseAllowance',
+            [serviceAgreementV1Address, tokenAmount],
+            blockchain,
+        );
+
+        try {
+            return this.executeContractFunction(
+                'ContentAsset',
+                'increaseAssetUpdateTokenAmount',
+                [tokenId, tokenAmount],
+                blockchain,
+            );
+        } catch (e) {
+            await this.executeContractFunction(
+                'Token',
+                'decreaseAllowance',
+                [serviceAgreementV1Address, tokenAmount],
+                blockchain,
+            );
+            throw e;
+        }
+    }
+
+    async getAssertionIdByIndex(tokenId, index, blockchain) {
+        return this.callContractFunction(
+            'ContentAssetStorage',
+            'getAssertionIdByIndex',
+            [tokenId, index],
+            blockchain,
+        );
+    }
+
+    async getAgreementData(agreementId, blockchain) {
+        const result = await this.callContractFunction(
+            'ServiceAgreementStorageProxy',
+            'getAgreementData',
+            [agreementId],
+            blockchain,
+        );
+
+        return {
+            startTime: Number(result['0']),
+            epochsNumber: Number(result['1']),
+            epochLength: Number(result['2']),
+            tokenAmount: result['3'][0],
+            addedTokenAmount: result['3'][1],
+            scoreFunctionId: result['4'][0],
+            proofWindowOffsetPerc: result['4'][1],
+        };
+    }
+
+    async getAssertionSize(assertionId, blockchain) {
+        return this.callContractFunction(
+            'AssertionStorage',
+            'getAssertionSize',
+            [assertionId],
+            blockchain,
+        );
+    }
+
+    async getBlockchainTimestamp(blockchain) {
+        if (blockchain.name !== 'hardhat') return Math.floor(Date.now() / 1000);
+
+        const latestBlock = await this.getLatestBlock(blockchain);
+        return latestBlock.timestamp;
+    }
+
+    async getLatestBlock(blockchain) {
+        const web3 = await this.getWeb3Instance(blockchain);
+        const blockNumber = await web3.eth.getBlockNumber();
+
+        return web3.eth.getBlock(blockNumber);
+    }
+
     convertToWei(ether) {
         return Web3.utils.toWei(ether.toString(), 'ether');
     }