validateTransactionV2(context, transactions, callback) {
    let schema = context.openapi,
      options = context.computedOptions,
      concreteUtils = context.concreteUtils,
      componentsAndPaths = { concreteUtils },
      schemaCache = context.schemaFakerCache,
      matchedEndpoints = [];

    context.schemaCache = context.schemaCache || {};
    context.schemaFakerCache = context.schemaFakerCache || {};
    Object.assign(componentsAndPaths, concreteUtils.getRequiredData(schema));

    // create and sanitize basic spec
    schema.servers = _.isEmpty(schema.servers) ? [{ url: '/' }] : schema.servers;
    schema.securityDefs = _.get(schema, 'components.securitySchemes', {});
    schema.baseUrl = _.get(schema, 'servers.0.url', '{{baseURL}}');
    schema.baseUrlVariables = _.get(schema, 'servers.0.variables');

    // Fix {scheme} and {path} vars in the URL to :scheme and :path
    schema.baseUrl = fixPathVariablesInUrl(schema.baseUrl);

    // check validity of transactions
    try {
      // add Ajv options to support validation of OpenAPI schema.
      // For more details see https://ajv.js.org/#options
      let ajv = new Ajv({
          allErrors: true,
          strict: false
        }),
        validate,
        res;
      addFormats(ajv);
      validate = ajv.compile(transactionSchema);
      res = validate(transactions);

      if (!res) {
        return callback(new OpenApiErr('Invalid syntax provided for requestList', validate.errors));
      }
    }
    catch (e) {
      return callback(new OpenApiErr('Invalid syntax provided for requestList', e));
    }

    return async.map(transactions, (transaction, callback) => {
      return validateTransaction(context, transaction, {
        schema, options, componentsAndPaths, schemaCache, matchedEndpoints
      }, callback);
    }, (err, result) => {
      var retVal;

      if (err) {
        return callback(err);
      }

      retVal = {
        requests: _.keyBy(result, 'requestId'),
        missingEndpoints: getMissingSchemaEndpoints(context, schema, matchedEndpoints,
          componentsAndPaths, options, schemaCache)
      };

      return callback(null, retVal);
    });
  }
@description Takes in a request collection (transaction object) and validates it against
corresponding definition matching endpoint

@param {Object} context - Required context from related SchemaPack function
@param {Array} transactions - Transactions to be validated
@param {*} callback return
@returns {boolean} validation