@routerprotocol/chain-api/routerprotocol/routerchain/crosschain/query_pb_service.js

Router Chain API Query client with generated gRPC bindings.

// package: routerprotocol.routerchain.crosschain
// file: routerprotocol/routerchain/crosschain/query.proto

var routerprotocol_routerchain_crosschain_query_pb = require("../../../routerprotocol/routerchain/crosschain/query_pb");
var grpc = require("@improbable-eng/grpc-web").grpc;

var Query = (function () {
  function Query() {}
  Query.serviceName = "routerprotocol.routerchain.crosschain.Query";
  return Query;
}());

Query.Params = {
  methodName: "Params",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryParamsRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryParamsResponse
};

Query.CrosschainRequest = {
  methodName: "CrosschainRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCrosschainRequestResponse
};

Query.CrosschainRequestAll = {
  methodName: "CrosschainRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCrosschainRequestResponse
};

Query.CrosschainRequestConfirm = {
  methodName: "CrosschainRequestConfirm",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCrosschainRequestConfirmRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCrosschainRequestConfirmResponse
};

Query.CrosschainRequestConfirmAll = {
  methodName: "CrosschainRequestConfirmAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCrosschainRequestConfirmRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCrosschainRequestConfirmResponse
};

Query.CrosschainAckRequest = {
  methodName: "CrosschainAckRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCrosschainAckRequestResponse
};

Query.CrosschainAckRequestAll = {
  methodName: "CrosschainAckRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCrosschainAckRequestResponse
};

Query.CrosschainAckRequestConfirm = {
  methodName: "CrosschainAckRequestConfirm",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCrosschainAckRequestConfirmRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCrosschainAckRequestConfirmResponse
};

Query.CrosschainAckRequestConfirmAll = {
  methodName: "CrosschainAckRequestConfirmAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCrosschainAckRequestConfirmRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCrosschainAckRequestConfirmResponse
};

Query.CrosschainAckReceipt = {
  methodName: "CrosschainAckReceipt",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCrosschainAckReceiptRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCrosschainAckReceiptResponse
};

Query.CrosschainAckReceiptAll = {
  methodName: "CrosschainAckReceiptAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCrosschainAckReceiptRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCrosschainAckReceiptResponse
};

Query.BlockedCrosschainRequest = {
  methodName: "BlockedCrosschainRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetBlockedCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetBlockedCrosschainRequestResponse
};

Query.BlockedCrosschainRequestAll = {
  methodName: "BlockedCrosschainRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllBlockedCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllBlockedCrosschainRequestResponse
};

Query.BlockedCrosschainAckRequest = {
  methodName: "BlockedCrosschainAckRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetBlockedCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetBlockedCrosschainAckRequestResponse
};

Query.BlockedCrosschainAckRequestAll = {
  methodName: "BlockedCrosschainAckRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllBlockedCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllBlockedCrosschainAckRequestResponse
};

Query.IBCConfig = {
  methodName: "IBCConfig",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetIBCConfigRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetIBCConfigResponse
};

Query.ExpiredCrosschainRequest = {
  methodName: "ExpiredCrosschainRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetExpiredCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetExpiredCrosschainRequestResponse
};

Query.ExpiredCrosschainRequestAll = {
  methodName: "ExpiredCrosschainRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllExpiredCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllExpiredCrosschainRequestResponse
};

Query.ExpiredCrosschainAckRequest = {
  methodName: "ExpiredCrosschainAckRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetExpiredCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetExpiredCrosschainAckRequestResponse
};

Query.ExpiredCrosschainAckRequestAll = {
  methodName: "ExpiredCrosschainAckRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllExpiredCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllExpiredCrosschainAckRequestResponse
};

Query.ValidCrosschainRequest = {
  methodName: "ValidCrosschainRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetValidCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetValidCrosschainRequestResponse
};

Query.ValidCrosschainRequestAll = {
  methodName: "ValidCrosschainRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllValidCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllValidCrosschainRequestResponse
};

Query.NativeTransferedCrosschainRequest = {
  methodName: "NativeTransferedCrosschainRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetNativeTransferedCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetNativeTransferedCrosschainRequestResponse
};

Query.NativeTransferedCrosschainRequestAll = {
  methodName: "NativeTransferedCrosschainRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllNativeTransferedCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllNativeTransferedCrosschainRequestResponse
};

Query.ReadyToExecuteCrosschainRequest = {
  methodName: "ReadyToExecuteCrosschainRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetReadyToExecuteCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetReadyToExecuteCrosschainRequestResponse
};

Query.ReadyToExecuteCrosschainRequestAll = {
  methodName: "ReadyToExecuteCrosschainRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllReadyToExecuteCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllReadyToExecuteCrosschainRequestResponse
};

Query.ExecutedCrosschainRequest = {
  methodName: "ExecutedCrosschainRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetExecutedCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetExecutedCrosschainRequestResponse
};

Query.ExecutedCrosschainRequestAll = {
  methodName: "ExecutedCrosschainRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllExecutedCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllExecutedCrosschainRequestResponse
};

Query.FeesSettledCrosschainRequest = {
  methodName: "FeesSettledCrosschainRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetFeesSettledCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetFeesSettledCrosschainRequestResponse
};

Query.FeesSettledCrosschainRequestAll = {
  methodName: "FeesSettledCrosschainRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllFeesSettledCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllFeesSettledCrosschainRequestResponse
};

Query.CompletedCrosschainRequest = {
  methodName: "CompletedCrosschainRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCompletedCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCompletedCrosschainRequestResponse
};

Query.CompletedCrosschainRequestAll = {
  methodName: "CompletedCrosschainRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCompletedCrosschainRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCompletedCrosschainRequestResponse
};

Query.ValidCrosschainAckRequest = {
  methodName: "ValidCrosschainAckRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetValidCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetValidCrosschainAckRequestResponse
};

Query.ValidCrosschainAckRequestAll = {
  methodName: "ValidCrosschainAckRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllValidCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllValidCrosschainAckRequestResponse
};

Query.ReadyToExecuteCrosschainAckRequest = {
  methodName: "ReadyToExecuteCrosschainAckRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetReadyToExecuteCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetReadyToExecuteCrosschainAckRequestResponse
};

Query.ReadyToExecuteCrosschainAckRequestAll = {
  methodName: "ReadyToExecuteCrosschainAckRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllReadyToExecuteCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllReadyToExecuteCrosschainAckRequestResponse
};

Query.ExecutedCrosschainAckRequest = {
  methodName: "ExecutedCrosschainAckRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetExecutedCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetExecutedCrosschainAckRequestResponse
};

Query.ExecutedCrosschainAckRequestAll = {
  methodName: "ExecutedCrosschainAckRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllExecutedCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllExecutedCrosschainAckRequestResponse
};

Query.FeesSettledCrosschainAckRequest = {
  methodName: "FeesSettledCrosschainAckRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetFeesSettledCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetFeesSettledCrosschainAckRequestResponse
};

Query.FeesSettledCrosschainAckRequestAll = {
  methodName: "FeesSettledCrosschainAckRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllFeesSettledCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllFeesSettledCrosschainAckRequestResponse
};

Query.CompletedCrosschainAckRequest = {
  methodName: "CompletedCrosschainAckRequest",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCompletedCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryGetCompletedCrosschainAckRequestResponse
};

Query.CompletedCrosschainAckRequestAll = {
  methodName: "CompletedCrosschainAckRequestAll",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCompletedCrosschainAckRequestRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryAllCompletedCrosschainAckRequestResponse
};

Query.ReadyToExecuteCrosschainAckRequestByWorkflow = {
  methodName: "ReadyToExecuteCrosschainAckRequestByWorkflow",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryReadyToExecuteCrosschainAckRequestByWorkflowRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryReadyToExecuteCrosschainAckRequestByWorkflowResponse
};

Query.ReadyToExecuteCrosschainAckRequestByWorkflowAndRelayer = {
  methodName: "ReadyToExecuteCrosschainAckRequestByWorkflowAndRelayer",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryReadyToExecuteCrosschainAckRequestByWorkflowAndRelayerRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryReadyToExecuteCrosschainAckRequestByWorkflowAndRelayerResponse
};

Query.ReadyToExecuteCrosschainRequestByWorkflow = {
  methodName: "ReadyToExecuteCrosschainRequestByWorkflow",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryReadyToExecuteCrosschainRequestByWorkflowRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryReadyToExecuteCrosschainRequestByWorkflowResponse
};

Query.ReadyToExecuteCrosschainRequestByWorkflowAndRelayer = {
  methodName: "ReadyToExecuteCrosschainRequestByWorkflowAndRelayer",
  service: Query,
  requestStream: false,
  responseStream: false,
  requestType: routerprotocol_routerchain_crosschain_query_pb.QueryReadyToExecuteCrosschainRequestByWorkflowAndRelayerRequest,
  responseType: routerprotocol_routerchain_crosschain_query_pb.QueryReadyToExecuteCrosschainRequestByWorkflowAndRelayerResponse
};

exports.Query = Query;

function QueryClient(serviceHost, options) {
  this.serviceHost = serviceHost;
  this.options = options || {};
}

QueryClient.prototype.params = function params(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.Params, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.crosschainRequest = function crosschainRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.CrosschainRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.crosschainRequestAll = function crosschainRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.CrosschainRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.crosschainRequestConfirm = function crosschainRequestConfirm(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.CrosschainRequestConfirm, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.crosschainRequestConfirmAll = function crosschainRequestConfirmAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.CrosschainRequestConfirmAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.crosschainAckRequest = function crosschainAckRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.CrosschainAckRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.crosschainAckRequestAll = function crosschainAckRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.CrosschainAckRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.crosschainAckRequestConfirm = function crosschainAckRequestConfirm(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.CrosschainAckRequestConfirm, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.crosschainAckRequestConfirmAll = function crosschainAckRequestConfirmAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.CrosschainAckRequestConfirmAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.crosschainAckReceipt = function crosschainAckReceipt(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.CrosschainAckReceipt, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.crosschainAckReceiptAll = function crosschainAckReceiptAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.CrosschainAckReceiptAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.blockedCrosschainRequest = function blockedCrosschainRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.BlockedCrosschainRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.blockedCrosschainRequestAll = function blockedCrosschainRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.BlockedCrosschainRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.blockedCrosschainAckRequest = function blockedCrosschainAckRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.BlockedCrosschainAckRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.blockedCrosschainAckRequestAll = function blockedCrosschainAckRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.BlockedCrosschainAckRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.iBCConfig = function iBCConfig(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.IBCConfig, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.expiredCrosschainRequest = function expiredCrosschainRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ExpiredCrosschainRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.expiredCrosschainRequestAll = function expiredCrosschainRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ExpiredCrosschainRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.expiredCrosschainAckRequest = function expiredCrosschainAckRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ExpiredCrosschainAckRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.expiredCrosschainAckRequestAll = function expiredCrosschainAckRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ExpiredCrosschainAckRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.validCrosschainRequest = function validCrosschainRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ValidCrosschainRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.validCrosschainRequestAll = function validCrosschainRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ValidCrosschainRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.nativeTransferedCrosschainRequest = function nativeTransferedCrosschainRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.NativeTransferedCrosschainRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.nativeTransferedCrosschainRequestAll = function nativeTransferedCrosschainRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.NativeTransferedCrosschainRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.readyToExecuteCrosschainRequest = function readyToExecuteCrosschainRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ReadyToExecuteCrosschainRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.readyToExecuteCrosschainRequestAll = function readyToExecuteCrosschainRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ReadyToExecuteCrosschainRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.executedCrosschainRequest = function executedCrosschainRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ExecutedCrosschainRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.executedCrosschainRequestAll = function executedCrosschainRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ExecutedCrosschainRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.feesSettledCrosschainRequest = function feesSettledCrosschainRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.FeesSettledCrosschainRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.feesSettledCrosschainRequestAll = function feesSettledCrosschainRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.FeesSettledCrosschainRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.completedCrosschainRequest = function completedCrosschainRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.CompletedCrosschainRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.completedCrosschainRequestAll = function completedCrosschainRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.CompletedCrosschainRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.validCrosschainAckRequest = function validCrosschainAckRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ValidCrosschainAckRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.validCrosschainAckRequestAll = function validCrosschainAckRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ValidCrosschainAckRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.readyToExecuteCrosschainAckRequest = function readyToExecuteCrosschainAckRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ReadyToExecuteCrosschainAckRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.readyToExecuteCrosschainAckRequestAll = function readyToExecuteCrosschainAckRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ReadyToExecuteCrosschainAckRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.executedCrosschainAckRequest = function executedCrosschainAckRequest(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ExecutedCrosschainAckRequest, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = new Error(response.statusMessage);
          err.code = response.status;
          err.metadata = response.trailers;
          callback(err, null);
        } else {
          callback(null, response.message);
        }
      }
    }
  });
  return {
    cancel: function () {
      callback = null;
      client.close();
    }
  };
};

QueryClient.prototype.executedCrosschainAckRequestAll = function executedCrosschainAckRequestAll(requestMessage, metadata, callback) {
  if (arguments.length === 2) {
    callback = arguments[1];
  }
  var client = grpc.unary(Query.ExecutedCrosschainAckRequestAll, {
    request: requestMessage,
    host: this.serviceHost,
    metadata: metadata,
    transport: this.options.transport,
    debug: this.options.debug,
    onEnd: function (response) {
      if (callback) {
        if (response.status !== grpc.Code.OK) {
          var err = n