docs: async function () {
      const encodedABI = simpleTokenContractObj.methods.transfer(receiverAddress, bigNumAmount.toString(10)).encodeABI();
  
      const estimateGasObj = new EstimateGasKlass({
        contract_name: simpleTokenContractName,
        contract_address: oThis.contractAddress,
        chain: 'value',
        sender_address: senderAddress,
        method_name: 'transfer',
        method_arguments: [receiverAddress, bigNumAmount.toString(10)]
      });
  
      const estimateGasResponse = await estimateGasObj.perform()
        , gasToUse = estimateGasResponse.data.gas_to_use
      ;
  
      // set txParams for firing event
      const rawTxParams = {
        from: senderAddress, to: receiverAddress, value: bigNumAmount.toString(10),
        gasPrice: VC_GAS_PRICE, gas: gasToUse
      };
  
      // set params in notification data
      notificationData.message.payload.params.txParams = rawTxParams; // one time
  
      // set txParams for executing transaction
      const txParams = {
        from: senderAddress,
        to: oThis.contractAddress,
        data: encodedABI,
        gasPrice: VC_GAS_PRICE,
        gas: gasToUse
      };
  
      // Unlock account and send transaction
      return new Promise(function (onResolve, onReject) {
        const onReceipt = function (receipt) {
          // Publish event
          notificationData.message.kind = 'transaction_mined';
          openSTNotification.publishEvent.perform(notificationData);
  
          // send response
          if (basicHelper.isReturnTypeTxReceipt(returnType)) {
            return onResolve(responseHelper.successWithData({
              transaction_uuid: txUUID,
              transaction_hash: receipt.transactionHash,
              transaction_receipt: receipt
            }));
          }
        };
  
        web3Provider.eth.personal.unlockAccount(senderAddress, senderPassphrase)
          .then(function () {
            return web3Provider.eth.sendTransaction(txParams)
              .on('transactionHash', function (transactionHash) {
                // set transaction hash in notification data
                notificationData.message.payload.transaction_hash = transactionHash; // one time
                // Publish event
                notificationData.message.kind = 'transaction_initiated';
                openSTNotification.publishEvent.perform(notificationData);
  
                // send response
                if (basicHelper.isReturnTypeTxHash(returnType)) {
                  return onResolve(responseHelper.successWithData({
                    transaction_uuid: txUUID,
                    transaction_hash: transactionHash,
                    transaction_receipt: {}
                  }));
                }
              })
              .on('receipt', onReceipt)
          })
          .catch(async function (reason) {
            logger.error("ST :: Transaction failed.\n\t Reason:", reason);
  
            const onCatchError = function () {
              // set error data in notification data
              notificationData.message.payload.error_data = reason;
              // Publish event
              notificationData.message.kind = 'transaction_error';
              openSTNotification.publishEvent.perform(notificationData);
  
              // send response
              let errObj = responseHelper.error({
                internal_error_identifier: 'l_ci_st_transfer_6',
                api_error_identifier: 'transaction_failed',
                error_config: basicHelper.fetchErrorConfig()
              });
              return onResolve(errObj);
            };
  
            const isNotMinedInSomeBlocksError = reason.message.includes('not mined within');
            if (isNotMinedInSomeBlocksError) {
              // get receipt
              const res = await contractInteractHelper.getTransactionReceiptFromTrasactionHash(
                web3Provider,
                notificationData.message.payload.transaction_hash
              );
  
              if (res.isSuccess()) {
                onReceipt(res.data.receipt);
              } else {
                onCatchError();
              }
            } else {
              onCatchError();
            }
  
          });
  
      });
  
    }