How to use the verror function in verror

if (!this.silent) {
          console.info(`Uploaded ${sourceMap} to Rollbar`); // eslint-disable-line no-console
        }
        return cb();
      }

      const errMessage = `failed to upload ${sourceMap} to Rollbar`;
      if (err) {
        return cb(new VError(err, errMessage));
      }

      try {
        const { message } = JSON.parse(body);
        return cb(new Error(message ? `${errMessage}: ${message}` : errMessage));
      } catch (parseErr) {
        return cb(new VError(parseErr, errMessage));
      }
    });

return async (dispatch, getState) => {
            const storedTracks = getStoredTracks(getState(), lick.id);
            let tracks;

            try {
                // Handle all new tracks submitted in form
                tracks = await Promise.all(
                    lick.tracks.map(track => handleTrack(track))
                );
            } catch (error) {
                throw new VError(
                    error,
                    'Unable to create action %s with lick %s',
                    LICK_UPDATE,
                    JSON.stringify(lick)
                );
            }

            try {
                // Delete all stored tracks which haven't been submitted
                const ids = tracks.map(track => track.id);
                const toBeDeletedTracks = storedTracks.filter(
                    track => !ids.includes(track.id)
                );
                await Promise.all(
                    toBeDeletedTracks.map(track => deleteTrack(track.id))
                );

.then(content => {
            if (BRIDGE_ERROR_REXP.test(content)) {
                const errMsg = content.replace(BRIDGE_ERROR_REXP, "");
                throw new VError({ info: { code: ERROR_CODE_DECRYPT_ERROR } }, errMsg);
            }
            return content;
        })
        .then(decryptedBase64 => new Buffer(decryptedBase64, "base64").toString("utf8"));

chrome.runtime.sendMessage({ type: "unlock-archive", sourceID, masterPassword }, response => {
            const { ok, error, hush = false } = response;
            if (ok) {
                return resolve();
            }
            return reject(
                new VError(
                    {
                        info: { hush }
                    },
                    `Unlocking archive source (${sourceID}) failed: ${error}`
                )
            );
        });
    });

const removeFilter = (state, filter) => {
    try {
        validateFilter(filter);
    } catch (error) {
        throw new VError(
            error,
            'Unable to reduce %s with filter "%s"',
            SEARCH_REMOVE_FILTER,
            JSON.stringify(filter)
        );
    }

    const filters = [...state.filters];
    const index = filters.findIndex(storedFilter =>
        isEqual(storedFilter, filter)
    );
    if (index > -1) {
        filters.splice(index, 1);
    }
    return {
        ...state,

awsS3.putObject(params, (err, result) => {
      if (err) {
        return reject(new WError(err, 'S3'))
      }
      resolve()
    })
  })

}, (err, stdout, stderr) => {
        logger.trace({ stdout, stderr });

        if (err) {
            defer.reject(new VError({
                cause: err,
                info: {
                    stdout,
                    stderr
                }
            }));
        } else {
            defer.resolve(stdout);
        }
    });
    return defer.promise;

const validateFilter = filter => {
    const schema = Joi.object().keys({
        type: Joi.string()
            .valid(TYPE_ARTIST, TYPE_TAG)
            .required(),
        value: Joi.string().required()
    });

    const { error } = Joi.validate(filter, schema, {
        abortEarly: false,
        convert: false
    });
    if (error) {
        throw new VError(error, 'Invalid filter');
    }
};

const validateMode = mode => {
    const validModes = [LICK_MODE_EDIT, LICK_MODE_VIEW];
    if (!validModes.includes(mode)) {
        throw new VError(
            'Invalid mode %s, should be one of %s',
            mode,
            validModes.join(', ')
        );
    }
};

const wrapLoadError = (error) => {
        throw new VError(error, 'Unable to load state');
    }