dkg.js 6.0.0 → 6.0.2

package/services/blockchain-service/implementations/browser-blockchain-service.js

@@ -1,25 +1,13 @@
 const Web3 = require('web3');
 const BlockchainServiceBase = require('../blockchain-service-base.js');
-const { WEBSOCKET_PROVIDER_OPTIONS, BLOCKCHAINS } = require('../../../constants.js');
+const { WEBSOCKET_PROVIDER_OPTIONS } = require('../../../constants.js');
 
 class BrowserBlockchainService extends BlockchainServiceBase {
-    constructor(config) {
+    constructor(config = {}) {
         super(config);
         this.config = config;
     }
 
-    getBlockchain(options) {
-        return {
-            name: options.blockchain.name,
-            hubContract:
-                options.blockchain.hubContract ?? BLOCKCHAINS[options.blockchain.name].hubContract,
-            assetContract:
-                options.blockchain.assetContract ??
-                BLOCKCHAINS[options.blockchain.name].assetContract,
-            rpc: options.blockchain.rpc ?? BLOCKCHAINS[options.blockchain.name].rpc,
-        };
-    }
-
     initializeWeb3(blockchainName, blockchainRpc) {
         if (typeof window.Web3 === 'undefined' || !window.Web3) {
             this.logger.error(
@@ -41,11 +29,7 @@ class BrowserBlockchainService extends BlockchainServiceBase {
     }
 
     async executeContractFunction(contractName, functionName, args, blockchain) {
-        const contractInstance = await this.getContractInstance(
-            blockchain.name,
-            contractName,
-            blockchain.rpc,
-        );
+        const contractInstance = await this.getContractInstance(contractName, blockchain);
         const tx = await this.prepareTransaction(contractInstance, functionName, args, {
             name: blockchain.name,
             publicKey: await this.getAccount(),
@@ -74,12 +58,12 @@ class BrowserBlockchainService extends BlockchainServiceBase {
         return receipt.events[eventName].returnValues;
     }
 
-    async transferAsset(tokenId, to, options) {
+    async transferAsset(tokenId, to, blockchain) {
         return this.executeContractFunction(
             'ContentAssetStorage',
             'transferFrom',
             [await this.getAccount(), to, tokenId],
-            this.getBlockchain(options),
+            blockchain,
         );
     }
 }

package/services/blockchain-service/implementations/node-blockchain-service.js

@@ -1,9 +1,9 @@
 const Web3 = require('web3');
-const { BLOCKCHAINS, WEBSOCKET_PROVIDER_OPTIONS } = require('../../../constants.js');
+const { WEBSOCKET_PROVIDER_OPTIONS } = require('../../../constants.js');
 const BlockchainServiceBase = require('../blockchain-service-base.js');
 
 class NodeBlockchainService extends BlockchainServiceBase {
-    constructor(config) {
+    constructor(config = {}) {
         super(config);
         this.config = config;
         this.events = {};
@@ -31,23 +31,10 @@ class NodeBlockchainService extends BlockchainServiceBase {
         }
     }
 
-    getBlockchain(options) {
-        return {
-            name: options.blockchain.name,
-            rpc: options.blockchain.rpc ?? BLOCKCHAINS[options.blockchain.name].rpc,
-            publicKey: this.config.blockchain?.publicKey ?? options.blockchain.publicKey,
-            privateKey: this.config.blockchain?.privateKey ?? options.blockchain.privateKey,
-        };
-    }
-
     async executeContractFunction(contractName, functionName, args, blockchain) {
-        const web3Instance = await this.getWeb3Instance(blockchain.name, blockchain.rpc);
+        const web3Instance = await this.getWeb3Instance(blockchain);
 
-        const contractInstance = await this.getContractInstance(
-            blockchain.name,
-            contractName,
-            blockchain.rpc,
-        );
+        const contractInstance = await this.getContractInstance(contractName, blockchain);
         const tx = await this.prepareTransaction(contractInstance, functionName, args, blockchain);
         const createdTransaction = await web3Instance.eth.accounts.signTransaction(
             tx,
@@ -58,7 +45,7 @@ class NodeBlockchainService extends BlockchainServiceBase {
     }
 
     async decodeEventLogs(receipt, eventName, blockchain) {
-        const web3Instance = await this.getWeb3Instance(blockchain.name, blockchain.rpc);
+        const web3Instance = await this.getWeb3Instance(blockchain);
         let result;
         const { hash, inputs } = this.events[eventName];
         receipt.logs.forEach((row) => {
@@ -68,9 +55,7 @@ class NodeBlockchainService extends BlockchainServiceBase {
         return result;
     }
 
-    async transferAsset(tokenId, to, options) {
-        const blockchain = this.getBlockchain(options);
-
+    async transferAsset(tokenId, to, blockchain) {
         return this.executeContractFunction(
             'ContentAssetStorage',
             'transferFrom',

package/services/input-service.js

@@ -0,0 +1,167 @@
+const { DEFAULT_PARAMETERS, BLOCKCHAINS } = require('../constants');
+
+class InputService {
+    constructor(config = {}) {
+        this.config = config;
+    }
+
+    getAssetCreateArguments(options) {
+        return {
+            blockchain: this.getBlockchain(options),
+            endpoint: this.getEndpoint(options),
+            port: this.getPort(options),
+            maxNumberOfRetries: this.getMaxNumberOfRetries(options),
+            frequency: this.getFrequency(options),
+            epochsNum: this.getEpochsNum(options),
+            hashFunctionId: this.getHashFunctionId(options),
+            scoreFunctionId: this.getScoreFunctionId(options),
+            immutable: this.getImmutable(options),
+            tokenAmount: this.getTokenAmount(options),
+            authToken: this.getAuthToken(options),
+        };
+    }
+
+    getAssetGetArguments(options) {
+        return {
+            blockchain: this.getBlockchain(options),
+            endpoint: this.getEndpoint(options),
+            port: this.getPort(options),
+            maxNumberOfRetries: this.getMaxNumberOfRetries(options),
+            frequency: this.getFrequency(options),
+            state: this.getState(options),
+            contentType: this.getContentType(options),
+            validate: this.getValidate(options),
+            outputFormat: this.getOutputFormat(options),
+            authToken: this.getAuthToken(options),
+            hashFunctionId: this.getHashFunctionId(options),
+        };
+    }
+
+    getAssetUpdateArguments(options) {
+        return {
+            blockchain: this.getBlockchain(options),
+            endpoint: this.getEndpoint(options),
+            port: this.getPort(options),
+            maxNumberOfRetries: this.getMaxNumberOfRetries(options),
+            frequency: this.getFrequency(options),
+            hashFunctionId: this.getHashFunctionId(options),
+            scoreFunctionId: this.getScoreFunctionId(options),
+            tokenAmount: this.getTokenAmount(options),
+            authToken: this.getAuthToken(options),
+        };
+    }
+
+    getQueryArguments(options) {
+        return {
+            graphLocation: this.getGraphLocation(options),
+            graphState: this.getGraphState(options),
+            endpoint: this.getEndpoint(options),
+            port: this.getPort(options),
+            maxNumberOfRetries: this.getMaxNumberOfRetries(options),
+            frequency: this.getFrequency(options),
+            authToken: this.getAuthToken(options),
+        };
+    }
+
+    getBlockchain(options) {
+        const name = options.blockchain?.name ?? this.config.blockchain?.name ?? null;
+        const rpc =
+            options.blockchain?.rpc ?? this.config.blockchain?.rpc ?? BLOCKCHAINS[name]?.rpc;
+        const hubContract =
+            options.blockchain?.hubContract ??
+            this.config.blockchain?.hubContract ??
+            BLOCKCHAINS[name]?.hubContract;
+        const publicKey =
+            options.blockchain?.publicKey ?? this.config.blockchain?.publicKey ?? null;
+        const privateKey =
+            options.blockchain?.privateKey ?? this.config.blockchain?.privateKey ?? null;
+
+        return {
+            name,
+            rpc,
+            hubContract,
+            publicKey,
+            privateKey,
+        };
+    }
+
+    getGraphLocation(options) {
+        return (
+            options.graphLocation ?? this.config.graphLocation ?? DEFAULT_PARAMETERS.GRAPH_LOCATION
+        );
+    }
+
+    getGraphState(options) {
+        return options.graphState ?? this.config.graphState ?? DEFAULT_PARAMETERS.GRAPH_STATE;
+    }
+
+    getEndpoint(options) {
+        return options.endpoint ?? this.config.endpoint ?? null;
+    }
+
+    getPort(options) {
+        return options.port ?? this.config.port ?? DEFAULT_PARAMETERS.PORT;
+    }
+
+    getFrequency(options) {
+        return options.frequency ?? this.config.frequency ?? DEFAULT_PARAMETERS.FREQUENCY;
+    }
+
+    getHashFunctionId(options) {
+        return (
+            options.hashFunctionId ??
+            this.config.hashFunctionId ??
+            DEFAULT_PARAMETERS.HASH_FUNCTION_ID
+        );
+    }
+
+    getScoreFunctionId(options) {
+        return (
+            options.scoreFunctionId ??
+            this.config.scoreFunctionId ??
+            DEFAULT_PARAMETERS.SCORE_FUNCTION_ID
+        );
+    }
+
+    getEpochsNum(options) {
+        return options.epochsNum ?? this.config.epochsNum ?? null;
+    }
+
+    getImmutable(options) {
+        return options.immutable ?? this.config.immutable ?? DEFAULT_PARAMETERS.IMMUTABLE;
+    }
+
+    getTokenAmount(options) {
+        return options.tokenAmount ?? this.config.tokenAmount ?? null;
+    }
+
+    getState(options) {
+        return options.state ?? this.config.state ?? DEFAULT_PARAMETERS.STATE;
+    }
+
+    getContentType(options) {
+        return options.contentType ?? this.config.contentType ?? DEFAULT_PARAMETERS.CONTENT_TYPE;
+    }
+
+    getValidate(options) {
+        return options.validate ?? this.config.validate ?? DEFAULT_PARAMETERS.VALIDATE;
+    }
+
+    getOutputFormat(options) {
+        return options.outputFormat ?? this.config.outputFormat ?? DEFAULT_PARAMETERS.OUTPUT_FORMAT;
+    }
+
+    getMaxNumberOfRetries(options) {
+        return (
+            options.maxNumberOfRetries ??
+            this.config.maxNumberOfRetries ??
+            DEFAULT_PARAMETERS.MAX_NUMBER_OF_RETRIES
+        );
+    }
+
+    getAuthToken(options) {
+        return options.auth?.token ?? this.config?.auth?.token ?? null;
+    }
+}
+
+module.exports = InputService;

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

@@ -1,22 +1,18 @@
 const axios = require('axios');
-const {
-    OPERATION_STATUSES,
-    DEFAULT_GET_OPERATION_RESULT_FREQUENCY,
-    DEFAULT_GET_OPERATION_RESULT_MAX_NUM_RETRIES,
-} = require('../../../constants.js');
-const { sleepForMilliseconds, resolveUAL } = require('../../utilities.js');
+const { OPERATION_STATUSES } = require('../../../constants.js');
+const { sleepForMilliseconds } = require('../../utilities.js');
 
 class HttpService {
-    constructor(config) {
+    constructor(config = {}) {
         this.config = config;
     }
 
-    async info() {
+    async info(endpoint, port, authToken) {
         try {
             const response = await axios({
                 method: 'get',
-                url: `${this.config.endpoint}:${this.config.port}/info`,
-                headers: this.prepareRequestConfig(),
+                url: `${endpoint}:${port}/info`,
+                headers: this.prepareRequestConfig(authToken),
             });
 
             return response;
@@ -26,19 +22,20 @@ class HttpService {
     }
 
     async getBidSuggestion(
+        endpoint,
+        port,
+        authToken,
         blockchain,
         epochsNumber,
         assertionSize,
         contentAssetStorageAddress,
         firstAssertionId,
         hashFunctionId,
-        options,
     ) {
-        const endpoint = options.endpoint ?? this.config.endpoint;
         try {
             const response = await axios({
                 method: 'get',
-                url: `${endpoint}:${this.config.port}/bid-suggestion`,
+                url: `${endpoint}:${port}/bid-suggestion`,
                 params: {
                     blockchain,
                     epochsNumber,
@@ -47,7 +44,7 @@ class HttpService {
                     firstAssertionId,
                     hashFunctionId,
                 },
-                headers: this.prepareRequestConfig(),
+                headers: this.prepareRequestConfig(authToken),
             });
 
             return response.data.bidSuggestion;
@@ -56,15 +53,13 @@ class HttpService {
         }
     }
 
-    async localStore(assertions, options) {
-        const endpoint = options.endpoint ?? this.config.endpoint;
-
+    async localStore(endpoint, port, authToken, assertions) {
         try {
             const response = await axios({
                 method: 'post',
-                url: `${endpoint}:${this.config.port}/local-store`,
+                url: `${endpoint}:${port}/local-store`,
                 data: assertions,
-                headers: this.prepareRequestConfig(),
+                headers: this.prepareRequestConfig(authToken),
             });
 
             return response.data.operationId;
@@ -73,21 +68,30 @@ class HttpService {
         }
     }
 
-    async publish(assertionId, assertion, UAL, options) {
-        const requestBody = this.preparePublishRequest(
-            assertionId,
-            assertion,
-            UAL,
-            options.hashFunctionId,
-        );
-        const endpoint = options.endpoint ?? this.config.endpoint;
-
+    async publish(
+        endpoint,
+        port,
+        authToken,
+        assertionId,
+        assertion,
+        blockchain,
+        contract,
+        tokenId,
+        hashFunctionId,
+    ) {
         try {
             const response = await axios({
                 method: 'post',
-                url: `${endpoint}:${this.config.port}/publish`,
-                data: requestBody,
-                headers: this.prepareRequestConfig(),
+                url: `${endpoint}:${port}/publish`,
+                data: {
+                    assertionId,
+                    assertion,
+                    blockchain,
+                    contract,
+                    tokenId,
+                    hashFunctionId,
+                },
+                headers: this.prepareRequestConfig(authToken),
             });
 
             return response.data.operationId;
@@ -96,15 +100,17 @@ class HttpService {
         }
     }
 
-    async get(UAL, options) {
-        const requestBody = this.prepareGetAssertionRequest(UAL, 1);
-        const endpoint = options.endpoint ?? this.config.endpoint;
+    async get(endpoint, port, authToken, UAL, state, hashFunctionId) {
         try {
             const response = await axios({
                 method: 'post',
-                url: `${endpoint}:${this.config.port}/get`,
-                data: requestBody,
-                headers: this.prepareRequestConfig(),
+                url: `${endpoint}:${port}/get`,
+                data: {
+                    id: UAL,
+                    state,
+                    hashFunctionId,
+                },
+                headers: this.prepareRequestConfig(authToken),
             });
 
             return response.data.operationId;
@@ -113,14 +119,45 @@ class HttpService {
         }
     }
 
-    async query(data, options) {
-        const endpoint = options.endpoint ?? this.config.endpoint;
+    async update(
+        endpoint,
+        port,
+        authToken,
+        assertionId,
+        assertion,
+        blockchain,
+        contract,
+        tokenId,
+        hashFunctionId,
+    ) {
         try {
             const response = await axios({
                 method: 'post',
-                url: `${endpoint}:${this.config.port}/query`,
-                data: { query: data.query, type: data.type },
-                headers: this.prepareRequestConfig(),
+                url: `${endpoint}:${port}/update`,
+                data: {
+                    assertionId,
+                    assertion,
+                    blockchain,
+                    contract,
+                    tokenId,
+                    hashFunctionId,
+                },
+                headers: this.prepareRequestConfig(authToken),
+            });
+
+            return response.data.operationId;
+        } catch (error) {
+            throw Error(`Unable to update: ${error.message}`);
+        }
+    }
+
+    async query(endpoint, port, authToken, query, type, repository) {
+        try {
+            const response = await axios({
+                method: 'post',
+                url: `${endpoint}:${port}/query`,
+                data: { query, type, repository },
+                headers: this.prepareRequestConfig(authToken),
             });
             return response.data.operationId;
         } catch (error) {
@@ -128,24 +165,25 @@ class HttpService {
         }
     }
 
-    async getOperationResult(operationId, options) {
+    async getOperationResult(
+        endpoint,
+        port,
+        authToken,
+        operation,
+        maxNumberOfRetries,
+        frequency,
+        operationId,
+    ) {
         await sleepForMilliseconds(500);
-        if (!operationId) {
-            throw Error('Operation ID is missing, unable to fetch the operation results.');
-        }
         let response = {
             status: OPERATION_STATUSES.PENDING,
         };
         let retries = 0;
-        const maxNumberOfRetries =
-            options.maxNumberOfRetries ?? DEFAULT_GET_OPERATION_RESULT_MAX_NUM_RETRIES;
-        const frequency = options.frequency ?? DEFAULT_GET_OPERATION_RESULT_FREQUENCY;
 
-        const endpoint = options.endpoint ?? this.config.endpoint;
         const axios_config = {
             method: 'get',
-            url: `${endpoint}:${this.config.port}/${options.operation}/${operationId}`,
-            headers: this.prepareRequestConfig(),
+            url: `${endpoint}:${port}/${operation}/${operationId}`,
+            headers: this.prepareRequestConfig(authToken),
         };
         do {
             if (retries > maxNumberOfRetries) {
@@ -170,28 +208,9 @@ class HttpService {
         return response.data;
     }
 
-    preparePublishRequest(assertionId, assertion, UAL, hashFunctionId = 1) {
-        const { blockchain, contract, tokenId } = resolveUAL(UAL);
-        return {
-            assertionId,
-            assertion,
-            blockchain,
-            contract,
-            tokenId: parseInt(tokenId, 10),
-            hashFunctionId,
-        };
-    }
-
-    prepareGetAssertionRequest(UAL, hashFunctionId = 1) {
-        return {
-            id: UAL,
-            hashFunctionId,
-        };
-    }
-
-    prepareRequestConfig() {
-        if (this.config?.auth?.token) {
-            return { Authorization: `Bearer ${this.config.auth.token}` };
+    prepareRequestConfig(authToken) {
+        if (authToken) {
+            return { Authorization: `Bearer ${authToken}` };
         }
 
         return {};

package/services/utilities.js

@@ -1,27 +1,29 @@
+const jsonld = require('jsonld');
+const { GRAPH_LOCATIONS, GRAPH_STATES, OT_NODE_TRIPLE_STORE_REPOSITORIES } = require('../constants.js');
+
 module.exports = {
-  nodeSupported() {
-    return typeof window === "undefined";
-  },
-  isEmptyObject(object) {
-    // eslint-disable-next-line no-unreachable-loop
-    for (const key in object) {
-      return false;
-    }
-    return true;
-  },
-  toNumber(hex) {
-    return parseInt(hex.slice(2), 16);
-  },
-  deriveUAL(blockchain, contract, tokenId) {
-    return `did:dkg:${
-      blockchain.startsWith("otp") ? "otp" : blockchain.toLowerCase()
-    }/${contract.toLowerCase()}/${tokenId}`;
-  },
-  resolveUAL(ual) {
-    const segments = ual.split(":");
-    const argsString =
-      segments.length === 3 ? segments[2] : segments[2] + segments[3];
-    const args = argsString.split("/");
+    nodeSupported() {
+        return typeof window === 'undefined';
+    },
+    isEmptyObject(object) {
+        // eslint-disable-next-line no-unreachable-loop
+        for (const key in object) {
+            return false;
+        }
+        return true;
+    },
+    toNumber(hex) {
+        return parseInt(hex.slice(2), 16);
+    },
+    deriveUAL(blockchain, contract, tokenId) {
+        return `did:dkg:${
+            blockchain.startsWith('otp') ? 'otp' : blockchain.toLowerCase()
+        }/${contract.toLowerCase()}/${tokenId}`;
+    },
+    resolveUAL(ual) {
+        const segments = ual.split(':');
+        const argsString = segments.length === 3 ? segments[2] : segments[2] + segments[3];
+        const args = argsString.split('/');
 
         if (args.length !== 3) {
             throw new Error(`UAL doesn't have correct format: ${ual}`);
@@ -30,9 +32,25 @@ module.exports = {
         return {
             blockchain: args[0],
             contract: args[1],
-            tokenId: args[2],
+            tokenId: parseInt(args[2], 10),
         };
     },
+    deriveRepository(graphLocation, graphState) {
+        switch (graphLocation + graphState) {
+            case GRAPH_LOCATIONS.PUBLIC_KG + GRAPH_STATES.CURRENT:
+                return OT_NODE_TRIPLE_STORE_REPOSITORIES.PUBLIC_CURRENT;
+            case GRAPH_LOCATIONS.PUBLIC_KG + GRAPH_STATES.HISTORICAL:
+                return OT_NODE_TRIPLE_STORE_REPOSITORIES.PUBLIC_HISTORY;
+            case GRAPH_LOCATIONS.LOCAL_KG + GRAPH_STATES.CURRENT:
+                return OT_NODE_TRIPLE_STORE_REPOSITORIES.PRIVATE_CURRENT;
+            case GRAPH_LOCATIONS.LOCAL_KG + GRAPH_STATES.HISTORICAL:
+                return OT_NODE_TRIPLE_STORE_REPOSITORIES.PRIVATE_HISTORY;
+            default:
+                throw new Error(
+                    `Unknown graph location and state: ${graphLocation}, ${graphState}`,
+                );
+        }
+    },
     async sleepForMilliseconds(milliseconds) {
         // eslint-disable-next-line no-promise-executor-return
         await new Promise((r) => setTimeout(r, milliseconds));
@@ -50,4 +68,24 @@ module.exports = {
             ...operationData,
         };
     },
+    async toNQuads(content, inputFormat) {
+        const options = {
+            algorithm: 'URDNA2015',
+            format: 'application/n-quads',
+        };
+
+        if (inputFormat) {
+            options.inputFormat = inputFormat;
+        }
+
+        const canonized = await jsonld.canonize(content, options);
+
+        return canonized.split('\n').filter((x) => x !== '');
+    },
+    async toJSONLD(nquads) {
+        return jsonld.fromRDF(nquads, {
+            algorithm: 'URDNA2015',
+            format: 'application/n-quads',
+        });
+    },
 };