docs: async function () {
      const oThis = this
      ;
  
      try {
        // validations
        if (!basicHelper.isTxHashValid(oThis.transactionHash)) {
          let errObj = responseHelper.error({
            internal_error_identifier: 's_ob_grs_1',
            api_error_identifier: 'invalid_transaction_hash',
            error_config: basicHelper.fetchErrorConfig()
          });
  
          return Promise.resolve(errObj);
        }
  
        // returns the registration status of the proposal
        const registrationStatus = new RegistrationStatusKlass()
        ;
  
        // check if the proposal transaction is mined
        const getReceiptObj = new getReceipt({transaction_hash: oThis.transactionHash, chain: web3UcProvider.chainKind});
        const proposalTxReceiptResponse = await getReceiptObj.perform();
        // if error or transaction not yet mined or transaction failed, return. Else proceed and check for other things
        if (!proposalTxReceiptResponse.isSuccess() || !proposalTxReceiptResponse.data.formattedTransactionReceipt) {
          return registrationStatus.returnResultPromise();
        }
        registrationStatus.setIsProposalDone(1);
  
        const proposalFormattedTxReceipt = proposalTxReceiptResponse.data.formattedTransactionReceipt;
        const proposalFormattedEvents = await web3EventsFormatter.perform(proposalFormattedTxReceipt);
  
        const uuid = proposalFormattedEvents['ProposedBrandedToken']['_uuid'];
        registrationStatus.setUuid(uuid);
  
        // now checking to confirm if registration on UC took place
        const registeredOnUCResponse = await openSTUtilityContractInteract.registeredToken(uuid);
  
        if (!registeredOnUCResponse ||
          !registeredOnUCResponse.isSuccess() ||
          (registeredOnUCResponse.data.erc20Address == '0x0000000000000000000000000000000000000000')) {
          return registrationStatus.returnResultPromise();
        }
  
        registrationStatus.setIsRegisteredOnUc(1);
        registrationStatus.setErc20Address(registeredOnUCResponse.data.erc20Address);
  
        // now checking to confirm if registration on VC took place
        const registeredOnVCResponse = await openSTValueContractInteract.utilityTokens(uuid);
  
        if (!registeredOnVCResponse ||
          !registeredOnVCResponse.isSuccess() ||
          (registeredOnVCResponse.data.symbol.length == 0)) {
          return registrationStatus.returnResultPromise();
        }
        registrationStatus.setIsRegisteredOnVc(1);
  
        return registrationStatus.returnResultPromise();
      } catch (err) {
        let errObj = responseHelper.error({
          internal_error_identifier: 's_ob_grs_3',
          api_error_identifier: 'something_went_wrong',
          error_config: basicHelper.fetchErrorConfig()
        });
  
        return Promise.resolve(errObj);
      }
    }