dkg.js 6.0.0 → 6.0.2

package/managers/asset-operations-manager.js

@@ -1,54 +1,97 @@
 const { assertionMetadata, formatAssertion, calculateRoot } = require('assertion-tools');
-const jsonld = require('jsonld');
+const { ethers } = require('ethers');
 const {
     isEmptyObject,
     deriveUAL,
     getOperationStatusObject,
     resolveUAL,
+    toNQuads,
+    toJSONLD,
+    sleepForMilliseconds,
+    deriveRepository,
 } = require('../services/utilities.js');
 const {
+    CONTENT_TYPES,
     OPERATIONS,
-    DEFAULT_HASH_FUNCTION_ID,
     OPERATIONS_STEP_STATUS,
     GET_OUTPUT_FORMATS,
     OPERATION_STATUSES,
     DEFAULT_GET_LOCAL_STORE_RESULT_FREQUENCY,
     PRIVATE_ASSERTION_PREDICATE,
+    QUERY_TYPES,
+    DEFAULT_PARAMETERS,
 } = require('../constants.js');
 const emptyHooks = require('../util/empty-hooks');
+const { STORE_TYPES, ASSET_STATES } = require('../constants');
 
 class AssetOperationsManager {
     constructor(config, services) {
         this.nodeApiService = services.nodeApiService;
         this.validationService = services.validationService;
         this.blockchainService = services.blockchainService;
+        this.inputService = services.inputService;
     }
 
-    async create(userContent, opts = {}, stepHooks = emptyHooks) {
-        const options = JSON.parse(JSON.stringify(opts));
-
-        this.validationService.validateContentType(userContent);
-        let content = {};
+    /**
+     * Creates a new asset.
+     * @async
+     * @param {Object} content - The content of the asset to be created, contains public, private or both keys.
+     * @param {Object} [options={}] - Additional options for asset creation.
+     * @param {Object} [stepHooks=emptyHooks] - Hooks to execute during asset creation.
+     * @returns {Object} Object containing UAL, publicAssertionId and operation status.
+     */
+    async create(content, options = {}, stepHooks = emptyHooks) {
+        this.validationService.validateObjectType(content);
+        let jsonContent = {};
 
         // for backwards compatibility
-        if (!userContent.public && !userContent.private) {
-            content.public = userContent;
+        if (!content.public && !content.private) {
+            jsonContent.public = content;
         } else {
-            content = userContent;
+            jsonContent = content;
         }
 
-        this.validationService.validatePublishRequest(content, options);
+        const {
+            blockchain,
+            endpoint,
+            port,
+            maxNumberOfRetries,
+            frequency,
+            epochsNum,
+            hashFunctionId,
+            scoreFunctionId,
+            immutable,
+            tokenAmount,
+            authToken,
+        } = this.inputService.getAssetCreateArguments(options);
+
+        this.validationService.validateAssetCreate(
+            jsonContent,
+            blockchain,
+            endpoint,
+            port,
+            maxNumberOfRetries,
+            frequency,
+            epochsNum,
+            hashFunctionId,
+            scoreFunctionId,
+            immutable,
+            tokenAmount,
+            authToken,
+        );
 
         let privateAssertion;
         let privateAssertionId;
-        if (content.private && !isEmptyObject(content.private)) {
-            privateAssertion = await formatAssertion(content.private);
+        if (jsonContent.private && !isEmptyObject(jsonContent.private)) {
+            privateAssertion = await formatAssertion(jsonContent.private);
             privateAssertionId = calculateRoot(privateAssertion);
         }
         const publicGraph = {
             '@graph': [
-                content.public && !isEmptyObject(content.public) ? content.public : null,
-                content.private && !isEmptyObject(content.private)
+                jsonContent.public && !isEmptyObject(jsonContent.public)
+                    ? jsonContent.public
+                    : null,
+                jsonContent.private && !isEmptyObject(jsonContent.private)
                     ? {
                           [PRIVATE_ASSERTION_PREDICATE]: privateAssertionId,
                       }
@@ -58,88 +101,112 @@ class AssetOperationsManager {
         const publicAssertion = await formatAssertion(publicGraph);
         const publicAssertionId = calculateRoot(publicAssertion);
 
-        const blockchain = this.blockchainService.getBlockchain(options);
         const contentAssetStorageAddress = await this.blockchainService.getContractAddress(
-            blockchain.name,
             'ContentAssetStorage',
-            blockchain.rpc,
+            blockchain,
         );
+
         const tokenAmountInWei =
-            options.tokenAmount ??
+            tokenAmount ??
             (await this.nodeApiService.getBidSuggestion(
+                endpoint,
+                port,
+                authToken,
                 blockchain.name.startsWith('otp') ? 'otp' : blockchain.name,
-                options.epochsNum,
+                epochsNum,
                 assertionMetadata.getAssertionSizeInBytes(publicAssertion),
                 contentAssetStorageAddress,
                 publicAssertionId,
-                options.hashFunctionId ?? DEFAULT_HASH_FUNCTION_ID,
-                options,
+                hashFunctionId,
             ));
+
         const tokenId = await this.blockchainService.createAsset(
             {
                 publicAssertionId,
                 assertionSize: assertionMetadata.getAssertionSizeInBytes(publicAssertion),
                 triplesNumber: assertionMetadata.getAssertionTriplesNumber(publicAssertion),
                 chunksNumber: assertionMetadata.getAssertionChunksNumber(publicAssertion),
-                epochsNum: options.epochsNum,
+                epochsNum,
                 tokenAmount: tokenAmountInWei,
-                scoreFunctionId: options.scoreFunctionId ?? 1,
-                immutable_: options.immutable ?? false,
+                scoreFunctionId: scoreFunctionId ?? 1,
+                immutable_: immutable,
             },
-            options,
+            blockchain,
             stepHooks,
         );
 
-        const UAL = deriveUAL(blockchain.name, contentAssetStorageAddress, tokenId);
-
-        let operationResult;
-        let operationId;
+        const resolvedUAL = {
+            blockchain: blockchain.name.startsWith('otp') ? 'otp' : blockchain.name,
+            contract: contentAssetStorageAddress,
+            tokenId,
+        };
+        const assertions = [
+            {
+                ...resolvedUAL,
+                assertionId: publicAssertionId,
+                assertion: publicAssertion,
+                storeType: STORE_TYPES.TRIPLE,
+            },
+        ];
         if (privateAssertion?.length) {
-            operationId = await this.nodeApiService.localStore(
-                [
-                    {
-                        blockchain: blockchain.name,
-                        contract: contentAssetStorageAddress,
-                        tokenId,
-                        assertionId: publicAssertionId,
-                        assertion: publicAssertion,
-                    },
-                    {
-                        blockchain: blockchain.name,
-                        contract: contentAssetStorageAddress,
-                        tokenId,
-                        assertionId: privateAssertionId,
-                        assertion: privateAssertion,
-                    },
-                ],
-                options,
-            );
-            operationResult = await this.nodeApiService.getOperationResult(operationId, {
-                ...options,
-                operation: OPERATIONS.LOCAL_STORE,
-                frequency: DEFAULT_GET_LOCAL_STORE_RESULT_FREQUENCY,
+            assertions.push({
+                ...resolvedUAL,
+                assertionId: privateAssertionId,
+                assertion: privateAssertion,
+                storeType: STORE_TYPES.TRIPLE,
             });
+        }
+        let operationId = await this.nodeApiService.localStore(
+            endpoint,
+            port,
+            authToken,
+            assertions,
+        );
+        let operationResult = await this.nodeApiService.getOperationResult(
+            endpoint,
+            port,
+            authToken,
+            OPERATIONS.LOCAL_STORE,
+            maxNumberOfRetries,
+            DEFAULT_GET_LOCAL_STORE_RESULT_FREQUENCY,
+            operationId,
+        );
 
-            if (operationResult.status === OPERATION_STATUSES.FAILED) {
-                return {
-                    UAL,
-                    assertionId: publicAssertionId,
-                    operation: getOperationStatusObject(operationResult, operationId),
-                };
-            }
+        const UAL = deriveUAL(
+            blockchain.name.startsWith('otp') ? 'otp' : blockchain.name,
+            contentAssetStorageAddress,
+            tokenId,
+        );
+
+        if (operationResult.status === OPERATION_STATUSES.FAILED) {
+            return {
+                UAL,
+                assertionId: publicAssertionId,
+                operation: getOperationStatusObject(operationResult, operationId),
+            };
         }
 
         operationId = await this.nodeApiService.publish(
+            endpoint,
+            port,
+            authToken,
             publicAssertionId,
             publicAssertion,
-            UAL,
-            options,
+            blockchain.name.startsWith('otp') ? 'otp' : blockchain.name,
+            contentAssetStorageAddress,
+            tokenId,
+            hashFunctionId,
         );
 
-        operationResult = await this.nodeApiService.getOperationResult(operationId, {
-            ...options,
-            operation: OPERATIONS.PUBLISH,
-        });
+        operationResult = await this.nodeApiService.getOperationResult(
+            endpoint,
+            port,
+            authToken,
+            OPERATIONS.PUBLISH,
+            maxNumberOfRetries,
+            frequency,
+            operationId,
+        );
 
         stepHooks.afterHook({
             status: OPERATIONS_STEP_STATUS.CREATE_ASSET_COMPLETED,
@@ -156,104 +223,473 @@ class AssetOperationsManager {
         };
     }
 
-    async get(UAL, opts = {}) {
-        const options = JSON.parse(JSON.stringify(opts));
-        this.validationService.validateGetRequest(UAL, options);
+    /**
+     * Retrieves a public or private assertion for a given UAL.
+     * @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.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".
+     * @returns {Object} - The result of the asset get operation.
+     */
+    async get(UAL, options = {}) {
+        const {
+            blockchain,
+            endpoint,
+            port,
+            maxNumberOfRetries,
+            frequency,
+            state,
+            contentType,
+            validate,
+            outputFormat,
+            authToken,
+            hashFunctionId,
+        } = this.inputService.getAssetGetArguments(options);
+
+        this.validationService.validateAssetGet(
+            UAL,
+            blockchain,
+            endpoint,
+            port,
+            maxNumberOfRetries,
+            frequency,
+            state,
+            contentType,
+            hashFunctionId,
+            validate,
+            outputFormat,
+            authToken,
+        );
+
         const { tokenId } = resolveUAL(UAL);
+        let hasPendingUpdate = false;
+        if (state === ASSET_STATES.LATEST) {
+            hasPendingUpdate = await this.blockchainService.hasPendingUpdate(tokenId, blockchain);
+        }
 
-        const assertionId = await this.blockchainService.getLatestAssertionId(tokenId, options);
+        const publicAssertionId = hasPendingUpdate
+            ? await this.blockchainService.getUnfinalizedState(tokenId, blockchain)
+            : await this.blockchainService.getLatestAssertionId(tokenId, blockchain);
 
-        const operationId = await this.nodeApiService.get(UAL, options);
-        let operationResult = await this.nodeApiService.getOperationResult(operationId, {
-            ...options,
-            operation: OPERATIONS.GET,
-        });
-        let { assertion } = operationResult.data;
-        if (assertion) {
+        const getPublicOperationId = await this.nodeApiService.get(
+            endpoint,
+            port,
+            authToken,
+            UAL,
+            state,
+            hashFunctionId,
+        );
+
+        const getPublicOperationResult = await this.nodeApiService.getOperationResult(
+            endpoint,
+            port,
+            authToken,
+            OPERATIONS.GET,
+            maxNumberOfRetries,
+            frequency,
+            getPublicOperationId,
+        );
+
+        if(!getPublicOperationResult.data.assertion) {
+            return {
+                errorType: 'DKG_CLIENT_ERROR',
+                errorMessage: "Unable to find assertion on the network!",
+            };
+        }
+
+        const publicAssertion = getPublicOperationResult.data.assertion;
+
+        if (validate === true && calculateRoot(publicAssertion) !== publicAssertionId) {
+            getPublicOperationResult.data = {
+                errorType: 'DKG_CLIENT_ERROR',
+                errorMessage: "Calculated root hashes don't match!",
+            };
+        }
+
+        let result = { operation: {} };
+        if (contentType !== CONTENT_TYPES.PRIVATE) {
+            let formattedPublicAssertion = publicAssertion;
             try {
-                if (options.validate === true) {
-                    if (calculateRoot(assertion) !== assertionId)
-                        throw Error("Calculated root hashes don't match!");
-                }
-                if (options.outputFormat !== GET_OUTPUT_FORMATS.N_QUADS) {
-                    assertion = await jsonld.fromRDF(assertion.join('\n'), {
-                        algorithm: 'URDNA2015',
-                        format: 'application/n-quads',
-                    });
+                if (outputFormat !== GET_OUTPUT_FORMATS.N_QUADS) {
+                    formattedPublicAssertion = await toJSONLD(publicAssertion.join('\n'));
+                } else {
+                    formattedPublicAssertion = publicAssertion.join('\n');
                 }
             } catch (error) {
-                operationResult = {
-                    ...operationResult,
-                    data: {
+                getPublicOperationResult.data = {
+                    errorType: 'DKG_CLIENT_ERROR',
+                    errorMessage: error.message,
+                };
+            }
+
+            if (contentType === CONTENT_TYPES.PUBLIC) {
+                result = {
+                    ...result,
+                    assertion: formattedPublicAssertion,
+                    assertionId: publicAssertionId,
+                };
+            } else {
+                result.public = {
+                    assertion: formattedPublicAssertion,
+                    assertionId: publicAssertionId,
+                };
+            }
+
+            result.operation.publicGet = getOperationStatusObject(
+                getPublicOperationResult,
+                getPublicOperationId,
+            );
+        }
+
+        if (contentType !== CONTENT_TYPES.PUBLIC) {
+            const privateAssertionLinkTriple = publicAssertion.filter((element) =>
+                element.includes(PRIVATE_ASSERTION_PREDICATE),
+            )[0];
+
+            let queryPrivateOperationId;
+            let queryPrivateOperationResult = {};
+            if (privateAssertionLinkTriple) {
+                const privateAssertionId = privateAssertionLinkTriple.match(/"(.*?)"/)[1];
+                let privateAssertion;
+                if (getPublicOperationResult?.data?.privateAssertion?.length)
+                    privateAssertion = getPublicOperationResult.data.privateAssertion;
+                else {
+                    const queryString = `
+                    CONSTRUCT { ?s ?p ?o }
+                    WHERE {
+                        {
+                            GRAPH <assertion:${privateAssertionId}>
+                            {
+                                ?s ?p ?o .
+                            }
+                        }
+                    }`;
+
+                    const repository = deriveRepository(
+                        DEFAULT_PARAMETERS.GRAPH_LOCATION,
+                        DEFAULT_PARAMETERS.GRAPH_STATE,
+                    );
+                    queryPrivateOperationId = await this.nodeApiService.query(
+                        endpoint,
+                        port,
+                        authToken,
+                        queryString,
+                        QUERY_TYPES.CONSTRUCT,
+                        repository
+                    );
+
+                    queryPrivateOperationResult = await this.nodeApiService.getOperationResult(
+                        endpoint,
+                        port,
+                        authToken,
+                        OPERATIONS.QUERY,
+                        maxNumberOfRetries,
+                        frequency,
+                        queryPrivateOperationId,
+                    );
+
+                    const privateAssertionNQuads = queryPrivateOperationResult.data;
+
+                    privateAssertion = await toNQuads(
+                        privateAssertionNQuads,
+                        'application/n-quads',
+                    );
+                }
+
+                let formattedPrivateAssertion;
+                if (
+                    privateAssertion.length &&
+                    validate === true &&
+                    calculateRoot(privateAssertion) !== privateAssertionId
+                ) {
+                    queryPrivateOperationResult.data = {
+                        errorType: 'DKG_CLIENT_ERROR',
+                        errorMessage: "Calculated root hashes don't match!",
+                    };
+                }
+
+                try {
+                    if (outputFormat !== GET_OUTPUT_FORMATS.N_QUADS) {
+                        formattedPrivateAssertion = await toJSONLD(privateAssertion.join('\n'));
+                    } else {
+                        formattedPrivateAssertion = privateAssertion.join('\n');
+                    }
+                } catch (error) {
+                    queryPrivateOperationResult.data = {
                         errorType: 'DKG_CLIENT_ERROR',
                         errorMessage: error.message,
+                    };
+                }
+
+                if (contentType === CONTENT_TYPES.PRIVATE) {
+                    result = {
+                        ...result,
+                        assertion: formattedPrivateAssertion,
+                        assertionId: privateAssertionId,
+                    };
+                } else {
+                    result.private = {
+                        assertion: formattedPrivateAssertion,
+                        assertionId: privateAssertionId,
+                    };
+                }
+                if (queryPrivateOperationId) {
+                    result.operation.queryPrivate = getOperationStatusObject(
+                        queryPrivateOperationResult,
+                        queryPrivateOperationId,
+                    );
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Updates an existing asset.
+     * @async
+     * @param {string} UAL - The Universal Asset Locator
+     * @param {Object} content - The content of the asset to be updated.
+     * @param {Object} [options={}] - Additional options for asset update.
+     * @returns {Object} Object containing UAL, publicAssertionId and operation status.
+     */
+    async update(UAL, content, options = {}) {
+        this.validationService.validateObjectType(content);
+        const jsonContent = content;
+
+        const {
+            blockchain,
+            endpoint,
+            port,
+            maxNumberOfRetries,
+            frequency,
+            hashFunctionId,
+            scoreFunctionId,
+            tokenAmount,
+            authToken,
+        } = this.inputService.getAssetUpdateArguments(options);
+
+        this.validationService.validateAssetUpdate(
+            jsonContent,
+            blockchain,
+            endpoint,
+            port,
+            maxNumberOfRetries,
+            frequency,
+            hashFunctionId,
+            scoreFunctionId,
+            tokenAmount,
+            authToken,
+        );
+
+        const { tokenId } = resolveUAL(UAL);
+
+        let privateAssertion;
+        let privateAssertionId;
+        if (jsonContent.private && !isEmptyObject(jsonContent.private)) {
+            privateAssertion = await formatAssertion(jsonContent.private);
+            privateAssertionId = calculateRoot(privateAssertion);
+        }
+        const publicGraph = {
+            '@graph': [
+                jsonContent.public && !isEmptyObject(jsonContent.public)
+                    ? jsonContent.public
+                    : null,
+                jsonContent.private && !isEmptyObject(jsonContent.private)
+                    ? {
+                          [PRIVATE_ASSERTION_PREDICATE]: privateAssertionId,
+                      }
+                    : null,
+            ],
+        };
+        const publicAssertion = await formatAssertion(publicGraph);
+        const publicAssertionId = calculateRoot(publicAssertion);
+
+        const contentAssetStorageAddress = await this.blockchainService.getContractAddress(
+            'ContentAssetStorage',
+            blockchain,
+        );
+
+        let tokenAmountInWei;
+
+        if (tokenAmount != null) {
+            tokenAmountInWei = tokenAmount;
+        } else {
+            tokenAmountInWei = await this._getUpdateBidSuggestion(
+                UAL,
+                blockchain,
+                endpoint,
+                port,
+                authToken,
+                publicAssertionId,
+                assertionMetadata.getAssertionSizeInBytes(publicAssertion),
+                hashFunctionId,
+            );
+        }
+
+        await this.blockchainService.updateAsset(
+            tokenId,
+            publicAssertionId,
+            assertionMetadata.getAssertionSizeInBytes(publicAssertion),
+            assertionMetadata.getAssertionTriplesNumber(publicAssertion),
+            assertionMetadata.getAssertionChunksNumber(publicAssertion),
+            tokenAmountInWei,
+            blockchain,
+        );
+
+        const resolvedUAL = {
+            blockchain: blockchain.name.startsWith('otp') ? 'otp' : blockchain.name,
+            contract: contentAssetStorageAddress,
+            tokenId,
+        };
+
+        const assertions = [
+            {
+                ...resolvedUAL,
+                assertionId: publicAssertionId,
+                assertion: publicAssertion,
+                storeType: STORE_TYPES.PENDING,
+            },
+        ];
+
+        if (privateAssertion?.length) {
+            assertions.push({
+                ...resolvedUAL,
+                assertionId: privateAssertionId,
+                assertion: privateAssertion,
+                storeType: STORE_TYPES.PENDING,
+            });
+        }
+
+        let operationId = await this.nodeApiService.localStore(
+            endpoint,
+            port,
+            authToken,
+            assertions,
+        );
+
+        let operationResult = await this.nodeApiService.getOperationResult(
+            endpoint,
+            port,
+            authToken,
+            OPERATIONS.LOCAL_STORE,
+            maxNumberOfRetries,
+            DEFAULT_GET_LOCAL_STORE_RESULT_FREQUENCY,
+            operationId,
+        );
+
+        if (operationResult.status === OPERATION_STATUSES.FAILED) {
+            return {
+                UAL,
+                assertionId: publicAssertionId,
+                operation: getOperationStatusObject(operationResult, operationId),
+            };
+        }
+
+        operationId = await this.nodeApiService.update(
+            endpoint,
+            port,
+            authToken,
+            publicAssertionId,
+            publicAssertion,
+            blockchain.name.startsWith('otp') ? 'otp' : blockchain.name,
+            contentAssetStorageAddress,
+            tokenId,
+            hashFunctionId,
+        );
+        operationResult = await this.nodeApiService.getOperationResult(
+            endpoint,
+            port,
+            authToken,
+            OPERATIONS.UPDATE,
+            maxNumberOfRetries,
+            frequency,
+            operationId,
+        );
+        return {
+            UAL,
+            operation: getOperationStatusObject(operationResult, operationId),
+        };
+    }
+
+    async waitFinalization(UAL, options = {}) {
+        const blockchain = this.inputService.getBlockchain(options);
+        const frequency = this.inputService.getFrequency(options);
+        const maxNumberOfRetries = this.inputService.getMaxNumberOfRetries(options);
+
+        this.validationService.validateWaitAssetUpdateFinalization(UAL, blockchain);
+
+        const { tokenId } = resolveUAL(UAL);
+        const response = {
+            status: OPERATION_STATUSES.PENDING,
+        };
+        let pendingUpdate = true;
+        let retries = 0;
+        do {
+            if (retries > maxNumberOfRetries) {
+                response.data = {
+                    ...response.data,
+                    data: {
+                        errorType: 'DKG_CLIENT_ERROR',
+                        errorMessage: 'Unable to get results. Max number of retries reached.',
                     },
                 };
+                break;
             }
+            retries += 1;
+            // eslint-disable-next-line no-await-in-loop
+            await sleepForMilliseconds(frequency * 1000);
+            // eslint-disable-next-line no-await-in-loop
+            pendingUpdate = await this.blockchainService.hasPendingUpdate(tokenId, blockchain);
+        } while (pendingUpdate);
+        if (pendingUpdate) {
+            response.status = OPERATION_STATUSES.PENDING;
+        } else {
+            response.status = OPERATION_STATUSES.COMPLETED;
         }
 
         return {
-            assertion,
-            assertionId,
-            operation: getOperationStatusObject(operationResult, operationId),
+            UAL,
+            operation: getOperationStatusObject(
+                { data: response.data, status: response.status },
+                null,
+            ),
         };
     }
 
-    /* async update(UAL, content, opts = {}) {
-    const options = JSON.parse(JSON.stringify(opts));
-    this.validationService.validatePublishRequest(content, options);
-
-    const assertion = await formatAssertion(content);
-    const assertionId = calculateRoot(assertion);
-    const tokenAmount =
-      options.tokenAmount ??
-      (await this.nodeApiService.getBidSuggestion(
-        options.blockchain.name,
-        options.epochsNum,
-        assertionMetadata.getAssertionSizeInBytes(assertion),
-        options.hashFunctionId ?? DEFAULT_HASH_FUNCTION_ID,
-        options
-      ));
-
-    await this.blockchainService.updateAsset(
-      Utilities.resolveUAL(UAL).tokenId,
-      {
-        assertionId,
-        assertionSize: assertionMetadata.getAssertionSizeInBytes(assertion),
-        triplesNumber: assertionMetadata.getAssertionTriplesNumber(assertion),
-        chunksNumber: assertionMetadata.getAssertionChunksNumber(assertion),
-        epochsNum: options.epochsNum,
-        tokenAmount: tokenAmount,
-        scoreFunctionId: options.scoreFunctionId ?? 1,
-      },
-      options
-    );
-    let operationId = await this.nodeApiService.publish(
-      assertionId,
-      assertion,
-      UAL,
-      options
-    );
-    let operationResult = await this.nodeApiService.getOperationResult(
-      operationId,
-      { ...options, operation: OPERATIONS.PUBLISH }
-    );
-    return {
-      UAL,
-      assertionId,
-      operation: Utilities.getOperationStatusObject(
-        operationResult,
-        operationId
-      ),
-    };
-  } */
-
-    async transfer(UAL, to, opts = {}) {
-        const options = JSON.parse(JSON.stringify(opts));
-        this.validationService.validateAssetTransferRequest(UAL, to, options);
+    async cancelUpdate(UAL, options = {}) {
+        const blockchain = this.inputService.getBlockchain(options);
+
+        this.validationService.validateAssetUpdateCancel(UAL, blockchain);
+
+        const { tokenId } = resolveUAL(UAL);
+        await this.blockchainService.cancelAssetUpdate(tokenId, blockchain);
+
+        return {
+            UAL,
+            operation: getOperationStatusObject({ status: 'COMPLETED' }, null),
+        };
+    }
+
+    /**
+     * Transfer an asset to a new owner on a specified blockchain.
+     * @async
+     * @param {string} UAL - The Universal Asset Locator of the asset to be transferred.
+     * @param {string} newOwner - The address of the new owner.
+     * @param {Object} [options={}] - Additional options for asset transfer.
+     * @returns {Object} Object containing UAL, owner's address and operation status.
+     */
+    async transfer(UAL, newOwner, options = {}) {
+        const blockchain = this.inputService.getBlockchain(options);
+
+        this.validationService.validateAssetTransfer(UAL, newOwner, blockchain);
+
         const { tokenId } = resolveUAL(UAL);
-        await this.blockchainService.transferAsset(tokenId, to, options);
-        const owner = await this.blockchainService.getAssetOwner(tokenId, options);
+        await this.blockchainService.transferAsset(tokenId, newOwner, blockchain);
+        const owner = await this.blockchainService.getAssetOwner(tokenId, blockchain);
         return {
             UAL,
             owner,
@@ -261,16 +697,262 @@ class AssetOperationsManager {
         };
     }
 
-    async getOwner(UAL, opts = {}) {
-        const options = JSON.parse(JSON.stringify(opts));
-        this.validationService.validateGetOwnerRequest(UAL);
+    /**
+     * Retrieves the owner of a specified asset for a given blockchain.
+     * @async
+     * @param {string} UAL - The Universal Asset Locator of the asset.
+     * @param {Object} [options={}] - Optional parameters for blockchain service.
+     * @returns {Object} An object containing the UAL, owner and operation status.
+     */
+    async getOwner(UAL, options = {}) {
+        const blockchain = this.inputService.getBlockchain(options);
+
+        this.validationService.validateAssetGetOwner(UAL, blockchain);
+
         const { tokenId } = resolveUAL(UAL);
-        const owner = await this.blockchainService.getAssetOwner(tokenId, options);
+        const owner = await this.blockchainService.getAssetOwner(tokenId, blockchain);
         return {
             UAL,
             owner,
             operation: getOperationStatusObject({ data: {}, status: 'COMPLETED' }, null),
         };
     }
+
+    async burn(UAL, options = {}) {
+        const blockchain = this.inputService.getBlockchain(options);
+
+        this.validationService.validateAssetBurn(UAL, blockchain);
+
+        const { tokenId } = resolveUAL(UAL);
+        await this.blockchainService.burnAsset(tokenId, blockchain);
+
+        return {
+            UAL,
+            operation: getOperationStatusObject({ status: 'COMPLETED' }, null),
+        };
+    }
+
+    async extendStoringPeriod(UAL, epochsNumber, options = {}) {
+        const blockchain = this.inputService.getBlockchain(options);
+        const tokenAmount = this.inputService.getTokenAmount(options);
+
+        const { tokenId } = resolveUAL(UAL);
+
+        let tokenAmountInWei;
+
+        if (tokenAmount != null) {
+            tokenAmountInWei = tokenAmount;
+        } else {
+            const endpoint = this.inputService.getEndpoint(options);
+            const port = this.inputService.getPort(options);
+            const authToken = this.inputService.getAuthToken(options);
+            const hashFunctionId = this.inputService.getHashFunctionId(options);
+
+            const latestFinalizedState = await this.blockchainService.getLatestAssertionId(
+                tokenId,
+                blockchain,
+            );
+
+            const latestFinalizedStateSize = await this.blockchainService.getAssertionSize(
+                latestFinalizedState,
+                blockchain,
+            );
+
+            tokenAmountInWei = await this._getUpdateBidSuggestion(
+                UAL,
+                blockchain,
+                endpoint,
+                port,
+                authToken,
+                latestFinalizedState,
+                latestFinalizedStateSize,
+                hashFunctionId,
+            );
+
+            if (tokenAmountInWei < 0) {
+                tokenAmountInWei = 0;
+            }
+        }
+
+        this.validationService.validateExtendAssetStoringPeriod(
+            UAL,
+            epochsNumber,
+            tokenAmountInWei,
+            blockchain,
+        );
+
+        await this.blockchainService.extendAssetStoringPeriod(
+            tokenId,
+            epochsNumber,
+            tokenAmountInWei,
+            blockchain,
+        );
+
+        return {
+            UAL,
+            operation: getOperationStatusObject({ status: 'COMPLETED' }, null),
+        };
+    }
+
+    async addTokens(UAL, options = {}) {
+        const blockchain = this.inputService.getBlockchain(options);
+        const tokenAmount = this.inputService.getTokenAmount(options);
+
+        const { tokenId } = resolveUAL(UAL);
+
+        let tokenAmountInWei;
+
+        if (tokenAmount != null) {
+            tokenAmountInWei = tokenAmount;
+        } else {
+            const endpoint = this.inputService.getEndpoint(options);
+            const port = this.inputService.getPort(options);
+            const authToken = this.inputService.getAuthToken(options);
+            const hashFunctionId = this.inputService.getHashFunctionId(options);
+
+            const latestFinalizedState = await this.blockchainService.getLatestAssertionId(
+                tokenId,
+                blockchain,
+            );
+
+            const latestFinalizedStateSize = await this.blockchainService.getAssertionSize(
+                latestFinalizedState,
+                blockchain,
+            );
+
+            tokenAmountInWei = await this._getUpdateBidSuggestion(
+                UAL,
+                blockchain,
+                endpoint,
+                port,
+                authToken,
+                latestFinalizedState,
+                latestFinalizedStateSize,
+                hashFunctionId,
+            );
+
+            if (tokenAmountInWei <= 0) {
+                throw Error(
+                    `Token amount is bigger than default suggested amount, please specify exact tokenAmount if you still want to add more tokens!`,
+                );
+            }
+        }
+
+        this.validationService.validateAddTokens(UAL, tokenAmountInWei, blockchain);
+
+        await this.blockchainService.addTokens(tokenId, tokenAmountInWei, blockchain);
+
+        return {
+            UAL,
+            operation: getOperationStatusObject({ status: 'COMPLETED' }, null),
+        };
+    }
+
+    async addUpdateTokens(UAL, options = {}) {
+        const blockchain = this.inputService.getBlockchain(options);
+        const tokenAmount = this.inputService.getTokenAmount(options);
+
+        const { tokenId } = resolveUAL(UAL);
+
+        let tokenAmountInWei;
+
+        if (tokenAmount != null) {
+            tokenAmountInWei = tokenAmount;
+        } else {
+            const endpoint = this.inputService.getEndpoint(options);
+            const port = this.inputService.getPort(options);
+            const authToken = this.inputService.getAuthToken(options);
+            const hashFunctionId = this.inputService.getHashFunctionId(options);
+
+            const unfinalizedState = await this.blockchainService.getUnfinalizedState(
+                tokenId,
+                blockchain,
+            );
+
+            const unfinalizedStateSize = await this.blockchainService.getAssertionSize(
+                unfinalizedState,
+                blockchain,
+            );
+
+            tokenAmountInWei = await this._getUpdateBidSuggestion(
+                UAL,
+                blockchain,
+                endpoint,
+                port,
+                authToken,
+                unfinalizedState,
+                unfinalizedStateSize,
+                hashFunctionId,
+            );
+            if (tokenAmountInWei <= 0) {
+                throw Error(
+                    `Token amount is bigger than default suggested amount, please specify exact tokenAmount if you still want to add more tokens!`,
+                );
+            }
+        }
+
+        this.validationService.validateAddTokens(UAL, tokenAmountInWei, blockchain);
+
+        await this.blockchainService.addUpdateTokens(tokenId, tokenAmountInWei, blockchain);
+
+        return {
+            UAL,
+            operation: getOperationStatusObject({ status: 'COMPLETED' }, null),
+        };
+    }
+
+    async _getUpdateBidSuggestion(
+        UAL,
+        blockchain,
+        endpoint,
+        port,
+        authToken,
+        assertionId,
+        size,
+        hashFunctionId,
+    ) {
+        const { contract, tokenId } = resolveUAL(UAL);
+        const firstAssertionId = await this.blockchainService.getAssertionIdByIndex(
+            tokenId,
+            0,
+            blockchain,
+        );
+
+        const keyword = ethers.solidityPacked(['address', 'bytes32'], [contract, firstAssertionId]);
+
+        const agreementId = ethers.sha256(
+            ethers.solidityPacked(['address', 'uint256', 'bytes'], [contract, tokenId, keyword]),
+        );
+        const agreementData = await this.blockchainService.getAgreementData(
+            agreementId,
+            blockchain,
+        );
+
+        const now = await this.blockchainService.getBlockchainTimestamp(blockchain);
+        const currentEpoch = Math.floor(
+            (now - agreementData.startTime) / agreementData.epochLength,
+        );
+
+        const epochsLeft = agreementData.epochsNumber - currentEpoch;
+
+        const bidSuggestion = await this.nodeApiService.getBidSuggestion(
+            endpoint,
+            port,
+            authToken,
+            blockchain.name.startsWith('otp') ? 'otp' : blockchain.name,
+            epochsLeft,
+            size,
+            contract,
+            assertionId,
+            hashFunctionId,
+        );
+
+        const tokenAmountInWei =
+            BigInt(bidSuggestion) -
+            (BigInt(agreementData.tokenAmount) + BigInt(agreementData.updateTokenAmount ?? 0));
+
+        return tokenAmountInWei > 0 ? tokenAmountInWei : 0;
+    }
 }
+
 module.exports = AssetOperationsManager;