github.com/hyperledger/burrow@v0.34.5-0.20220512172541-77f09336001d/js/proto/rpcquery_grpc_pb.js (about)

     1  // GENERATED CODE -- DO NOT EDIT!
     2  
     3  'use strict';
     4  var grpc = require('@grpc/grpc-js');
     5  var rpcquery_pb = require('./rpcquery_pb.js');
     6  var gogoproto_gogo_pb = require('./gogoproto/gogo_pb.js');
     7  var tendermint_types_types_pb = require('./tendermint/types/types_pb.js');
     8  var names_pb = require('./names_pb.js');
     9  var acm_pb = require('./acm_pb.js');
    10  var validator_pb = require('./validator_pb.js');
    11  var registry_pb = require('./registry_pb.js');
    12  var rpc_pb = require('./rpc_pb.js');
    13  var payload_pb = require('./payload_pb.js');
    14  
    15  function serialize_acm_Account(arg) {
    16    if (!(arg instanceof acm_pb.Account)) {
    17      throw new Error('Expected argument of type acm.Account');
    18    }
    19    return Buffer.from(arg.serializeBinary());
    20  }
    21  
    22  function deserialize_acm_Account(buffer_arg) {
    23    return acm_pb.Account.deserializeBinary(new Uint8Array(buffer_arg));
    24  }
    25  
    26  function serialize_names_Entry(arg) {
    27    if (!(arg instanceof names_pb.Entry)) {
    28      throw new Error('Expected argument of type names.Entry');
    29    }
    30    return Buffer.from(arg.serializeBinary());
    31  }
    32  
    33  function deserialize_names_Entry(buffer_arg) {
    34    return names_pb.Entry.deserializeBinary(new Uint8Array(buffer_arg));
    35  }
    36  
    37  function serialize_payload_Ballot(arg) {
    38    if (!(arg instanceof payload_pb.Ballot)) {
    39      throw new Error('Expected argument of type payload.Ballot');
    40    }
    41    return Buffer.from(arg.serializeBinary());
    42  }
    43  
    44  function deserialize_payload_Ballot(buffer_arg) {
    45    return payload_pb.Ballot.deserializeBinary(new Uint8Array(buffer_arg));
    46  }
    47  
    48  function serialize_rpc_ResultStatus(arg) {
    49    if (!(arg instanceof rpc_pb.ResultStatus)) {
    50      throw new Error('Expected argument of type rpc.ResultStatus');
    51    }
    52    return Buffer.from(arg.serializeBinary());
    53  }
    54  
    55  function deserialize_rpc_ResultStatus(buffer_arg) {
    56    return rpc_pb.ResultStatus.deserializeBinary(new Uint8Array(buffer_arg));
    57  }
    58  
    59  function serialize_rpcquery_GetAccountParam(arg) {
    60    if (!(arg instanceof rpcquery_pb.GetAccountParam)) {
    61      throw new Error('Expected argument of type rpcquery.GetAccountParam');
    62    }
    63    return Buffer.from(arg.serializeBinary());
    64  }
    65  
    66  function deserialize_rpcquery_GetAccountParam(buffer_arg) {
    67    return rpcquery_pb.GetAccountParam.deserializeBinary(new Uint8Array(buffer_arg));
    68  }
    69  
    70  function serialize_rpcquery_GetBlockParam(arg) {
    71    if (!(arg instanceof rpcquery_pb.GetBlockParam)) {
    72      throw new Error('Expected argument of type rpcquery.GetBlockParam');
    73    }
    74    return Buffer.from(arg.serializeBinary());
    75  }
    76  
    77  function deserialize_rpcquery_GetBlockParam(buffer_arg) {
    78    return rpcquery_pb.GetBlockParam.deserializeBinary(new Uint8Array(buffer_arg));
    79  }
    80  
    81  function serialize_rpcquery_GetMetadataParam(arg) {
    82    if (!(arg instanceof rpcquery_pb.GetMetadataParam)) {
    83      throw new Error('Expected argument of type rpcquery.GetMetadataParam');
    84    }
    85    return Buffer.from(arg.serializeBinary());
    86  }
    87  
    88  function deserialize_rpcquery_GetMetadataParam(buffer_arg) {
    89    return rpcquery_pb.GetMetadataParam.deserializeBinary(new Uint8Array(buffer_arg));
    90  }
    91  
    92  function serialize_rpcquery_GetNameParam(arg) {
    93    if (!(arg instanceof rpcquery_pb.GetNameParam)) {
    94      throw new Error('Expected argument of type rpcquery.GetNameParam');
    95    }
    96    return Buffer.from(arg.serializeBinary());
    97  }
    98  
    99  function deserialize_rpcquery_GetNameParam(buffer_arg) {
   100    return rpcquery_pb.GetNameParam.deserializeBinary(new Uint8Array(buffer_arg));
   101  }
   102  
   103  function serialize_rpcquery_GetNetworkRegistryParam(arg) {
   104    if (!(arg instanceof rpcquery_pb.GetNetworkRegistryParam)) {
   105      throw new Error('Expected argument of type rpcquery.GetNetworkRegistryParam');
   106    }
   107    return Buffer.from(arg.serializeBinary());
   108  }
   109  
   110  function deserialize_rpcquery_GetNetworkRegistryParam(buffer_arg) {
   111    return rpcquery_pb.GetNetworkRegistryParam.deserializeBinary(new Uint8Array(buffer_arg));
   112  }
   113  
   114  function serialize_rpcquery_GetProposalParam(arg) {
   115    if (!(arg instanceof rpcquery_pb.GetProposalParam)) {
   116      throw new Error('Expected argument of type rpcquery.GetProposalParam');
   117    }
   118    return Buffer.from(arg.serializeBinary());
   119  }
   120  
   121  function deserialize_rpcquery_GetProposalParam(buffer_arg) {
   122    return rpcquery_pb.GetProposalParam.deserializeBinary(new Uint8Array(buffer_arg));
   123  }
   124  
   125  function serialize_rpcquery_GetStatsParam(arg) {
   126    if (!(arg instanceof rpcquery_pb.GetStatsParam)) {
   127      throw new Error('Expected argument of type rpcquery.GetStatsParam');
   128    }
   129    return Buffer.from(arg.serializeBinary());
   130  }
   131  
   132  function deserialize_rpcquery_GetStatsParam(buffer_arg) {
   133    return rpcquery_pb.GetStatsParam.deserializeBinary(new Uint8Array(buffer_arg));
   134  }
   135  
   136  function serialize_rpcquery_GetStorageParam(arg) {
   137    if (!(arg instanceof rpcquery_pb.GetStorageParam)) {
   138      throw new Error('Expected argument of type rpcquery.GetStorageParam');
   139    }
   140    return Buffer.from(arg.serializeBinary());
   141  }
   142  
   143  function deserialize_rpcquery_GetStorageParam(buffer_arg) {
   144    return rpcquery_pb.GetStorageParam.deserializeBinary(new Uint8Array(buffer_arg));
   145  }
   146  
   147  function serialize_rpcquery_GetValidatorSetHistoryParam(arg) {
   148    if (!(arg instanceof rpcquery_pb.GetValidatorSetHistoryParam)) {
   149      throw new Error('Expected argument of type rpcquery.GetValidatorSetHistoryParam');
   150    }
   151    return Buffer.from(arg.serializeBinary());
   152  }
   153  
   154  function deserialize_rpcquery_GetValidatorSetHistoryParam(buffer_arg) {
   155    return rpcquery_pb.GetValidatorSetHistoryParam.deserializeBinary(new Uint8Array(buffer_arg));
   156  }
   157  
   158  function serialize_rpcquery_GetValidatorSetParam(arg) {
   159    if (!(arg instanceof rpcquery_pb.GetValidatorSetParam)) {
   160      throw new Error('Expected argument of type rpcquery.GetValidatorSetParam');
   161    }
   162    return Buffer.from(arg.serializeBinary());
   163  }
   164  
   165  function deserialize_rpcquery_GetValidatorSetParam(buffer_arg) {
   166    return rpcquery_pb.GetValidatorSetParam.deserializeBinary(new Uint8Array(buffer_arg));
   167  }
   168  
   169  function serialize_rpcquery_ListAccountsParam(arg) {
   170    if (!(arg instanceof rpcquery_pb.ListAccountsParam)) {
   171      throw new Error('Expected argument of type rpcquery.ListAccountsParam');
   172    }
   173    return Buffer.from(arg.serializeBinary());
   174  }
   175  
   176  function deserialize_rpcquery_ListAccountsParam(buffer_arg) {
   177    return rpcquery_pb.ListAccountsParam.deserializeBinary(new Uint8Array(buffer_arg));
   178  }
   179  
   180  function serialize_rpcquery_ListNamesParam(arg) {
   181    if (!(arg instanceof rpcquery_pb.ListNamesParam)) {
   182      throw new Error('Expected argument of type rpcquery.ListNamesParam');
   183    }
   184    return Buffer.from(arg.serializeBinary());
   185  }
   186  
   187  function deserialize_rpcquery_ListNamesParam(buffer_arg) {
   188    return rpcquery_pb.ListNamesParam.deserializeBinary(new Uint8Array(buffer_arg));
   189  }
   190  
   191  function serialize_rpcquery_ListProposalsParam(arg) {
   192    if (!(arg instanceof rpcquery_pb.ListProposalsParam)) {
   193      throw new Error('Expected argument of type rpcquery.ListProposalsParam');
   194    }
   195    return Buffer.from(arg.serializeBinary());
   196  }
   197  
   198  function deserialize_rpcquery_ListProposalsParam(buffer_arg) {
   199    return rpcquery_pb.ListProposalsParam.deserializeBinary(new Uint8Array(buffer_arg));
   200  }
   201  
   202  function serialize_rpcquery_MetadataResult(arg) {
   203    if (!(arg instanceof rpcquery_pb.MetadataResult)) {
   204      throw new Error('Expected argument of type rpcquery.MetadataResult');
   205    }
   206    return Buffer.from(arg.serializeBinary());
   207  }
   208  
   209  function deserialize_rpcquery_MetadataResult(buffer_arg) {
   210    return rpcquery_pb.MetadataResult.deserializeBinary(new Uint8Array(buffer_arg));
   211  }
   212  
   213  function serialize_rpcquery_NetworkRegistry(arg) {
   214    if (!(arg instanceof rpcquery_pb.NetworkRegistry)) {
   215      throw new Error('Expected argument of type rpcquery.NetworkRegistry');
   216    }
   217    return Buffer.from(arg.serializeBinary());
   218  }
   219  
   220  function deserialize_rpcquery_NetworkRegistry(buffer_arg) {
   221    return rpcquery_pb.NetworkRegistry.deserializeBinary(new Uint8Array(buffer_arg));
   222  }
   223  
   224  function serialize_rpcquery_ProposalResult(arg) {
   225    if (!(arg instanceof rpcquery_pb.ProposalResult)) {
   226      throw new Error('Expected argument of type rpcquery.ProposalResult');
   227    }
   228    return Buffer.from(arg.serializeBinary());
   229  }
   230  
   231  function deserialize_rpcquery_ProposalResult(buffer_arg) {
   232    return rpcquery_pb.ProposalResult.deserializeBinary(new Uint8Array(buffer_arg));
   233  }
   234  
   235  function serialize_rpcquery_Stats(arg) {
   236    if (!(arg instanceof rpcquery_pb.Stats)) {
   237      throw new Error('Expected argument of type rpcquery.Stats');
   238    }
   239    return Buffer.from(arg.serializeBinary());
   240  }
   241  
   242  function deserialize_rpcquery_Stats(buffer_arg) {
   243    return rpcquery_pb.Stats.deserializeBinary(new Uint8Array(buffer_arg));
   244  }
   245  
   246  function serialize_rpcquery_StatusParam(arg) {
   247    if (!(arg instanceof rpcquery_pb.StatusParam)) {
   248      throw new Error('Expected argument of type rpcquery.StatusParam');
   249    }
   250    return Buffer.from(arg.serializeBinary());
   251  }
   252  
   253  function deserialize_rpcquery_StatusParam(buffer_arg) {
   254    return rpcquery_pb.StatusParam.deserializeBinary(new Uint8Array(buffer_arg));
   255  }
   256  
   257  function serialize_rpcquery_StorageValue(arg) {
   258    if (!(arg instanceof rpcquery_pb.StorageValue)) {
   259      throw new Error('Expected argument of type rpcquery.StorageValue');
   260    }
   261    return Buffer.from(arg.serializeBinary());
   262  }
   263  
   264  function deserialize_rpcquery_StorageValue(buffer_arg) {
   265    return rpcquery_pb.StorageValue.deserializeBinary(new Uint8Array(buffer_arg));
   266  }
   267  
   268  function serialize_rpcquery_ValidatorSet(arg) {
   269    if (!(arg instanceof rpcquery_pb.ValidatorSet)) {
   270      throw new Error('Expected argument of type rpcquery.ValidatorSet');
   271    }
   272    return Buffer.from(arg.serializeBinary());
   273  }
   274  
   275  function deserialize_rpcquery_ValidatorSet(buffer_arg) {
   276    return rpcquery_pb.ValidatorSet.deserializeBinary(new Uint8Array(buffer_arg));
   277  }
   278  
   279  function serialize_rpcquery_ValidatorSetHistory(arg) {
   280    if (!(arg instanceof rpcquery_pb.ValidatorSetHistory)) {
   281      throw new Error('Expected argument of type rpcquery.ValidatorSetHistory');
   282    }
   283    return Buffer.from(arg.serializeBinary());
   284  }
   285  
   286  function deserialize_rpcquery_ValidatorSetHistory(buffer_arg) {
   287    return rpcquery_pb.ValidatorSetHistory.deserializeBinary(new Uint8Array(buffer_arg));
   288  }
   289  
   290  function serialize_tendermint_types_Header(arg) {
   291    if (!(arg instanceof tendermint_types_types_pb.Header)) {
   292      throw new Error('Expected argument of type tendermint.types.Header');
   293    }
   294    return Buffer.from(arg.serializeBinary());
   295  }
   296  
   297  function deserialize_tendermint_types_Header(buffer_arg) {
   298    return tendermint_types_types_pb.Header.deserializeBinary(new Uint8Array(buffer_arg));
   299  }
   300  
   301  
   302  var QueryService = exports.QueryService = {
   303    status: {
   304      path: '/rpcquery.Query/Status',
   305      requestStream: false,
   306      responseStream: false,
   307      requestType: rpcquery_pb.StatusParam,
   308      responseType: rpc_pb.ResultStatus,
   309      requestSerialize: serialize_rpcquery_StatusParam,
   310      requestDeserialize: deserialize_rpcquery_StatusParam,
   311      responseSerialize: serialize_rpc_ResultStatus,
   312      responseDeserialize: deserialize_rpc_ResultStatus,
   313    },
   314    getAccount: {
   315      path: '/rpcquery.Query/GetAccount',
   316      requestStream: false,
   317      responseStream: false,
   318      requestType: rpcquery_pb.GetAccountParam,
   319      responseType: acm_pb.Account,
   320      requestSerialize: serialize_rpcquery_GetAccountParam,
   321      requestDeserialize: deserialize_rpcquery_GetAccountParam,
   322      responseSerialize: serialize_acm_Account,
   323      responseDeserialize: deserialize_acm_Account,
   324    },
   325    getMetadata: {
   326      path: '/rpcquery.Query/GetMetadata',
   327      requestStream: false,
   328      responseStream: false,
   329      requestType: rpcquery_pb.GetMetadataParam,
   330      responseType: rpcquery_pb.MetadataResult,
   331      requestSerialize: serialize_rpcquery_GetMetadataParam,
   332      requestDeserialize: deserialize_rpcquery_GetMetadataParam,
   333      responseSerialize: serialize_rpcquery_MetadataResult,
   334      responseDeserialize: deserialize_rpcquery_MetadataResult,
   335    },
   336    getStorage: {
   337      path: '/rpcquery.Query/GetStorage',
   338      requestStream: false,
   339      responseStream: false,
   340      requestType: rpcquery_pb.GetStorageParam,
   341      responseType: rpcquery_pb.StorageValue,
   342      requestSerialize: serialize_rpcquery_GetStorageParam,
   343      requestDeserialize: deserialize_rpcquery_GetStorageParam,
   344      responseSerialize: serialize_rpcquery_StorageValue,
   345      responseDeserialize: deserialize_rpcquery_StorageValue,
   346    },
   347    listAccounts: {
   348      path: '/rpcquery.Query/ListAccounts',
   349      requestStream: false,
   350      responseStream: true,
   351      requestType: rpcquery_pb.ListAccountsParam,
   352      responseType: acm_pb.Account,
   353      requestSerialize: serialize_rpcquery_ListAccountsParam,
   354      requestDeserialize: deserialize_rpcquery_ListAccountsParam,
   355      responseSerialize: serialize_acm_Account,
   356      responseDeserialize: deserialize_acm_Account,
   357    },
   358    getName: {
   359      path: '/rpcquery.Query/GetName',
   360      requestStream: false,
   361      responseStream: false,
   362      requestType: rpcquery_pb.GetNameParam,
   363      responseType: names_pb.Entry,
   364      requestSerialize: serialize_rpcquery_GetNameParam,
   365      requestDeserialize: deserialize_rpcquery_GetNameParam,
   366      responseSerialize: serialize_names_Entry,
   367      responseDeserialize: deserialize_names_Entry,
   368    },
   369    listNames: {
   370      path: '/rpcquery.Query/ListNames',
   371      requestStream: false,
   372      responseStream: true,
   373      requestType: rpcquery_pb.ListNamesParam,
   374      responseType: names_pb.Entry,
   375      requestSerialize: serialize_rpcquery_ListNamesParam,
   376      requestDeserialize: deserialize_rpcquery_ListNamesParam,
   377      responseSerialize: serialize_names_Entry,
   378      responseDeserialize: deserialize_names_Entry,
   379    },
   380    // GetNetworkRegistry returns for each validator address, the list of their identified node at the current state
   381  getNetworkRegistry: {
   382      path: '/rpcquery.Query/GetNetworkRegistry',
   383      requestStream: false,
   384      responseStream: false,
   385      requestType: rpcquery_pb.GetNetworkRegistryParam,
   386      responseType: rpcquery_pb.NetworkRegistry,
   387      requestSerialize: serialize_rpcquery_GetNetworkRegistryParam,
   388      requestDeserialize: deserialize_rpcquery_GetNetworkRegistryParam,
   389      responseSerialize: serialize_rpcquery_NetworkRegistry,
   390      responseDeserialize: deserialize_rpcquery_NetworkRegistry,
   391    },
   392    getValidatorSet: {
   393      path: '/rpcquery.Query/GetValidatorSet',
   394      requestStream: false,
   395      responseStream: false,
   396      requestType: rpcquery_pb.GetValidatorSetParam,
   397      responseType: rpcquery_pb.ValidatorSet,
   398      requestSerialize: serialize_rpcquery_GetValidatorSetParam,
   399      requestDeserialize: deserialize_rpcquery_GetValidatorSetParam,
   400      responseSerialize: serialize_rpcquery_ValidatorSet,
   401      responseDeserialize: deserialize_rpcquery_ValidatorSet,
   402    },
   403    getValidatorSetHistory: {
   404      path: '/rpcquery.Query/GetValidatorSetHistory',
   405      requestStream: false,
   406      responseStream: false,
   407      requestType: rpcquery_pb.GetValidatorSetHistoryParam,
   408      responseType: rpcquery_pb.ValidatorSetHistory,
   409      requestSerialize: serialize_rpcquery_GetValidatorSetHistoryParam,
   410      requestDeserialize: deserialize_rpcquery_GetValidatorSetHistoryParam,
   411      responseSerialize: serialize_rpcquery_ValidatorSetHistory,
   412      responseDeserialize: deserialize_rpcquery_ValidatorSetHistory,
   413    },
   414    getProposal: {
   415      path: '/rpcquery.Query/GetProposal',
   416      requestStream: false,
   417      responseStream: false,
   418      requestType: rpcquery_pb.GetProposalParam,
   419      responseType: payload_pb.Ballot,
   420      requestSerialize: serialize_rpcquery_GetProposalParam,
   421      requestDeserialize: deserialize_rpcquery_GetProposalParam,
   422      responseSerialize: serialize_payload_Ballot,
   423      responseDeserialize: deserialize_payload_Ballot,
   424    },
   425    listProposals: {
   426      path: '/rpcquery.Query/ListProposals',
   427      requestStream: false,
   428      responseStream: true,
   429      requestType: rpcquery_pb.ListProposalsParam,
   430      responseType: rpcquery_pb.ProposalResult,
   431      requestSerialize: serialize_rpcquery_ListProposalsParam,
   432      requestDeserialize: deserialize_rpcquery_ListProposalsParam,
   433      responseSerialize: serialize_rpcquery_ProposalResult,
   434      responseDeserialize: deserialize_rpcquery_ProposalResult,
   435    },
   436    getStats: {
   437      path: '/rpcquery.Query/GetStats',
   438      requestStream: false,
   439      responseStream: false,
   440      requestType: rpcquery_pb.GetStatsParam,
   441      responseType: rpcquery_pb.Stats,
   442      requestSerialize: serialize_rpcquery_GetStatsParam,
   443      requestDeserialize: deserialize_rpcquery_GetStatsParam,
   444      responseSerialize: serialize_rpcquery_Stats,
   445      responseDeserialize: deserialize_rpcquery_Stats,
   446    },
   447    getBlockHeader: {
   448      path: '/rpcquery.Query/GetBlockHeader',
   449      requestStream: false,
   450      responseStream: false,
   451      requestType: rpcquery_pb.GetBlockParam,
   452      responseType: tendermint_types_types_pb.Header,
   453      requestSerialize: serialize_rpcquery_GetBlockParam,
   454      requestDeserialize: deserialize_rpcquery_GetBlockParam,
   455      responseSerialize: serialize_tendermint_types_Header,
   456      responseDeserialize: deserialize_tendermint_types_Header,
   457    },
   458  };
   459  
   460  exports.QueryClient = grpc.makeGenericClientConstructor(QueryService);