dkg.js 6.0.6 → 6.0.7

package/.github/workflows/npm-publish.yml

@@ -24,10 +24,13 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v3
 
-      - name: Set up environment
-        uses: ./.github/actions/setup
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '16.x'
+          registry-url: 'https://registry.npmjs.org'
 
       - name: Publish npm package
         run: npm publish
         env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/examples/demo.js

@@ -111,7 +111,7 @@ function divider() {
 
     divider();
 
-    let getLatestAssetResult = await DkgClient.asset.get(createAssetResult.UAL);
+    const getLatestAssetResult = await DkgClient.asset.get(createAssetResult.UAL);
     console.log('======================== ASSET LATEST  RESOLVED');
     console.log(JSON.stringify(getLatestAssetResult, null, 2));
 
@@ -138,6 +138,36 @@ function divider() {
 
     divider();
 
+    const getFirstStateByIndex = await DkgClient.asset.get(createAssetResult.UAL, {
+        state: 0,
+    });
+    console.log('======================== ASSET FIRST STATE (GET BY STATE INDEX) RESOLVED');
+    console.log(JSON.stringify(getFirstStateByIndex, null, 2));
+
+    divider();
+
+    const getSecondStateByIndex = await DkgClient.asset.get(createAssetResult.UAL, {
+        state: 1,
+    });
+    console.log('======================== ASSET SECOND STATE (GET BY STATE INDEX) RESOLVED');
+    console.log(JSON.stringify(getSecondStateByIndex, null, 2));
+
+    divider();
+
+    const getFirstStateByHash = await DkgClient.asset.get(createAssetResult.UAL, {
+        state: createAssetResult.publicAssertionId,
+    });
+    console.log('======================== ASSET FIRST STATE (GET BY STATE HASH) RESOLVED');
+    console.log(JSON.stringify(getFirstStateByHash, null, 2));
+
+    divider();
+
+    const getSecondStateByHash = await DkgClient.asset.get(createAssetResult.UAL, {
+        state: updateAssetResult.publicAssertionId,
+    });
+    console.log('======================== ASSET SECOND STATE (GET BY STATE HASH) RESOLVED');
+    console.log(JSON.stringify(getSecondStateByHash, null, 2));
+
     let queryResult = await DkgClient.graph.query(
         'construct { ?s ?p ?o } where { ?s ?p ?o . <uuid:1> ?p ?o }',
         'CONSTRUCT',

package/managers/asset-operations-manager.js

@@ -1,5 +1,5 @@
 const { assertionMetadata, formatAssertion, calculateRoot } = require('assertion-tools');
-const { ethers } = require('ethers');
+const { ethers, ZeroHash } = require('ethers');
 const {
     isEmptyObject,
     deriveUAL,
@@ -307,7 +307,7 @@ class AssetOperationsManager {
      * @async
      * @param {string} UAL - The Universal Asset Locator
      * @param {Object} [options={}] - Optional parameters for the asset get operation.
-     * @param {string} [options.state] - The state of the asset, "latest" or "finalized".
+     * @param {string} [options.state] - The state or state index of the asset, "latest", "finalized", numerical, hash.
      * @param {string} [options.contentType] - The type of content to retrieve, either "public", "private" or "all".
      * @param {boolean} [options.validate] - Whether to validate the retrieved assertion.
      * @param {string} [options.outputFormat] - The format of the retrieved assertion output, either "n-quads" or "json-ld".
@@ -344,21 +344,56 @@ class AssetOperationsManager {
         );
 
         const { tokenId } = resolveUAL(UAL);
-        let hasPendingUpdate = false;
-        if (state === ASSET_STATES.LATEST) {
-            hasPendingUpdate = await this.blockchainService.hasPendingUpdate(tokenId, blockchain);
+
+        let publicAssertionId;
+        if(state === ASSET_STATES.LATEST) {
+            const unfinalizedState = await this.blockchainService.getUnfinalizedState(
+                tokenId,
+                blockchain,
+            );
+
+            if (unfinalizedState != null && unfinalizedState !== ZeroHash) {
+                publicAssertionId = unfinalizedState;
+            }
         }
 
-        const publicAssertionId = hasPendingUpdate
-            ? await this.blockchainService.getUnfinalizedState(tokenId, blockchain)
-            : await this.blockchainService.getLatestAssertionId(tokenId, blockchain);
+        let assertionIds = [];
+        const isEnumState = Object.values(ASSET_STATES).includes(state);
+        if(!publicAssertionId) {
+            assertionIds = await this.blockchainService.getAssertionIds(tokenId, blockchain);
+
+            if (isEnumState) {
+                publicAssertionId = assertionIds[assertionIds.length - 1];
+            } else if (typeof state === 'number') {
+                if (state >= assertionIds.length) {
+                    throw Error('State index is out of range.');
+                }
+
+                publicAssertionId = assertionIds[state];
+            } else if (assertionIds.includes(state)) {
+                publicAssertionId = state;
+            } else if (/^0x[a-fA-F0-9]{64}$/.test(state)) {
+                const unfinalizedState = await this.blockchainService.getUnfinalizedState(
+                    tokenId,
+                    blockchain,
+                );
+    
+                if (unfinalizedState != null && unfinalizedState !== ZeroHash && state === unfinalizedState) {
+                    publicAssertionId = unfinalizedState;
+                } else {
+                    throw Error('Given state hash isn\'t a part of the Knowledge Asset.')
+                }
+            } else {
+                throw Error('Incorrect state option.');
+            }
+        }
 
         const getPublicOperationId = await this.nodeApiService.get(
             endpoint,
             port,
             authToken,
             UAL,
-            state,
+            isEnumState ? state : publicAssertionId,
             hashFunctionId,
         );
 
@@ -373,9 +408,21 @@ class AssetOperationsManager {
         );
 
         if (!getPublicOperationResult.data.assertion) {
+            if (getPublicOperationResult.status !== 'FAILED') {
+                getPublicOperationResult.data = {
+                    errorType: 'DKG_CLIENT_ERROR',
+                    errorMessage: 'Unable to find assertion on the network!',
+                };
+                getPublicOperationResult.status = 'FAILED';
+            }
+
             return {
-                errorType: 'DKG_CLIENT_ERROR',
-                errorMessage: 'Unable to find assertion on the network!',
+                operation: {
+                    publicGet: getOperationStatusObject(
+                        getPublicOperationResult,
+                        getPublicOperationId,
+                    ),
+                },
             };
         }
 
@@ -914,12 +961,12 @@ class AssetOperationsManager {
         const blockchain = this.inputService.getBlockchain(options);
         const tokenAmount = this.inputService.getTokenAmount(options);
 
-         this.validationService.validateExtendAssetStoringPeriod(
-             UAL,
-             epochsNumber,
-             tokenAmount,
-             blockchain,
-         );
+        this.validationService.validateExtendAssetStoringPeriod(
+            UAL,
+            epochsNumber,
+            tokenAmount,
+            blockchain,
+        );
 
         const { tokenId, contract } = resolveUAL(UAL);
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dkg.js",
-    "version": "6.0.6",
+    "version": "6.0.7",
     "description": "Javascript library for interaction with the OriginTrail Decentralized Knowledge Graph",
     "main": "index.js",
     "scripts": {

package/services/validation-service.js

@@ -186,13 +186,22 @@ class ValidationService {
         if (param == null) throw Error(`${paramName} is missing.`);
     }
 
-    validateParamType(paramName, param, type) {
+    validateParamType(paramName, param, typeOrTypes) {
+        const isTypesArray = Array.isArray(typeOrTypes);
+
         let parameter = param;
-        if (type === 'number') {
+        if (isTypesArray && typeOrTypes.includes('number')) {
+            const parsed = parseInt(param, 10);
+            parameter = Number.isNaN(parsed) ? param : parsed;
+        } else if (typeOrTypes === 'number') {
             parameter = parseInt(param, 10);
         }
+        const types = isTypesArray ? typeOrTypes : [typeOrTypes];
+    
         // eslint-disable-next-line valid-typeof
-        if (typeof parameter !== type) throw Error(`${paramName} must be of type ${type}.`);
+        if (!types.some(type => typeof parameter === type)) {
+            throw new Error(`${paramName} must be of type ${types.join(" or ")}.`);
+        }
     }
 
     validateQueryString(queryString) {
@@ -288,10 +297,14 @@ class ValidationService {
 
     validateState(state) {
         this.validateRequiredParam('state', state);
-        this.validateParamType('state', state, 'string');
-        const validStates = Object.values(ASSET_STATES);
-        if (!validStates.includes(state.toUpperCase()))
-            throw Error(`Invalid state, available states: ${validStates}`);
+        this.validateParamType('state', state, ['number', 'string']);
+        const validStatesEnum = Object.values(ASSET_STATES);
+        if (
+            (typeof state === 'string' && !validStatesEnum.includes(state.toUpperCase())) &&
+            typeof state !== 'number' &&
+            !/^0x[a-fA-F0-9]{64}$/.test(state)
+        )
+            throw Error(`Invalid state, available states: ${validStatesEnum},numerical or hash.`);
     }
 
     validateContentType(contentType) {