docs: async function (senderAddr, senderPassphrase, recipientAddr, amountInWei, options) {
  
      options = options || {};
      const oThis = this
        , txUUID = uuid.v4()
        , tag = options.tag
        , returnType = basicHelper.getReturnType(options.returnType)
        , notificationData = {
          topics: ['transfer.ether'],
          publisher: 'OST',
          message: {
            kind: '', // populate later: with every stage
            payload: {
              contract_name: '',
              contract_address: '',
              erc20_contract_address: '',
              method: 'transfer',
              params: {args: [], txParams: {}}, // populate later: when Tx params created
              transaction_hash: '', // populate later: when Tx submitted
              chain_id: web3Provider.chainId,
              chain_kind: web3Provider.chainKind,
              uuid: txUUID,
              tag: tag,
              error_data: {} // populate later: when error received
            }
          }
        }
      ;
  
      //Validate addresses
      if (!basicHelper.isAddressValid(senderAddr)) {
        let errObj = responseHelper.error({
          internal_error_identifier: 'l_ci_eth_transfer_1',
          api_error_identifier: 'invalid_address',
          error_config: basicHelper.fetchErrorConfig()
        });
        return Promise.resolve(errObj);
      }
      if (!basicHelper.isAddressValid(recipientAddr)) {
        let errObj = responseHelper.error({
          internal_error_identifier: 'l_ci_eth_transfer_2',
          api_error_identifier: 'invalid_address',
          error_config: basicHelper.fetchErrorConfig()
        });
        return Promise.resolve(errObj);
      }
      if (senderAddr.equalsIgnoreCase(recipientAddr)) {
        logger.error("eth :: transfer :: sender & recipient addresses are same");
  
        let errObj = responseHelper.error({
          internal_error_identifier: 'l_ci_eth_transfer_3',
          api_error_identifier: 'sender_and_recipient_same',
          error_config: basicHelper.fetchErrorConfig()
        });
        return Promise.resolve(errObj);
      }
      if (!basicHelper.isNonZeroWeiValid(amountInWei)) {
        let errObj = responseHelper.error({
          internal_error_identifier: 'l_ci_eth_transfer_4',
          api_error_identifier: 'invalid_amount',
          error_config: basicHelper.fetchErrorConfig()
        });
        return Promise.resolve(errObj);
      }
      if (!basicHelper.isTagValid(tag)) {
        let errObj = responseHelper.error({
          internal_error_identifier: 'l_ci_eth_transfer_5',
          api_error_identifier: 'invalid_transaction_tag',
          error_config: basicHelper.fetchErrorConfig()
        });
        return Promise.resolve(errObj);
      }
  
      // Convert amount in BigNumber
      var bigNumAmount = basicHelper.convertToBigNumber(amountInWei);
  
      // Validate sender balance
      const senderBalanceResponse = await oThis._validateBalance(senderAddr, bigNumAmount);
      if (senderBalanceResponse.isFailure()) {
        return Promise.resolve(senderBalanceResponse);
      }
  
      // Perform transfer async
      const asyncTransfer = function () {
  
        // set txParams for firing event
        const txParams = {
          from: senderAddr,
          to: recipientAddr,
          value: bigNumAmount.toString(10),
          gasPrice: VC_GAS_PRICE,
          gas: 25000
        };
  
        // set params in notification data
        notificationData.message.payload.params.txParams = txParams; // one time
  
        // 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(senderAddr, 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("eth :: 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_eth_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();
              }
            });
        });
  
      };
  
      // Perform transaction as requested
      if (basicHelper.isReturnTypeUUID(returnType)) {
        asyncTransfer();
        return Promise.resolve(responseHelper.successWithData({
          transaction_uuid: txUUID,
          transaction_hash: "",
          transaction_receipt: {}
        }));
      } else {
        return asyncTransfer();
      }
  
    }