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

     1  // GENERATED CODE -- DO NOT EDIT!
     2  
     3  'use strict';
     4  var grpc = require('@grpc/grpc-js');
     5  var keys_pb = require('./keys_pb.js');
     6  var gogoproto_gogo_pb = require('./gogoproto/gogo_pb.js');
     7  var crypto_pb = require('./crypto_pb.js');
     8  
     9  function serialize_keys_AddNameRequest(arg) {
    10    if (!(arg instanceof keys_pb.AddNameRequest)) {
    11      throw new Error('Expected argument of type keys.AddNameRequest');
    12    }
    13    return Buffer.from(arg.serializeBinary());
    14  }
    15  
    16  function deserialize_keys_AddNameRequest(buffer_arg) {
    17    return keys_pb.AddNameRequest.deserializeBinary(new Uint8Array(buffer_arg));
    18  }
    19  
    20  function serialize_keys_AddNameResponse(arg) {
    21    if (!(arg instanceof keys_pb.AddNameResponse)) {
    22      throw new Error('Expected argument of type keys.AddNameResponse');
    23    }
    24    return Buffer.from(arg.serializeBinary());
    25  }
    26  
    27  function deserialize_keys_AddNameResponse(buffer_arg) {
    28    return keys_pb.AddNameResponse.deserializeBinary(new Uint8Array(buffer_arg));
    29  }
    30  
    31  function serialize_keys_ExportRequest(arg) {
    32    if (!(arg instanceof keys_pb.ExportRequest)) {
    33      throw new Error('Expected argument of type keys.ExportRequest');
    34    }
    35    return Buffer.from(arg.serializeBinary());
    36  }
    37  
    38  function deserialize_keys_ExportRequest(buffer_arg) {
    39    return keys_pb.ExportRequest.deserializeBinary(new Uint8Array(buffer_arg));
    40  }
    41  
    42  function serialize_keys_ExportResponse(arg) {
    43    if (!(arg instanceof keys_pb.ExportResponse)) {
    44      throw new Error('Expected argument of type keys.ExportResponse');
    45    }
    46    return Buffer.from(arg.serializeBinary());
    47  }
    48  
    49  function deserialize_keys_ExportResponse(buffer_arg) {
    50    return keys_pb.ExportResponse.deserializeBinary(new Uint8Array(buffer_arg));
    51  }
    52  
    53  function serialize_keys_GenRequest(arg) {
    54    if (!(arg instanceof keys_pb.GenRequest)) {
    55      throw new Error('Expected argument of type keys.GenRequest');
    56    }
    57    return Buffer.from(arg.serializeBinary());
    58  }
    59  
    60  function deserialize_keys_GenRequest(buffer_arg) {
    61    return keys_pb.GenRequest.deserializeBinary(new Uint8Array(buffer_arg));
    62  }
    63  
    64  function serialize_keys_GenResponse(arg) {
    65    if (!(arg instanceof keys_pb.GenResponse)) {
    66      throw new Error('Expected argument of type keys.GenResponse');
    67    }
    68    return Buffer.from(arg.serializeBinary());
    69  }
    70  
    71  function deserialize_keys_GenResponse(buffer_arg) {
    72    return keys_pb.GenResponse.deserializeBinary(new Uint8Array(buffer_arg));
    73  }
    74  
    75  function serialize_keys_HashRequest(arg) {
    76    if (!(arg instanceof keys_pb.HashRequest)) {
    77      throw new Error('Expected argument of type keys.HashRequest');
    78    }
    79    return Buffer.from(arg.serializeBinary());
    80  }
    81  
    82  function deserialize_keys_HashRequest(buffer_arg) {
    83    return keys_pb.HashRequest.deserializeBinary(new Uint8Array(buffer_arg));
    84  }
    85  
    86  function serialize_keys_HashResponse(arg) {
    87    if (!(arg instanceof keys_pb.HashResponse)) {
    88      throw new Error('Expected argument of type keys.HashResponse');
    89    }
    90    return Buffer.from(arg.serializeBinary());
    91  }
    92  
    93  function deserialize_keys_HashResponse(buffer_arg) {
    94    return keys_pb.HashResponse.deserializeBinary(new Uint8Array(buffer_arg));
    95  }
    96  
    97  function serialize_keys_ImportJSONRequest(arg) {
    98    if (!(arg instanceof keys_pb.ImportJSONRequest)) {
    99      throw new Error('Expected argument of type keys.ImportJSONRequest');
   100    }
   101    return Buffer.from(arg.serializeBinary());
   102  }
   103  
   104  function deserialize_keys_ImportJSONRequest(buffer_arg) {
   105    return keys_pb.ImportJSONRequest.deserializeBinary(new Uint8Array(buffer_arg));
   106  }
   107  
   108  function serialize_keys_ImportRequest(arg) {
   109    if (!(arg instanceof keys_pb.ImportRequest)) {
   110      throw new Error('Expected argument of type keys.ImportRequest');
   111    }
   112    return Buffer.from(arg.serializeBinary());
   113  }
   114  
   115  function deserialize_keys_ImportRequest(buffer_arg) {
   116    return keys_pb.ImportRequest.deserializeBinary(new Uint8Array(buffer_arg));
   117  }
   118  
   119  function serialize_keys_ImportResponse(arg) {
   120    if (!(arg instanceof keys_pb.ImportResponse)) {
   121      throw new Error('Expected argument of type keys.ImportResponse');
   122    }
   123    return Buffer.from(arg.serializeBinary());
   124  }
   125  
   126  function deserialize_keys_ImportResponse(buffer_arg) {
   127    return keys_pb.ImportResponse.deserializeBinary(new Uint8Array(buffer_arg));
   128  }
   129  
   130  function serialize_keys_ListRequest(arg) {
   131    if (!(arg instanceof keys_pb.ListRequest)) {
   132      throw new Error('Expected argument of type keys.ListRequest');
   133    }
   134    return Buffer.from(arg.serializeBinary());
   135  }
   136  
   137  function deserialize_keys_ListRequest(buffer_arg) {
   138    return keys_pb.ListRequest.deserializeBinary(new Uint8Array(buffer_arg));
   139  }
   140  
   141  function serialize_keys_ListResponse(arg) {
   142    if (!(arg instanceof keys_pb.ListResponse)) {
   143      throw new Error('Expected argument of type keys.ListResponse');
   144    }
   145    return Buffer.from(arg.serializeBinary());
   146  }
   147  
   148  function deserialize_keys_ListResponse(buffer_arg) {
   149    return keys_pb.ListResponse.deserializeBinary(new Uint8Array(buffer_arg));
   150  }
   151  
   152  function serialize_keys_PubRequest(arg) {
   153    if (!(arg instanceof keys_pb.PubRequest)) {
   154      throw new Error('Expected argument of type keys.PubRequest');
   155    }
   156    return Buffer.from(arg.serializeBinary());
   157  }
   158  
   159  function deserialize_keys_PubRequest(buffer_arg) {
   160    return keys_pb.PubRequest.deserializeBinary(new Uint8Array(buffer_arg));
   161  }
   162  
   163  function serialize_keys_PubResponse(arg) {
   164    if (!(arg instanceof keys_pb.PubResponse)) {
   165      throw new Error('Expected argument of type keys.PubResponse');
   166    }
   167    return Buffer.from(arg.serializeBinary());
   168  }
   169  
   170  function deserialize_keys_PubResponse(buffer_arg) {
   171    return keys_pb.PubResponse.deserializeBinary(new Uint8Array(buffer_arg));
   172  }
   173  
   174  function serialize_keys_RemoveNameRequest(arg) {
   175    if (!(arg instanceof keys_pb.RemoveNameRequest)) {
   176      throw new Error('Expected argument of type keys.RemoveNameRequest');
   177    }
   178    return Buffer.from(arg.serializeBinary());
   179  }
   180  
   181  function deserialize_keys_RemoveNameRequest(buffer_arg) {
   182    return keys_pb.RemoveNameRequest.deserializeBinary(new Uint8Array(buffer_arg));
   183  }
   184  
   185  function serialize_keys_RemoveNameResponse(arg) {
   186    if (!(arg instanceof keys_pb.RemoveNameResponse)) {
   187      throw new Error('Expected argument of type keys.RemoveNameResponse');
   188    }
   189    return Buffer.from(arg.serializeBinary());
   190  }
   191  
   192  function deserialize_keys_RemoveNameResponse(buffer_arg) {
   193    return keys_pb.RemoveNameResponse.deserializeBinary(new Uint8Array(buffer_arg));
   194  }
   195  
   196  function serialize_keys_SignRequest(arg) {
   197    if (!(arg instanceof keys_pb.SignRequest)) {
   198      throw new Error('Expected argument of type keys.SignRequest');
   199    }
   200    return Buffer.from(arg.serializeBinary());
   201  }
   202  
   203  function deserialize_keys_SignRequest(buffer_arg) {
   204    return keys_pb.SignRequest.deserializeBinary(new Uint8Array(buffer_arg));
   205  }
   206  
   207  function serialize_keys_SignResponse(arg) {
   208    if (!(arg instanceof keys_pb.SignResponse)) {
   209      throw new Error('Expected argument of type keys.SignResponse');
   210    }
   211    return Buffer.from(arg.serializeBinary());
   212  }
   213  
   214  function deserialize_keys_SignResponse(buffer_arg) {
   215    return keys_pb.SignResponse.deserializeBinary(new Uint8Array(buffer_arg));
   216  }
   217  
   218  function serialize_keys_VerifyRequest(arg) {
   219    if (!(arg instanceof keys_pb.VerifyRequest)) {
   220      throw new Error('Expected argument of type keys.VerifyRequest');
   221    }
   222    return Buffer.from(arg.serializeBinary());
   223  }
   224  
   225  function deserialize_keys_VerifyRequest(buffer_arg) {
   226    return keys_pb.VerifyRequest.deserializeBinary(new Uint8Array(buffer_arg));
   227  }
   228  
   229  function serialize_keys_VerifyResponse(arg) {
   230    if (!(arg instanceof keys_pb.VerifyResponse)) {
   231      throw new Error('Expected argument of type keys.VerifyResponse');
   232    }
   233    return Buffer.from(arg.serializeBinary());
   234  }
   235  
   236  function deserialize_keys_VerifyResponse(buffer_arg) {
   237    return keys_pb.VerifyResponse.deserializeBinary(new Uint8Array(buffer_arg));
   238  }
   239  
   240  
   241  var KeysService = exports.KeysService = {
   242    generateKey: {
   243      path: '/keys.Keys/GenerateKey',
   244      requestStream: false,
   245      responseStream: false,
   246      requestType: keys_pb.GenRequest,
   247      responseType: keys_pb.GenResponse,
   248      requestSerialize: serialize_keys_GenRequest,
   249      requestDeserialize: deserialize_keys_GenRequest,
   250      responseSerialize: serialize_keys_GenResponse,
   251      responseDeserialize: deserialize_keys_GenResponse,
   252    },
   253    publicKey: {
   254      path: '/keys.Keys/PublicKey',
   255      requestStream: false,
   256      responseStream: false,
   257      requestType: keys_pb.PubRequest,
   258      responseType: keys_pb.PubResponse,
   259      requestSerialize: serialize_keys_PubRequest,
   260      requestDeserialize: deserialize_keys_PubRequest,
   261      responseSerialize: serialize_keys_PubResponse,
   262      responseDeserialize: deserialize_keys_PubResponse,
   263    },
   264    sign: {
   265      path: '/keys.Keys/Sign',
   266      requestStream: false,
   267      responseStream: false,
   268      requestType: keys_pb.SignRequest,
   269      responseType: keys_pb.SignResponse,
   270      requestSerialize: serialize_keys_SignRequest,
   271      requestDeserialize: deserialize_keys_SignRequest,
   272      responseSerialize: serialize_keys_SignResponse,
   273      responseDeserialize: deserialize_keys_SignResponse,
   274    },
   275    verify: {
   276      path: '/keys.Keys/Verify',
   277      requestStream: false,
   278      responseStream: false,
   279      requestType: keys_pb.VerifyRequest,
   280      responseType: keys_pb.VerifyResponse,
   281      requestSerialize: serialize_keys_VerifyRequest,
   282      requestDeserialize: deserialize_keys_VerifyRequest,
   283      responseSerialize: serialize_keys_VerifyResponse,
   284      responseDeserialize: deserialize_keys_VerifyResponse,
   285    },
   286    import: {
   287      path: '/keys.Keys/Import',
   288      requestStream: false,
   289      responseStream: false,
   290      requestType: keys_pb.ImportRequest,
   291      responseType: keys_pb.ImportResponse,
   292      requestSerialize: serialize_keys_ImportRequest,
   293      requestDeserialize: deserialize_keys_ImportRequest,
   294      responseSerialize: serialize_keys_ImportResponse,
   295      responseDeserialize: deserialize_keys_ImportResponse,
   296    },
   297    importJSON: {
   298      path: '/keys.Keys/ImportJSON',
   299      requestStream: false,
   300      responseStream: false,
   301      requestType: keys_pb.ImportJSONRequest,
   302      responseType: keys_pb.ImportResponse,
   303      requestSerialize: serialize_keys_ImportJSONRequest,
   304      requestDeserialize: deserialize_keys_ImportJSONRequest,
   305      responseSerialize: serialize_keys_ImportResponse,
   306      responseDeserialize: deserialize_keys_ImportResponse,
   307    },
   308    export: {
   309      path: '/keys.Keys/Export',
   310      requestStream: false,
   311      responseStream: false,
   312      requestType: keys_pb.ExportRequest,
   313      responseType: keys_pb.ExportResponse,
   314      requestSerialize: serialize_keys_ExportRequest,
   315      requestDeserialize: deserialize_keys_ExportRequest,
   316      responseSerialize: serialize_keys_ExportResponse,
   317      responseDeserialize: deserialize_keys_ExportResponse,
   318    },
   319    hash: {
   320      path: '/keys.Keys/Hash',
   321      requestStream: false,
   322      responseStream: false,
   323      requestType: keys_pb.HashRequest,
   324      responseType: keys_pb.HashResponse,
   325      requestSerialize: serialize_keys_HashRequest,
   326      requestDeserialize: deserialize_keys_HashRequest,
   327      responseSerialize: serialize_keys_HashResponse,
   328      responseDeserialize: deserialize_keys_HashResponse,
   329    },
   330    removeName: {
   331      path: '/keys.Keys/RemoveName',
   332      requestStream: false,
   333      responseStream: false,
   334      requestType: keys_pb.RemoveNameRequest,
   335      responseType: keys_pb.RemoveNameResponse,
   336      requestSerialize: serialize_keys_RemoveNameRequest,
   337      requestDeserialize: deserialize_keys_RemoveNameRequest,
   338      responseSerialize: serialize_keys_RemoveNameResponse,
   339      responseDeserialize: deserialize_keys_RemoveNameResponse,
   340    },
   341    list: {
   342      path: '/keys.Keys/List',
   343      requestStream: false,
   344      responseStream: false,
   345      requestType: keys_pb.ListRequest,
   346      responseType: keys_pb.ListResponse,
   347      requestSerialize: serialize_keys_ListRequest,
   348      requestDeserialize: deserialize_keys_ListRequest,
   349      responseSerialize: serialize_keys_ListResponse,
   350      responseDeserialize: deserialize_keys_ListResponse,
   351    },
   352    addName: {
   353      path: '/keys.Keys/AddName',
   354      requestStream: false,
   355      responseStream: false,
   356      requestType: keys_pb.AddNameRequest,
   357      responseType: keys_pb.AddNameResponse,
   358      requestSerialize: serialize_keys_AddNameRequest,
   359      requestDeserialize: deserialize_keys_AddNameRequest,
   360      responseSerialize: serialize_keys_AddNameResponse,
   361      responseDeserialize: deserialize_keys_AddNameResponse,
   362    },
   363  };
   364  
   365  exports.KeysClient = grpc.makeGenericClientConstructor(KeysService);