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

     1  // source: exec.proto
     2  /**
     3   * @fileoverview
     4   * @enhanceable
     5   * @suppress {missingRequire} reports error on implicit type usages.
     6   * @suppress {messageConventions} JS Compiler reports an error if a variable or
     7   *     field starts with 'MSG_' and isn't a translatable message.
     8   * @public
     9   */
    10  // GENERATED CODE -- DO NOT EDIT!
    11  /* eslint-disable */
    12  // @ts-nocheck
    13  
    14  var jspb = require('google-protobuf');
    15  var goog = jspb;
    16  var global = Function('return this')();
    17  
    18  var gogoproto_gogo_pb = require('./gogoproto/gogo_pb.js');
    19  goog.object.extend(proto, gogoproto_gogo_pb);
    20  var tendermint_types_types_pb = require('./tendermint/types/types_pb.js');
    21  goog.object.extend(proto, tendermint_types_types_pb);
    22  var google_protobuf_timestamp_pb = require('google-protobuf/google/protobuf/timestamp_pb.js');
    23  goog.object.extend(proto, google_protobuf_timestamp_pb);
    24  var errors_pb = require('./errors_pb.js');
    25  goog.object.extend(proto, errors_pb);
    26  var names_pb = require('./names_pb.js');
    27  goog.object.extend(proto, names_pb);
    28  var txs_pb = require('./txs_pb.js');
    29  goog.object.extend(proto, txs_pb);
    30  var permission_pb = require('./permission_pb.js');
    31  goog.object.extend(proto, permission_pb);
    32  var spec_pb = require('./spec_pb.js');
    33  goog.object.extend(proto, spec_pb);
    34  goog.exportSymbol('proto.exec.BeginBlock', null, global);
    35  goog.exportSymbol('proto.exec.BeginTx', null, global);
    36  goog.exportSymbol('proto.exec.BlockExecution', null, global);
    37  goog.exportSymbol('proto.exec.CallData', null, global);
    38  goog.exportSymbol('proto.exec.CallEvent', null, global);
    39  goog.exportSymbol('proto.exec.EndBlock', null, global);
    40  goog.exportSymbol('proto.exec.EndTx', null, global);
    41  goog.exportSymbol('proto.exec.Event', null, global);
    42  goog.exportSymbol('proto.exec.GovernAccountEvent', null, global);
    43  goog.exportSymbol('proto.exec.Header', null, global);
    44  goog.exportSymbol('proto.exec.InputEvent', null, global);
    45  goog.exportSymbol('proto.exec.LogEvent', null, global);
    46  goog.exportSymbol('proto.exec.Origin', null, global);
    47  goog.exportSymbol('proto.exec.OutputEvent', null, global);
    48  goog.exportSymbol('proto.exec.PrintEvent', null, global);
    49  goog.exportSymbol('proto.exec.Result', null, global);
    50  goog.exportSymbol('proto.exec.StreamEvent', null, global);
    51  goog.exportSymbol('proto.exec.StreamEvents', null, global);
    52  goog.exportSymbol('proto.exec.TxExecution', null, global);
    53  goog.exportSymbol('proto.exec.TxExecutionKey', null, global);
    54  goog.exportSymbol('proto.exec.TxHeader', null, global);
    55  /**
    56   * Generated by JsPbCodeGenerator.
    57   * @param {Array=} opt_data Optional initial data array, typically from a
    58   * server response, or constructed directly in Javascript. The array is used
    59   * in place and becomes part of the constructed object. It is not cloned.
    60   * If no data is provided, the constructed object will be empty, but still
    61   * valid.
    62   * @extends {jspb.Message}
    63   * @constructor
    64   */
    65  proto.exec.StreamEvents = function(opt_data) {
    66    jspb.Message.initialize(this, opt_data, 0, -1, proto.exec.StreamEvents.repeatedFields_, null);
    67  };
    68  goog.inherits(proto.exec.StreamEvents, jspb.Message);
    69  if (goog.DEBUG && !COMPILED) {
    70    /**
    71     * @public
    72     * @override
    73     */
    74    proto.exec.StreamEvents.displayName = 'proto.exec.StreamEvents';
    75  }
    76  /**
    77   * Generated by JsPbCodeGenerator.
    78   * @param {Array=} opt_data Optional initial data array, typically from a
    79   * server response, or constructed directly in Javascript. The array is used
    80   * in place and becomes part of the constructed object. It is not cloned.
    81   * If no data is provided, the constructed object will be empty, but still
    82   * valid.
    83   * @extends {jspb.Message}
    84   * @constructor
    85   */
    86  proto.exec.StreamEvent = function(opt_data) {
    87    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
    88  };
    89  goog.inherits(proto.exec.StreamEvent, jspb.Message);
    90  if (goog.DEBUG && !COMPILED) {
    91    /**
    92     * @public
    93     * @override
    94     */
    95    proto.exec.StreamEvent.displayName = 'proto.exec.StreamEvent';
    96  }
    97  /**
    98   * Generated by JsPbCodeGenerator.
    99   * @param {Array=} opt_data Optional initial data array, typically from a
   100   * server response, or constructed directly in Javascript. The array is used
   101   * in place and becomes part of the constructed object. It is not cloned.
   102   * If no data is provided, the constructed object will be empty, but still
   103   * valid.
   104   * @extends {jspb.Message}
   105   * @constructor
   106   */
   107  proto.exec.BeginBlock = function(opt_data) {
   108    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   109  };
   110  goog.inherits(proto.exec.BeginBlock, jspb.Message);
   111  if (goog.DEBUG && !COMPILED) {
   112    /**
   113     * @public
   114     * @override
   115     */
   116    proto.exec.BeginBlock.displayName = 'proto.exec.BeginBlock';
   117  }
   118  /**
   119   * Generated by JsPbCodeGenerator.
   120   * @param {Array=} opt_data Optional initial data array, typically from a
   121   * server response, or constructed directly in Javascript. The array is used
   122   * in place and becomes part of the constructed object. It is not cloned.
   123   * If no data is provided, the constructed object will be empty, but still
   124   * valid.
   125   * @extends {jspb.Message}
   126   * @constructor
   127   */
   128  proto.exec.EndBlock = function(opt_data) {
   129    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   130  };
   131  goog.inherits(proto.exec.EndBlock, jspb.Message);
   132  if (goog.DEBUG && !COMPILED) {
   133    /**
   134     * @public
   135     * @override
   136     */
   137    proto.exec.EndBlock.displayName = 'proto.exec.EndBlock';
   138  }
   139  /**
   140   * Generated by JsPbCodeGenerator.
   141   * @param {Array=} opt_data Optional initial data array, typically from a
   142   * server response, or constructed directly in Javascript. The array is used
   143   * in place and becomes part of the constructed object. It is not cloned.
   144   * If no data is provided, the constructed object will be empty, but still
   145   * valid.
   146   * @extends {jspb.Message}
   147   * @constructor
   148   */
   149  proto.exec.BeginTx = function(opt_data) {
   150    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   151  };
   152  goog.inherits(proto.exec.BeginTx, jspb.Message);
   153  if (goog.DEBUG && !COMPILED) {
   154    /**
   155     * @public
   156     * @override
   157     */
   158    proto.exec.BeginTx.displayName = 'proto.exec.BeginTx';
   159  }
   160  /**
   161   * Generated by JsPbCodeGenerator.
   162   * @param {Array=} opt_data Optional initial data array, typically from a
   163   * server response, or constructed directly in Javascript. The array is used
   164   * in place and becomes part of the constructed object. It is not cloned.
   165   * If no data is provided, the constructed object will be empty, but still
   166   * valid.
   167   * @extends {jspb.Message}
   168   * @constructor
   169   */
   170  proto.exec.EndTx = function(opt_data) {
   171    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   172  };
   173  goog.inherits(proto.exec.EndTx, jspb.Message);
   174  if (goog.DEBUG && !COMPILED) {
   175    /**
   176     * @public
   177     * @override
   178     */
   179    proto.exec.EndTx.displayName = 'proto.exec.EndTx';
   180  }
   181  /**
   182   * Generated by JsPbCodeGenerator.
   183   * @param {Array=} opt_data Optional initial data array, typically from a
   184   * server response, or constructed directly in Javascript. The array is used
   185   * in place and becomes part of the constructed object. It is not cloned.
   186   * If no data is provided, the constructed object will be empty, but still
   187   * valid.
   188   * @extends {jspb.Message}
   189   * @constructor
   190   */
   191  proto.exec.TxHeader = function(opt_data) {
   192    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   193  };
   194  goog.inherits(proto.exec.TxHeader, jspb.Message);
   195  if (goog.DEBUG && !COMPILED) {
   196    /**
   197     * @public
   198     * @override
   199     */
   200    proto.exec.TxHeader.displayName = 'proto.exec.TxHeader';
   201  }
   202  /**
   203   * Generated by JsPbCodeGenerator.
   204   * @param {Array=} opt_data Optional initial data array, typically from a
   205   * server response, or constructed directly in Javascript. The array is used
   206   * in place and becomes part of the constructed object. It is not cloned.
   207   * If no data is provided, the constructed object will be empty, but still
   208   * valid.
   209   * @extends {jspb.Message}
   210   * @constructor
   211   */
   212  proto.exec.BlockExecution = function(opt_data) {
   213    jspb.Message.initialize(this, opt_data, 0, -1, proto.exec.BlockExecution.repeatedFields_, null);
   214  };
   215  goog.inherits(proto.exec.BlockExecution, jspb.Message);
   216  if (goog.DEBUG && !COMPILED) {
   217    /**
   218     * @public
   219     * @override
   220     */
   221    proto.exec.BlockExecution.displayName = 'proto.exec.BlockExecution';
   222  }
   223  /**
   224   * Generated by JsPbCodeGenerator.
   225   * @param {Array=} opt_data Optional initial data array, typically from a
   226   * server response, or constructed directly in Javascript. The array is used
   227   * in place and becomes part of the constructed object. It is not cloned.
   228   * If no data is provided, the constructed object will be empty, but still
   229   * valid.
   230   * @extends {jspb.Message}
   231   * @constructor
   232   */
   233  proto.exec.TxExecutionKey = function(opt_data) {
   234    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   235  };
   236  goog.inherits(proto.exec.TxExecutionKey, jspb.Message);
   237  if (goog.DEBUG && !COMPILED) {
   238    /**
   239     * @public
   240     * @override
   241     */
   242    proto.exec.TxExecutionKey.displayName = 'proto.exec.TxExecutionKey';
   243  }
   244  /**
   245   * Generated by JsPbCodeGenerator.
   246   * @param {Array=} opt_data Optional initial data array, typically from a
   247   * server response, or constructed directly in Javascript. The array is used
   248   * in place and becomes part of the constructed object. It is not cloned.
   249   * If no data is provided, the constructed object will be empty, but still
   250   * valid.
   251   * @extends {jspb.Message}
   252   * @constructor
   253   */
   254  proto.exec.TxExecution = function(opt_data) {
   255    jspb.Message.initialize(this, opt_data, 0, -1, proto.exec.TxExecution.repeatedFields_, null);
   256  };
   257  goog.inherits(proto.exec.TxExecution, jspb.Message);
   258  if (goog.DEBUG && !COMPILED) {
   259    /**
   260     * @public
   261     * @override
   262     */
   263    proto.exec.TxExecution.displayName = 'proto.exec.TxExecution';
   264  }
   265  /**
   266   * Generated by JsPbCodeGenerator.
   267   * @param {Array=} opt_data Optional initial data array, typically from a
   268   * server response, or constructed directly in Javascript. The array is used
   269   * in place and becomes part of the constructed object. It is not cloned.
   270   * If no data is provided, the constructed object will be empty, but still
   271   * valid.
   272   * @extends {jspb.Message}
   273   * @constructor
   274   */
   275  proto.exec.Origin = function(opt_data) {
   276    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   277  };
   278  goog.inherits(proto.exec.Origin, jspb.Message);
   279  if (goog.DEBUG && !COMPILED) {
   280    /**
   281     * @public
   282     * @override
   283     */
   284    proto.exec.Origin.displayName = 'proto.exec.Origin';
   285  }
   286  /**
   287   * Generated by JsPbCodeGenerator.
   288   * @param {Array=} opt_data Optional initial data array, typically from a
   289   * server response, or constructed directly in Javascript. The array is used
   290   * in place and becomes part of the constructed object. It is not cloned.
   291   * If no data is provided, the constructed object will be empty, but still
   292   * valid.
   293   * @extends {jspb.Message}
   294   * @constructor
   295   */
   296  proto.exec.Header = function(opt_data) {
   297    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   298  };
   299  goog.inherits(proto.exec.Header, jspb.Message);
   300  if (goog.DEBUG && !COMPILED) {
   301    /**
   302     * @public
   303     * @override
   304     */
   305    proto.exec.Header.displayName = 'proto.exec.Header';
   306  }
   307  /**
   308   * Generated by JsPbCodeGenerator.
   309   * @param {Array=} opt_data Optional initial data array, typically from a
   310   * server response, or constructed directly in Javascript. The array is used
   311   * in place and becomes part of the constructed object. It is not cloned.
   312   * If no data is provided, the constructed object will be empty, but still
   313   * valid.
   314   * @extends {jspb.Message}
   315   * @constructor
   316   */
   317  proto.exec.Event = function(opt_data) {
   318    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   319  };
   320  goog.inherits(proto.exec.Event, jspb.Message);
   321  if (goog.DEBUG && !COMPILED) {
   322    /**
   323     * @public
   324     * @override
   325     */
   326    proto.exec.Event.displayName = 'proto.exec.Event';
   327  }
   328  /**
   329   * Generated by JsPbCodeGenerator.
   330   * @param {Array=} opt_data Optional initial data array, typically from a
   331   * server response, or constructed directly in Javascript. The array is used
   332   * in place and becomes part of the constructed object. It is not cloned.
   333   * If no data is provided, the constructed object will be empty, but still
   334   * valid.
   335   * @extends {jspb.Message}
   336   * @constructor
   337   */
   338  proto.exec.Result = function(opt_data) {
   339    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   340  };
   341  goog.inherits(proto.exec.Result, jspb.Message);
   342  if (goog.DEBUG && !COMPILED) {
   343    /**
   344     * @public
   345     * @override
   346     */
   347    proto.exec.Result.displayName = 'proto.exec.Result';
   348  }
   349  /**
   350   * Generated by JsPbCodeGenerator.
   351   * @param {Array=} opt_data Optional initial data array, typically from a
   352   * server response, or constructed directly in Javascript. The array is used
   353   * in place and becomes part of the constructed object. It is not cloned.
   354   * If no data is provided, the constructed object will be empty, but still
   355   * valid.
   356   * @extends {jspb.Message}
   357   * @constructor
   358   */
   359  proto.exec.LogEvent = function(opt_data) {
   360    jspb.Message.initialize(this, opt_data, 0, -1, proto.exec.LogEvent.repeatedFields_, null);
   361  };
   362  goog.inherits(proto.exec.LogEvent, jspb.Message);
   363  if (goog.DEBUG && !COMPILED) {
   364    /**
   365     * @public
   366     * @override
   367     */
   368    proto.exec.LogEvent.displayName = 'proto.exec.LogEvent';
   369  }
   370  /**
   371   * Generated by JsPbCodeGenerator.
   372   * @param {Array=} opt_data Optional initial data array, typically from a
   373   * server response, or constructed directly in Javascript. The array is used
   374   * in place and becomes part of the constructed object. It is not cloned.
   375   * If no data is provided, the constructed object will be empty, but still
   376   * valid.
   377   * @extends {jspb.Message}
   378   * @constructor
   379   */
   380  proto.exec.CallEvent = function(opt_data) {
   381    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   382  };
   383  goog.inherits(proto.exec.CallEvent, jspb.Message);
   384  if (goog.DEBUG && !COMPILED) {
   385    /**
   386     * @public
   387     * @override
   388     */
   389    proto.exec.CallEvent.displayName = 'proto.exec.CallEvent';
   390  }
   391  /**
   392   * Generated by JsPbCodeGenerator.
   393   * @param {Array=} opt_data Optional initial data array, typically from a
   394   * server response, or constructed directly in Javascript. The array is used
   395   * in place and becomes part of the constructed object. It is not cloned.
   396   * If no data is provided, the constructed object will be empty, but still
   397   * valid.
   398   * @extends {jspb.Message}
   399   * @constructor
   400   */
   401  proto.exec.PrintEvent = function(opt_data) {
   402    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   403  };
   404  goog.inherits(proto.exec.PrintEvent, jspb.Message);
   405  if (goog.DEBUG && !COMPILED) {
   406    /**
   407     * @public
   408     * @override
   409     */
   410    proto.exec.PrintEvent.displayName = 'proto.exec.PrintEvent';
   411  }
   412  /**
   413   * Generated by JsPbCodeGenerator.
   414   * @param {Array=} opt_data Optional initial data array, typically from a
   415   * server response, or constructed directly in Javascript. The array is used
   416   * in place and becomes part of the constructed object. It is not cloned.
   417   * If no data is provided, the constructed object will be empty, but still
   418   * valid.
   419   * @extends {jspb.Message}
   420   * @constructor
   421   */
   422  proto.exec.GovernAccountEvent = function(opt_data) {
   423    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   424  };
   425  goog.inherits(proto.exec.GovernAccountEvent, jspb.Message);
   426  if (goog.DEBUG && !COMPILED) {
   427    /**
   428     * @public
   429     * @override
   430     */
   431    proto.exec.GovernAccountEvent.displayName = 'proto.exec.GovernAccountEvent';
   432  }
   433  /**
   434   * Generated by JsPbCodeGenerator.
   435   * @param {Array=} opt_data Optional initial data array, typically from a
   436   * server response, or constructed directly in Javascript. The array is used
   437   * in place and becomes part of the constructed object. It is not cloned.
   438   * If no data is provided, the constructed object will be empty, but still
   439   * valid.
   440   * @extends {jspb.Message}
   441   * @constructor
   442   */
   443  proto.exec.InputEvent = function(opt_data) {
   444    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   445  };
   446  goog.inherits(proto.exec.InputEvent, jspb.Message);
   447  if (goog.DEBUG && !COMPILED) {
   448    /**
   449     * @public
   450     * @override
   451     */
   452    proto.exec.InputEvent.displayName = 'proto.exec.InputEvent';
   453  }
   454  /**
   455   * Generated by JsPbCodeGenerator.
   456   * @param {Array=} opt_data Optional initial data array, typically from a
   457   * server response, or constructed directly in Javascript. The array is used
   458   * in place and becomes part of the constructed object. It is not cloned.
   459   * If no data is provided, the constructed object will be empty, but still
   460   * valid.
   461   * @extends {jspb.Message}
   462   * @constructor
   463   */
   464  proto.exec.OutputEvent = function(opt_data) {
   465    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   466  };
   467  goog.inherits(proto.exec.OutputEvent, jspb.Message);
   468  if (goog.DEBUG && !COMPILED) {
   469    /**
   470     * @public
   471     * @override
   472     */
   473    proto.exec.OutputEvent.displayName = 'proto.exec.OutputEvent';
   474  }
   475  /**
   476   * Generated by JsPbCodeGenerator.
   477   * @param {Array=} opt_data Optional initial data array, typically from a
   478   * server response, or constructed directly in Javascript. The array is used
   479   * in place and becomes part of the constructed object. It is not cloned.
   480   * If no data is provided, the constructed object will be empty, but still
   481   * valid.
   482   * @extends {jspb.Message}
   483   * @constructor
   484   */
   485  proto.exec.CallData = function(opt_data) {
   486    jspb.Message.initialize(this, opt_data, 0, -1, null, null);
   487  };
   488  goog.inherits(proto.exec.CallData, jspb.Message);
   489  if (goog.DEBUG && !COMPILED) {
   490    /**
   491     * @public
   492     * @override
   493     */
   494    proto.exec.CallData.displayName = 'proto.exec.CallData';
   495  }
   496  
   497  /**
   498   * List of repeated fields within this message type.
   499   * @private {!Array<number>}
   500   * @const
   501   */
   502  proto.exec.StreamEvents.repeatedFields_ = [1];
   503  
   504  
   505  
   506  if (jspb.Message.GENERATE_TO_OBJECT) {
   507  /**
   508   * Creates an object representation of this proto.
   509   * Field names that are reserved in JavaScript and will be renamed to pb_name.
   510   * Optional fields that are not set will be set to undefined.
   511   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
   512   * For the list of reserved names please see:
   513   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
   514   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
   515   *     JSPB instance for transitional soy proto support:
   516   *     http://goto/soy-param-migration
   517   * @return {!Object}
   518   */
   519  proto.exec.StreamEvents.prototype.toObject = function(opt_includeInstance) {
   520    return proto.exec.StreamEvents.toObject(opt_includeInstance, this);
   521  };
   522  
   523  
   524  /**
   525   * Static version of the {@see toObject} method.
   526   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
   527   *     the JSPB instance for transitional soy proto support:
   528   *     http://goto/soy-param-migration
   529   * @param {!proto.exec.StreamEvents} msg The msg instance to transform.
   530   * @return {!Object}
   531   * @suppress {unusedLocalVariables} f is only used for nested messages
   532   */
   533  proto.exec.StreamEvents.toObject = function(includeInstance, msg) {
   534    var f, obj = {
   535      streameventsList: jspb.Message.toObjectList(msg.getStreameventsList(),
   536      proto.exec.StreamEvent.toObject, includeInstance)
   537    };
   538  
   539    if (includeInstance) {
   540      obj.$jspbMessageInstance = msg;
   541    }
   542    return obj;
   543  };
   544  }
   545  
   546  
   547  /**
   548   * Deserializes binary data (in protobuf wire format).
   549   * @param {jspb.ByteSource} bytes The bytes to deserialize.
   550   * @return {!proto.exec.StreamEvents}
   551   */
   552  proto.exec.StreamEvents.deserializeBinary = function(bytes) {
   553    var reader = new jspb.BinaryReader(bytes);
   554    var msg = new proto.exec.StreamEvents;
   555    return proto.exec.StreamEvents.deserializeBinaryFromReader(msg, reader);
   556  };
   557  
   558  
   559  /**
   560   * Deserializes binary data (in protobuf wire format) from the
   561   * given reader into the given message object.
   562   * @param {!proto.exec.StreamEvents} msg The message object to deserialize into.
   563   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
   564   * @return {!proto.exec.StreamEvents}
   565   */
   566  proto.exec.StreamEvents.deserializeBinaryFromReader = function(msg, reader) {
   567    while (reader.nextField()) {
   568      if (reader.isEndGroup()) {
   569        break;
   570      }
   571      var field = reader.getFieldNumber();
   572      switch (field) {
   573      case 1:
   574        var value = new proto.exec.StreamEvent;
   575        reader.readMessage(value,proto.exec.StreamEvent.deserializeBinaryFromReader);
   576        msg.addStreamevents(value);
   577        break;
   578      default:
   579        reader.skipField();
   580        break;
   581      }
   582    }
   583    return msg;
   584  };
   585  
   586  
   587  /**
   588   * Serializes the message to binary data (in protobuf wire format).
   589   * @return {!Uint8Array}
   590   */
   591  proto.exec.StreamEvents.prototype.serializeBinary = function() {
   592    var writer = new jspb.BinaryWriter();
   593    proto.exec.StreamEvents.serializeBinaryToWriter(this, writer);
   594    return writer.getResultBuffer();
   595  };
   596  
   597  
   598  /**
   599   * Serializes the given message to binary data (in protobuf wire
   600   * format), writing to the given BinaryWriter.
   601   * @param {!proto.exec.StreamEvents} message
   602   * @param {!jspb.BinaryWriter} writer
   603   * @suppress {unusedLocalVariables} f is only used for nested messages
   604   */
   605  proto.exec.StreamEvents.serializeBinaryToWriter = function(message, writer) {
   606    var f = undefined;
   607    f = message.getStreameventsList();
   608    if (f.length > 0) {
   609      writer.writeRepeatedMessage(
   610        1,
   611        f,
   612        proto.exec.StreamEvent.serializeBinaryToWriter
   613      );
   614    }
   615  };
   616  
   617  
   618  /**
   619   * repeated StreamEvent StreamEvents = 1;
   620   * @return {!Array<!proto.exec.StreamEvent>}
   621   */
   622  proto.exec.StreamEvents.prototype.getStreameventsList = function() {
   623    return /** @type{!Array<!proto.exec.StreamEvent>} */ (
   624      jspb.Message.getRepeatedWrapperField(this, proto.exec.StreamEvent, 1));
   625  };
   626  
   627  
   628  /**
   629   * @param {!Array<!proto.exec.StreamEvent>} value
   630   * @return {!proto.exec.StreamEvents} returns this
   631  */
   632  proto.exec.StreamEvents.prototype.setStreameventsList = function(value) {
   633    return jspb.Message.setRepeatedWrapperField(this, 1, value);
   634  };
   635  
   636  
   637  /**
   638   * @param {!proto.exec.StreamEvent=} opt_value
   639   * @param {number=} opt_index
   640   * @return {!proto.exec.StreamEvent}
   641   */
   642  proto.exec.StreamEvents.prototype.addStreamevents = function(opt_value, opt_index) {
   643    return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.exec.StreamEvent, opt_index);
   644  };
   645  
   646  
   647  /**
   648   * Clears the list making it empty but non-null.
   649   * @return {!proto.exec.StreamEvents} returns this
   650   */
   651  proto.exec.StreamEvents.prototype.clearStreameventsList = function() {
   652    return this.setStreameventsList([]);
   653  };
   654  
   655  
   656  
   657  
   658  
   659  if (jspb.Message.GENERATE_TO_OBJECT) {
   660  /**
   661   * Creates an object representation of this proto.
   662   * Field names that are reserved in JavaScript and will be renamed to pb_name.
   663   * Optional fields that are not set will be set to undefined.
   664   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
   665   * For the list of reserved names please see:
   666   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
   667   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
   668   *     JSPB instance for transitional soy proto support:
   669   *     http://goto/soy-param-migration
   670   * @return {!Object}
   671   */
   672  proto.exec.StreamEvent.prototype.toObject = function(opt_includeInstance) {
   673    return proto.exec.StreamEvent.toObject(opt_includeInstance, this);
   674  };
   675  
   676  
   677  /**
   678   * Static version of the {@see toObject} method.
   679   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
   680   *     the JSPB instance for transitional soy proto support:
   681   *     http://goto/soy-param-migration
   682   * @param {!proto.exec.StreamEvent} msg The msg instance to transform.
   683   * @return {!Object}
   684   * @suppress {unusedLocalVariables} f is only used for nested messages
   685   */
   686  proto.exec.StreamEvent.toObject = function(includeInstance, msg) {
   687    var f, obj = {
   688      beginblock: (f = msg.getBeginblock()) && proto.exec.BeginBlock.toObject(includeInstance, f),
   689      begintx: (f = msg.getBegintx()) && proto.exec.BeginTx.toObject(includeInstance, f),
   690      envelope: (f = msg.getEnvelope()) && txs_pb.Envelope.toObject(includeInstance, f),
   691      event: (f = msg.getEvent()) && proto.exec.Event.toObject(includeInstance, f),
   692      endtx: (f = msg.getEndtx()) && proto.exec.EndTx.toObject(includeInstance, f),
   693      endblock: (f = msg.getEndblock()) && proto.exec.EndBlock.toObject(includeInstance, f)
   694    };
   695  
   696    if (includeInstance) {
   697      obj.$jspbMessageInstance = msg;
   698    }
   699    return obj;
   700  };
   701  }
   702  
   703  
   704  /**
   705   * Deserializes binary data (in protobuf wire format).
   706   * @param {jspb.ByteSource} bytes The bytes to deserialize.
   707   * @return {!proto.exec.StreamEvent}
   708   */
   709  proto.exec.StreamEvent.deserializeBinary = function(bytes) {
   710    var reader = new jspb.BinaryReader(bytes);
   711    var msg = new proto.exec.StreamEvent;
   712    return proto.exec.StreamEvent.deserializeBinaryFromReader(msg, reader);
   713  };
   714  
   715  
   716  /**
   717   * Deserializes binary data (in protobuf wire format) from the
   718   * given reader into the given message object.
   719   * @param {!proto.exec.StreamEvent} msg The message object to deserialize into.
   720   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
   721   * @return {!proto.exec.StreamEvent}
   722   */
   723  proto.exec.StreamEvent.deserializeBinaryFromReader = function(msg, reader) {
   724    while (reader.nextField()) {
   725      if (reader.isEndGroup()) {
   726        break;
   727      }
   728      var field = reader.getFieldNumber();
   729      switch (field) {
   730      case 1:
   731        var value = new proto.exec.BeginBlock;
   732        reader.readMessage(value,proto.exec.BeginBlock.deserializeBinaryFromReader);
   733        msg.setBeginblock(value);
   734        break;
   735      case 2:
   736        var value = new proto.exec.BeginTx;
   737        reader.readMessage(value,proto.exec.BeginTx.deserializeBinaryFromReader);
   738        msg.setBegintx(value);
   739        break;
   740      case 3:
   741        var value = new txs_pb.Envelope;
   742        reader.readMessage(value,txs_pb.Envelope.deserializeBinaryFromReader);
   743        msg.setEnvelope(value);
   744        break;
   745      case 4:
   746        var value = new proto.exec.Event;
   747        reader.readMessage(value,proto.exec.Event.deserializeBinaryFromReader);
   748        msg.setEvent(value);
   749        break;
   750      case 5:
   751        var value = new proto.exec.EndTx;
   752        reader.readMessage(value,proto.exec.EndTx.deserializeBinaryFromReader);
   753        msg.setEndtx(value);
   754        break;
   755      case 6:
   756        var value = new proto.exec.EndBlock;
   757        reader.readMessage(value,proto.exec.EndBlock.deserializeBinaryFromReader);
   758        msg.setEndblock(value);
   759        break;
   760      default:
   761        reader.skipField();
   762        break;
   763      }
   764    }
   765    return msg;
   766  };
   767  
   768  
   769  /**
   770   * Serializes the message to binary data (in protobuf wire format).
   771   * @return {!Uint8Array}
   772   */
   773  proto.exec.StreamEvent.prototype.serializeBinary = function() {
   774    var writer = new jspb.BinaryWriter();
   775    proto.exec.StreamEvent.serializeBinaryToWriter(this, writer);
   776    return writer.getResultBuffer();
   777  };
   778  
   779  
   780  /**
   781   * Serializes the given message to binary data (in protobuf wire
   782   * format), writing to the given BinaryWriter.
   783   * @param {!proto.exec.StreamEvent} message
   784   * @param {!jspb.BinaryWriter} writer
   785   * @suppress {unusedLocalVariables} f is only used for nested messages
   786   */
   787  proto.exec.StreamEvent.serializeBinaryToWriter = function(message, writer) {
   788    var f = undefined;
   789    f = message.getBeginblock();
   790    if (f != null) {
   791      writer.writeMessage(
   792        1,
   793        f,
   794        proto.exec.BeginBlock.serializeBinaryToWriter
   795      );
   796    }
   797    f = message.getBegintx();
   798    if (f != null) {
   799      writer.writeMessage(
   800        2,
   801        f,
   802        proto.exec.BeginTx.serializeBinaryToWriter
   803      );
   804    }
   805    f = message.getEnvelope();
   806    if (f != null) {
   807      writer.writeMessage(
   808        3,
   809        f,
   810        txs_pb.Envelope.serializeBinaryToWriter
   811      );
   812    }
   813    f = message.getEvent();
   814    if (f != null) {
   815      writer.writeMessage(
   816        4,
   817        f,
   818        proto.exec.Event.serializeBinaryToWriter
   819      );
   820    }
   821    f = message.getEndtx();
   822    if (f != null) {
   823      writer.writeMessage(
   824        5,
   825        f,
   826        proto.exec.EndTx.serializeBinaryToWriter
   827      );
   828    }
   829    f = message.getEndblock();
   830    if (f != null) {
   831      writer.writeMessage(
   832        6,
   833        f,
   834        proto.exec.EndBlock.serializeBinaryToWriter
   835      );
   836    }
   837  };
   838  
   839  
   840  /**
   841   * optional BeginBlock BeginBlock = 1;
   842   * @return {?proto.exec.BeginBlock}
   843   */
   844  proto.exec.StreamEvent.prototype.getBeginblock = function() {
   845    return /** @type{?proto.exec.BeginBlock} */ (
   846      jspb.Message.getWrapperField(this, proto.exec.BeginBlock, 1));
   847  };
   848  
   849  
   850  /**
   851   * @param {?proto.exec.BeginBlock|undefined} value
   852   * @return {!proto.exec.StreamEvent} returns this
   853  */
   854  proto.exec.StreamEvent.prototype.setBeginblock = function(value) {
   855    return jspb.Message.setWrapperField(this, 1, value);
   856  };
   857  
   858  
   859  /**
   860   * Clears the message field making it undefined.
   861   * @return {!proto.exec.StreamEvent} returns this
   862   */
   863  proto.exec.StreamEvent.prototype.clearBeginblock = function() {
   864    return this.setBeginblock(undefined);
   865  };
   866  
   867  
   868  /**
   869   * Returns whether this field is set.
   870   * @return {boolean}
   871   */
   872  proto.exec.StreamEvent.prototype.hasBeginblock = function() {
   873    return jspb.Message.getField(this, 1) != null;
   874  };
   875  
   876  
   877  /**
   878   * optional BeginTx BeginTx = 2;
   879   * @return {?proto.exec.BeginTx}
   880   */
   881  proto.exec.StreamEvent.prototype.getBegintx = function() {
   882    return /** @type{?proto.exec.BeginTx} */ (
   883      jspb.Message.getWrapperField(this, proto.exec.BeginTx, 2));
   884  };
   885  
   886  
   887  /**
   888   * @param {?proto.exec.BeginTx|undefined} value
   889   * @return {!proto.exec.StreamEvent} returns this
   890  */
   891  proto.exec.StreamEvent.prototype.setBegintx = function(value) {
   892    return jspb.Message.setWrapperField(this, 2, value);
   893  };
   894  
   895  
   896  /**
   897   * Clears the message field making it undefined.
   898   * @return {!proto.exec.StreamEvent} returns this
   899   */
   900  proto.exec.StreamEvent.prototype.clearBegintx = function() {
   901    return this.setBegintx(undefined);
   902  };
   903  
   904  
   905  /**
   906   * Returns whether this field is set.
   907   * @return {boolean}
   908   */
   909  proto.exec.StreamEvent.prototype.hasBegintx = function() {
   910    return jspb.Message.getField(this, 2) != null;
   911  };
   912  
   913  
   914  /**
   915   * optional txs.Envelope Envelope = 3;
   916   * @return {?proto.txs.Envelope}
   917   */
   918  proto.exec.StreamEvent.prototype.getEnvelope = function() {
   919    return /** @type{?proto.txs.Envelope} */ (
   920      jspb.Message.getWrapperField(this, txs_pb.Envelope, 3));
   921  };
   922  
   923  
   924  /**
   925   * @param {?proto.txs.Envelope|undefined} value
   926   * @return {!proto.exec.StreamEvent} returns this
   927  */
   928  proto.exec.StreamEvent.prototype.setEnvelope = function(value) {
   929    return jspb.Message.setWrapperField(this, 3, value);
   930  };
   931  
   932  
   933  /**
   934   * Clears the message field making it undefined.
   935   * @return {!proto.exec.StreamEvent} returns this
   936   */
   937  proto.exec.StreamEvent.prototype.clearEnvelope = function() {
   938    return this.setEnvelope(undefined);
   939  };
   940  
   941  
   942  /**
   943   * Returns whether this field is set.
   944   * @return {boolean}
   945   */
   946  proto.exec.StreamEvent.prototype.hasEnvelope = function() {
   947    return jspb.Message.getField(this, 3) != null;
   948  };
   949  
   950  
   951  /**
   952   * optional Event Event = 4;
   953   * @return {?proto.exec.Event}
   954   */
   955  proto.exec.StreamEvent.prototype.getEvent = function() {
   956    return /** @type{?proto.exec.Event} */ (
   957      jspb.Message.getWrapperField(this, proto.exec.Event, 4));
   958  };
   959  
   960  
   961  /**
   962   * @param {?proto.exec.Event|undefined} value
   963   * @return {!proto.exec.StreamEvent} returns this
   964  */
   965  proto.exec.StreamEvent.prototype.setEvent = function(value) {
   966    return jspb.Message.setWrapperField(this, 4, value);
   967  };
   968  
   969  
   970  /**
   971   * Clears the message field making it undefined.
   972   * @return {!proto.exec.StreamEvent} returns this
   973   */
   974  proto.exec.StreamEvent.prototype.clearEvent = function() {
   975    return this.setEvent(undefined);
   976  };
   977  
   978  
   979  /**
   980   * Returns whether this field is set.
   981   * @return {boolean}
   982   */
   983  proto.exec.StreamEvent.prototype.hasEvent = function() {
   984    return jspb.Message.getField(this, 4) != null;
   985  };
   986  
   987  
   988  /**
   989   * optional EndTx EndTx = 5;
   990   * @return {?proto.exec.EndTx}
   991   */
   992  proto.exec.StreamEvent.prototype.getEndtx = function() {
   993    return /** @type{?proto.exec.EndTx} */ (
   994      jspb.Message.getWrapperField(this, proto.exec.EndTx, 5));
   995  };
   996  
   997  
   998  /**
   999   * @param {?proto.exec.EndTx|undefined} value
  1000   * @return {!proto.exec.StreamEvent} returns this
  1001  */
  1002  proto.exec.StreamEvent.prototype.setEndtx = function(value) {
  1003    return jspb.Message.setWrapperField(this, 5, value);
  1004  };
  1005  
  1006  
  1007  /**
  1008   * Clears the message field making it undefined.
  1009   * @return {!proto.exec.StreamEvent} returns this
  1010   */
  1011  proto.exec.StreamEvent.prototype.clearEndtx = function() {
  1012    return this.setEndtx(undefined);
  1013  };
  1014  
  1015  
  1016  /**
  1017   * Returns whether this field is set.
  1018   * @return {boolean}
  1019   */
  1020  proto.exec.StreamEvent.prototype.hasEndtx = function() {
  1021    return jspb.Message.getField(this, 5) != null;
  1022  };
  1023  
  1024  
  1025  /**
  1026   * optional EndBlock EndBlock = 6;
  1027   * @return {?proto.exec.EndBlock}
  1028   */
  1029  proto.exec.StreamEvent.prototype.getEndblock = function() {
  1030    return /** @type{?proto.exec.EndBlock} */ (
  1031      jspb.Message.getWrapperField(this, proto.exec.EndBlock, 6));
  1032  };
  1033  
  1034  
  1035  /**
  1036   * @param {?proto.exec.EndBlock|undefined} value
  1037   * @return {!proto.exec.StreamEvent} returns this
  1038  */
  1039  proto.exec.StreamEvent.prototype.setEndblock = function(value) {
  1040    return jspb.Message.setWrapperField(this, 6, value);
  1041  };
  1042  
  1043  
  1044  /**
  1045   * Clears the message field making it undefined.
  1046   * @return {!proto.exec.StreamEvent} returns this
  1047   */
  1048  proto.exec.StreamEvent.prototype.clearEndblock = function() {
  1049    return this.setEndblock(undefined);
  1050  };
  1051  
  1052  
  1053  /**
  1054   * Returns whether this field is set.
  1055   * @return {boolean}
  1056   */
  1057  proto.exec.StreamEvent.prototype.hasEndblock = function() {
  1058    return jspb.Message.getField(this, 6) != null;
  1059  };
  1060  
  1061  
  1062  
  1063  
  1064  
  1065  if (jspb.Message.GENERATE_TO_OBJECT) {
  1066  /**
  1067   * Creates an object representation of this proto.
  1068   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  1069   * Optional fields that are not set will be set to undefined.
  1070   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  1071   * For the list of reserved names please see:
  1072   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  1073   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  1074   *     JSPB instance for transitional soy proto support:
  1075   *     http://goto/soy-param-migration
  1076   * @return {!Object}
  1077   */
  1078  proto.exec.BeginBlock.prototype.toObject = function(opt_includeInstance) {
  1079    return proto.exec.BeginBlock.toObject(opt_includeInstance, this);
  1080  };
  1081  
  1082  
  1083  /**
  1084   * Static version of the {@see toObject} method.
  1085   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  1086   *     the JSPB instance for transitional soy proto support:
  1087   *     http://goto/soy-param-migration
  1088   * @param {!proto.exec.BeginBlock} msg The msg instance to transform.
  1089   * @return {!Object}
  1090   * @suppress {unusedLocalVariables} f is only used for nested messages
  1091   */
  1092  proto.exec.BeginBlock.toObject = function(includeInstance, msg) {
  1093    var f, obj = {
  1094      height: jspb.Message.getFieldWithDefault(msg, 1, 0),
  1095      numtxs: jspb.Message.getFieldWithDefault(msg, 3, 0),
  1096      predecessorheight: jspb.Message.getFieldWithDefault(msg, 4, 0),
  1097      header: (f = msg.getHeader()) && tendermint_types_types_pb.Header.toObject(includeInstance, f)
  1098    };
  1099  
  1100    if (includeInstance) {
  1101      obj.$jspbMessageInstance = msg;
  1102    }
  1103    return obj;
  1104  };
  1105  }
  1106  
  1107  
  1108  /**
  1109   * Deserializes binary data (in protobuf wire format).
  1110   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  1111   * @return {!proto.exec.BeginBlock}
  1112   */
  1113  proto.exec.BeginBlock.deserializeBinary = function(bytes) {
  1114    var reader = new jspb.BinaryReader(bytes);
  1115    var msg = new proto.exec.BeginBlock;
  1116    return proto.exec.BeginBlock.deserializeBinaryFromReader(msg, reader);
  1117  };
  1118  
  1119  
  1120  /**
  1121   * Deserializes binary data (in protobuf wire format) from the
  1122   * given reader into the given message object.
  1123   * @param {!proto.exec.BeginBlock} msg The message object to deserialize into.
  1124   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  1125   * @return {!proto.exec.BeginBlock}
  1126   */
  1127  proto.exec.BeginBlock.deserializeBinaryFromReader = function(msg, reader) {
  1128    while (reader.nextField()) {
  1129      if (reader.isEndGroup()) {
  1130        break;
  1131      }
  1132      var field = reader.getFieldNumber();
  1133      switch (field) {
  1134      case 1:
  1135        var value = /** @type {number} */ (reader.readUint64());
  1136        msg.setHeight(value);
  1137        break;
  1138      case 3:
  1139        var value = /** @type {number} */ (reader.readUint64());
  1140        msg.setNumtxs(value);
  1141        break;
  1142      case 4:
  1143        var value = /** @type {number} */ (reader.readUint64());
  1144        msg.setPredecessorheight(value);
  1145        break;
  1146      case 2:
  1147        var value = new tendermint_types_types_pb.Header;
  1148        reader.readMessage(value,tendermint_types_types_pb.Header.deserializeBinaryFromReader);
  1149        msg.setHeader(value);
  1150        break;
  1151      default:
  1152        reader.skipField();
  1153        break;
  1154      }
  1155    }
  1156    return msg;
  1157  };
  1158  
  1159  
  1160  /**
  1161   * Serializes the message to binary data (in protobuf wire format).
  1162   * @return {!Uint8Array}
  1163   */
  1164  proto.exec.BeginBlock.prototype.serializeBinary = function() {
  1165    var writer = new jspb.BinaryWriter();
  1166    proto.exec.BeginBlock.serializeBinaryToWriter(this, writer);
  1167    return writer.getResultBuffer();
  1168  };
  1169  
  1170  
  1171  /**
  1172   * Serializes the given message to binary data (in protobuf wire
  1173   * format), writing to the given BinaryWriter.
  1174   * @param {!proto.exec.BeginBlock} message
  1175   * @param {!jspb.BinaryWriter} writer
  1176   * @suppress {unusedLocalVariables} f is only used for nested messages
  1177   */
  1178  proto.exec.BeginBlock.serializeBinaryToWriter = function(message, writer) {
  1179    var f = undefined;
  1180    f = message.getHeight();
  1181    if (f !== 0) {
  1182      writer.writeUint64(
  1183        1,
  1184        f
  1185      );
  1186    }
  1187    f = message.getNumtxs();
  1188    if (f !== 0) {
  1189      writer.writeUint64(
  1190        3,
  1191        f
  1192      );
  1193    }
  1194    f = message.getPredecessorheight();
  1195    if (f !== 0) {
  1196      writer.writeUint64(
  1197        4,
  1198        f
  1199      );
  1200    }
  1201    f = message.getHeader();
  1202    if (f != null) {
  1203      writer.writeMessage(
  1204        2,
  1205        f,
  1206        tendermint_types_types_pb.Header.serializeBinaryToWriter
  1207      );
  1208    }
  1209  };
  1210  
  1211  
  1212  /**
  1213   * optional uint64 Height = 1;
  1214   * @return {number}
  1215   */
  1216  proto.exec.BeginBlock.prototype.getHeight = function() {
  1217    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0));
  1218  };
  1219  
  1220  
  1221  /**
  1222   * @param {number} value
  1223   * @return {!proto.exec.BeginBlock} returns this
  1224   */
  1225  proto.exec.BeginBlock.prototype.setHeight = function(value) {
  1226    return jspb.Message.setProto3IntField(this, 1, value);
  1227  };
  1228  
  1229  
  1230  /**
  1231   * optional uint64 NumTxs = 3;
  1232   * @return {number}
  1233   */
  1234  proto.exec.BeginBlock.prototype.getNumtxs = function() {
  1235    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));
  1236  };
  1237  
  1238  
  1239  /**
  1240   * @param {number} value
  1241   * @return {!proto.exec.BeginBlock} returns this
  1242   */
  1243  proto.exec.BeginBlock.prototype.setNumtxs = function(value) {
  1244    return jspb.Message.setProto3IntField(this, 3, value);
  1245  };
  1246  
  1247  
  1248  /**
  1249   * optional uint64 PredecessorHeight = 4;
  1250   * @return {number}
  1251   */
  1252  proto.exec.BeginBlock.prototype.getPredecessorheight = function() {
  1253    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0));
  1254  };
  1255  
  1256  
  1257  /**
  1258   * @param {number} value
  1259   * @return {!proto.exec.BeginBlock} returns this
  1260   */
  1261  proto.exec.BeginBlock.prototype.setPredecessorheight = function(value) {
  1262    return jspb.Message.setProto3IntField(this, 4, value);
  1263  };
  1264  
  1265  
  1266  /**
  1267   * optional tendermint.types.Header Header = 2;
  1268   * @return {?proto.tendermint.types.Header}
  1269   */
  1270  proto.exec.BeginBlock.prototype.getHeader = function() {
  1271    return /** @type{?proto.tendermint.types.Header} */ (
  1272      jspb.Message.getWrapperField(this, tendermint_types_types_pb.Header, 2));
  1273  };
  1274  
  1275  
  1276  /**
  1277   * @param {?proto.tendermint.types.Header|undefined} value
  1278   * @return {!proto.exec.BeginBlock} returns this
  1279  */
  1280  proto.exec.BeginBlock.prototype.setHeader = function(value) {
  1281    return jspb.Message.setWrapperField(this, 2, value);
  1282  };
  1283  
  1284  
  1285  /**
  1286   * Clears the message field making it undefined.
  1287   * @return {!proto.exec.BeginBlock} returns this
  1288   */
  1289  proto.exec.BeginBlock.prototype.clearHeader = function() {
  1290    return this.setHeader(undefined);
  1291  };
  1292  
  1293  
  1294  /**
  1295   * Returns whether this field is set.
  1296   * @return {boolean}
  1297   */
  1298  proto.exec.BeginBlock.prototype.hasHeader = function() {
  1299    return jspb.Message.getField(this, 2) != null;
  1300  };
  1301  
  1302  
  1303  
  1304  
  1305  
  1306  if (jspb.Message.GENERATE_TO_OBJECT) {
  1307  /**
  1308   * Creates an object representation of this proto.
  1309   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  1310   * Optional fields that are not set will be set to undefined.
  1311   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  1312   * For the list of reserved names please see:
  1313   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  1314   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  1315   *     JSPB instance for transitional soy proto support:
  1316   *     http://goto/soy-param-migration
  1317   * @return {!Object}
  1318   */
  1319  proto.exec.EndBlock.prototype.toObject = function(opt_includeInstance) {
  1320    return proto.exec.EndBlock.toObject(opt_includeInstance, this);
  1321  };
  1322  
  1323  
  1324  /**
  1325   * Static version of the {@see toObject} method.
  1326   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  1327   *     the JSPB instance for transitional soy proto support:
  1328   *     http://goto/soy-param-migration
  1329   * @param {!proto.exec.EndBlock} msg The msg instance to transform.
  1330   * @return {!Object}
  1331   * @suppress {unusedLocalVariables} f is only used for nested messages
  1332   */
  1333  proto.exec.EndBlock.toObject = function(includeInstance, msg) {
  1334    var f, obj = {
  1335      height: jspb.Message.getFieldWithDefault(msg, 1, 0)
  1336    };
  1337  
  1338    if (includeInstance) {
  1339      obj.$jspbMessageInstance = msg;
  1340    }
  1341    return obj;
  1342  };
  1343  }
  1344  
  1345  
  1346  /**
  1347   * Deserializes binary data (in protobuf wire format).
  1348   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  1349   * @return {!proto.exec.EndBlock}
  1350   */
  1351  proto.exec.EndBlock.deserializeBinary = function(bytes) {
  1352    var reader = new jspb.BinaryReader(bytes);
  1353    var msg = new proto.exec.EndBlock;
  1354    return proto.exec.EndBlock.deserializeBinaryFromReader(msg, reader);
  1355  };
  1356  
  1357  
  1358  /**
  1359   * Deserializes binary data (in protobuf wire format) from the
  1360   * given reader into the given message object.
  1361   * @param {!proto.exec.EndBlock} msg The message object to deserialize into.
  1362   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  1363   * @return {!proto.exec.EndBlock}
  1364   */
  1365  proto.exec.EndBlock.deserializeBinaryFromReader = function(msg, reader) {
  1366    while (reader.nextField()) {
  1367      if (reader.isEndGroup()) {
  1368        break;
  1369      }
  1370      var field = reader.getFieldNumber();
  1371      switch (field) {
  1372      case 1:
  1373        var value = /** @type {number} */ (reader.readUint64());
  1374        msg.setHeight(value);
  1375        break;
  1376      default:
  1377        reader.skipField();
  1378        break;
  1379      }
  1380    }
  1381    return msg;
  1382  };
  1383  
  1384  
  1385  /**
  1386   * Serializes the message to binary data (in protobuf wire format).
  1387   * @return {!Uint8Array}
  1388   */
  1389  proto.exec.EndBlock.prototype.serializeBinary = function() {
  1390    var writer = new jspb.BinaryWriter();
  1391    proto.exec.EndBlock.serializeBinaryToWriter(this, writer);
  1392    return writer.getResultBuffer();
  1393  };
  1394  
  1395  
  1396  /**
  1397   * Serializes the given message to binary data (in protobuf wire
  1398   * format), writing to the given BinaryWriter.
  1399   * @param {!proto.exec.EndBlock} message
  1400   * @param {!jspb.BinaryWriter} writer
  1401   * @suppress {unusedLocalVariables} f is only used for nested messages
  1402   */
  1403  proto.exec.EndBlock.serializeBinaryToWriter = function(message, writer) {
  1404    var f = undefined;
  1405    f = message.getHeight();
  1406    if (f !== 0) {
  1407      writer.writeUint64(
  1408        1,
  1409        f
  1410      );
  1411    }
  1412  };
  1413  
  1414  
  1415  /**
  1416   * optional uint64 Height = 1;
  1417   * @return {number}
  1418   */
  1419  proto.exec.EndBlock.prototype.getHeight = function() {
  1420    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0));
  1421  };
  1422  
  1423  
  1424  /**
  1425   * @param {number} value
  1426   * @return {!proto.exec.EndBlock} returns this
  1427   */
  1428  proto.exec.EndBlock.prototype.setHeight = function(value) {
  1429    return jspb.Message.setProto3IntField(this, 1, value);
  1430  };
  1431  
  1432  
  1433  
  1434  
  1435  
  1436  if (jspb.Message.GENERATE_TO_OBJECT) {
  1437  /**
  1438   * Creates an object representation of this proto.
  1439   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  1440   * Optional fields that are not set will be set to undefined.
  1441   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  1442   * For the list of reserved names please see:
  1443   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  1444   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  1445   *     JSPB instance for transitional soy proto support:
  1446   *     http://goto/soy-param-migration
  1447   * @return {!Object}
  1448   */
  1449  proto.exec.BeginTx.prototype.toObject = function(opt_includeInstance) {
  1450    return proto.exec.BeginTx.toObject(opt_includeInstance, this);
  1451  };
  1452  
  1453  
  1454  /**
  1455   * Static version of the {@see toObject} method.
  1456   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  1457   *     the JSPB instance for transitional soy proto support:
  1458   *     http://goto/soy-param-migration
  1459   * @param {!proto.exec.BeginTx} msg The msg instance to transform.
  1460   * @return {!Object}
  1461   * @suppress {unusedLocalVariables} f is only used for nested messages
  1462   */
  1463  proto.exec.BeginTx.toObject = function(includeInstance, msg) {
  1464    var f, obj = {
  1465      txheader: (f = msg.getTxheader()) && proto.exec.TxHeader.toObject(includeInstance, f),
  1466      numevents: jspb.Message.getFieldWithDefault(msg, 5, 0),
  1467      result: (f = msg.getResult()) && proto.exec.Result.toObject(includeInstance, f),
  1468      exception: (f = msg.getException()) && errors_pb.Exception.toObject(includeInstance, f)
  1469    };
  1470  
  1471    if (includeInstance) {
  1472      obj.$jspbMessageInstance = msg;
  1473    }
  1474    return obj;
  1475  };
  1476  }
  1477  
  1478  
  1479  /**
  1480   * Deserializes binary data (in protobuf wire format).
  1481   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  1482   * @return {!proto.exec.BeginTx}
  1483   */
  1484  proto.exec.BeginTx.deserializeBinary = function(bytes) {
  1485    var reader = new jspb.BinaryReader(bytes);
  1486    var msg = new proto.exec.BeginTx;
  1487    return proto.exec.BeginTx.deserializeBinaryFromReader(msg, reader);
  1488  };
  1489  
  1490  
  1491  /**
  1492   * Deserializes binary data (in protobuf wire format) from the
  1493   * given reader into the given message object.
  1494   * @param {!proto.exec.BeginTx} msg The message object to deserialize into.
  1495   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  1496   * @return {!proto.exec.BeginTx}
  1497   */
  1498  proto.exec.BeginTx.deserializeBinaryFromReader = function(msg, reader) {
  1499    while (reader.nextField()) {
  1500      if (reader.isEndGroup()) {
  1501        break;
  1502      }
  1503      var field = reader.getFieldNumber();
  1504      switch (field) {
  1505      case 1:
  1506        var value = new proto.exec.TxHeader;
  1507        reader.readMessage(value,proto.exec.TxHeader.deserializeBinaryFromReader);
  1508        msg.setTxheader(value);
  1509        break;
  1510      case 5:
  1511        var value = /** @type {number} */ (reader.readUint64());
  1512        msg.setNumevents(value);
  1513        break;
  1514      case 2:
  1515        var value = new proto.exec.Result;
  1516        reader.readMessage(value,proto.exec.Result.deserializeBinaryFromReader);
  1517        msg.setResult(value);
  1518        break;
  1519      case 4:
  1520        var value = new errors_pb.Exception;
  1521        reader.readMessage(value,errors_pb.Exception.deserializeBinaryFromReader);
  1522        msg.setException(value);
  1523        break;
  1524      default:
  1525        reader.skipField();
  1526        break;
  1527      }
  1528    }
  1529    return msg;
  1530  };
  1531  
  1532  
  1533  /**
  1534   * Serializes the message to binary data (in protobuf wire format).
  1535   * @return {!Uint8Array}
  1536   */
  1537  proto.exec.BeginTx.prototype.serializeBinary = function() {
  1538    var writer = new jspb.BinaryWriter();
  1539    proto.exec.BeginTx.serializeBinaryToWriter(this, writer);
  1540    return writer.getResultBuffer();
  1541  };
  1542  
  1543  
  1544  /**
  1545   * Serializes the given message to binary data (in protobuf wire
  1546   * format), writing to the given BinaryWriter.
  1547   * @param {!proto.exec.BeginTx} message
  1548   * @param {!jspb.BinaryWriter} writer
  1549   * @suppress {unusedLocalVariables} f is only used for nested messages
  1550   */
  1551  proto.exec.BeginTx.serializeBinaryToWriter = function(message, writer) {
  1552    var f = undefined;
  1553    f = message.getTxheader();
  1554    if (f != null) {
  1555      writer.writeMessage(
  1556        1,
  1557        f,
  1558        proto.exec.TxHeader.serializeBinaryToWriter
  1559      );
  1560    }
  1561    f = message.getNumevents();
  1562    if (f !== 0) {
  1563      writer.writeUint64(
  1564        5,
  1565        f
  1566      );
  1567    }
  1568    f = message.getResult();
  1569    if (f != null) {
  1570      writer.writeMessage(
  1571        2,
  1572        f,
  1573        proto.exec.Result.serializeBinaryToWriter
  1574      );
  1575    }
  1576    f = message.getException();
  1577    if (f != null) {
  1578      writer.writeMessage(
  1579        4,
  1580        f,
  1581        errors_pb.Exception.serializeBinaryToWriter
  1582      );
  1583    }
  1584  };
  1585  
  1586  
  1587  /**
  1588   * optional TxHeader TxHeader = 1;
  1589   * @return {?proto.exec.TxHeader}
  1590   */
  1591  proto.exec.BeginTx.prototype.getTxheader = function() {
  1592    return /** @type{?proto.exec.TxHeader} */ (
  1593      jspb.Message.getWrapperField(this, proto.exec.TxHeader, 1));
  1594  };
  1595  
  1596  
  1597  /**
  1598   * @param {?proto.exec.TxHeader|undefined} value
  1599   * @return {!proto.exec.BeginTx} returns this
  1600  */
  1601  proto.exec.BeginTx.prototype.setTxheader = function(value) {
  1602    return jspb.Message.setWrapperField(this, 1, value);
  1603  };
  1604  
  1605  
  1606  /**
  1607   * Clears the message field making it undefined.
  1608   * @return {!proto.exec.BeginTx} returns this
  1609   */
  1610  proto.exec.BeginTx.prototype.clearTxheader = function() {
  1611    return this.setTxheader(undefined);
  1612  };
  1613  
  1614  
  1615  /**
  1616   * Returns whether this field is set.
  1617   * @return {boolean}
  1618   */
  1619  proto.exec.BeginTx.prototype.hasTxheader = function() {
  1620    return jspb.Message.getField(this, 1) != null;
  1621  };
  1622  
  1623  
  1624  /**
  1625   * optional uint64 NumEvents = 5;
  1626   * @return {number}
  1627   */
  1628  proto.exec.BeginTx.prototype.getNumevents = function() {
  1629    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0));
  1630  };
  1631  
  1632  
  1633  /**
  1634   * @param {number} value
  1635   * @return {!proto.exec.BeginTx} returns this
  1636   */
  1637  proto.exec.BeginTx.prototype.setNumevents = function(value) {
  1638    return jspb.Message.setProto3IntField(this, 5, value);
  1639  };
  1640  
  1641  
  1642  /**
  1643   * optional Result Result = 2;
  1644   * @return {?proto.exec.Result}
  1645   */
  1646  proto.exec.BeginTx.prototype.getResult = function() {
  1647    return /** @type{?proto.exec.Result} */ (
  1648      jspb.Message.getWrapperField(this, proto.exec.Result, 2));
  1649  };
  1650  
  1651  
  1652  /**
  1653   * @param {?proto.exec.Result|undefined} value
  1654   * @return {!proto.exec.BeginTx} returns this
  1655  */
  1656  proto.exec.BeginTx.prototype.setResult = function(value) {
  1657    return jspb.Message.setWrapperField(this, 2, value);
  1658  };
  1659  
  1660  
  1661  /**
  1662   * Clears the message field making it undefined.
  1663   * @return {!proto.exec.BeginTx} returns this
  1664   */
  1665  proto.exec.BeginTx.prototype.clearResult = function() {
  1666    return this.setResult(undefined);
  1667  };
  1668  
  1669  
  1670  /**
  1671   * Returns whether this field is set.
  1672   * @return {boolean}
  1673   */
  1674  proto.exec.BeginTx.prototype.hasResult = function() {
  1675    return jspb.Message.getField(this, 2) != null;
  1676  };
  1677  
  1678  
  1679  /**
  1680   * optional errors.Exception Exception = 4;
  1681   * @return {?proto.errors.Exception}
  1682   */
  1683  proto.exec.BeginTx.prototype.getException = function() {
  1684    return /** @type{?proto.errors.Exception} */ (
  1685      jspb.Message.getWrapperField(this, errors_pb.Exception, 4));
  1686  };
  1687  
  1688  
  1689  /**
  1690   * @param {?proto.errors.Exception|undefined} value
  1691   * @return {!proto.exec.BeginTx} returns this
  1692  */
  1693  proto.exec.BeginTx.prototype.setException = function(value) {
  1694    return jspb.Message.setWrapperField(this, 4, value);
  1695  };
  1696  
  1697  
  1698  /**
  1699   * Clears the message field making it undefined.
  1700   * @return {!proto.exec.BeginTx} returns this
  1701   */
  1702  proto.exec.BeginTx.prototype.clearException = function() {
  1703    return this.setException(undefined);
  1704  };
  1705  
  1706  
  1707  /**
  1708   * Returns whether this field is set.
  1709   * @return {boolean}
  1710   */
  1711  proto.exec.BeginTx.prototype.hasException = function() {
  1712    return jspb.Message.getField(this, 4) != null;
  1713  };
  1714  
  1715  
  1716  
  1717  
  1718  
  1719  if (jspb.Message.GENERATE_TO_OBJECT) {
  1720  /**
  1721   * Creates an object representation of this proto.
  1722   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  1723   * Optional fields that are not set will be set to undefined.
  1724   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  1725   * For the list of reserved names please see:
  1726   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  1727   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  1728   *     JSPB instance for transitional soy proto support:
  1729   *     http://goto/soy-param-migration
  1730   * @return {!Object}
  1731   */
  1732  proto.exec.EndTx.prototype.toObject = function(opt_includeInstance) {
  1733    return proto.exec.EndTx.toObject(opt_includeInstance, this);
  1734  };
  1735  
  1736  
  1737  /**
  1738   * Static version of the {@see toObject} method.
  1739   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  1740   *     the JSPB instance for transitional soy proto support:
  1741   *     http://goto/soy-param-migration
  1742   * @param {!proto.exec.EndTx} msg The msg instance to transform.
  1743   * @return {!Object}
  1744   * @suppress {unusedLocalVariables} f is only used for nested messages
  1745   */
  1746  proto.exec.EndTx.toObject = function(includeInstance, msg) {
  1747    var f, obj = {
  1748      txhash: msg.getTxhash_asB64()
  1749    };
  1750  
  1751    if (includeInstance) {
  1752      obj.$jspbMessageInstance = msg;
  1753    }
  1754    return obj;
  1755  };
  1756  }
  1757  
  1758  
  1759  /**
  1760   * Deserializes binary data (in protobuf wire format).
  1761   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  1762   * @return {!proto.exec.EndTx}
  1763   */
  1764  proto.exec.EndTx.deserializeBinary = function(bytes) {
  1765    var reader = new jspb.BinaryReader(bytes);
  1766    var msg = new proto.exec.EndTx;
  1767    return proto.exec.EndTx.deserializeBinaryFromReader(msg, reader);
  1768  };
  1769  
  1770  
  1771  /**
  1772   * Deserializes binary data (in protobuf wire format) from the
  1773   * given reader into the given message object.
  1774   * @param {!proto.exec.EndTx} msg The message object to deserialize into.
  1775   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  1776   * @return {!proto.exec.EndTx}
  1777   */
  1778  proto.exec.EndTx.deserializeBinaryFromReader = function(msg, reader) {
  1779    while (reader.nextField()) {
  1780      if (reader.isEndGroup()) {
  1781        break;
  1782      }
  1783      var field = reader.getFieldNumber();
  1784      switch (field) {
  1785      case 3:
  1786        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  1787        msg.setTxhash(value);
  1788        break;
  1789      default:
  1790        reader.skipField();
  1791        break;
  1792      }
  1793    }
  1794    return msg;
  1795  };
  1796  
  1797  
  1798  /**
  1799   * Serializes the message to binary data (in protobuf wire format).
  1800   * @return {!Uint8Array}
  1801   */
  1802  proto.exec.EndTx.prototype.serializeBinary = function() {
  1803    var writer = new jspb.BinaryWriter();
  1804    proto.exec.EndTx.serializeBinaryToWriter(this, writer);
  1805    return writer.getResultBuffer();
  1806  };
  1807  
  1808  
  1809  /**
  1810   * Serializes the given message to binary data (in protobuf wire
  1811   * format), writing to the given BinaryWriter.
  1812   * @param {!proto.exec.EndTx} message
  1813   * @param {!jspb.BinaryWriter} writer
  1814   * @suppress {unusedLocalVariables} f is only used for nested messages
  1815   */
  1816  proto.exec.EndTx.serializeBinaryToWriter = function(message, writer) {
  1817    var f = undefined;
  1818    f = message.getTxhash_asU8();
  1819    if (f.length > 0) {
  1820      writer.writeBytes(
  1821        3,
  1822        f
  1823      );
  1824    }
  1825  };
  1826  
  1827  
  1828  /**
  1829   * optional bytes TxHash = 3;
  1830   * @return {!(string|Uint8Array)}
  1831   */
  1832  proto.exec.EndTx.prototype.getTxhash = function() {
  1833    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
  1834  };
  1835  
  1836  
  1837  /**
  1838   * optional bytes TxHash = 3;
  1839   * This is a type-conversion wrapper around `getTxhash()`
  1840   * @return {string}
  1841   */
  1842  proto.exec.EndTx.prototype.getTxhash_asB64 = function() {
  1843    return /** @type {string} */ (jspb.Message.bytesAsB64(
  1844        this.getTxhash()));
  1845  };
  1846  
  1847  
  1848  /**
  1849   * optional bytes TxHash = 3;
  1850   * Note that Uint8Array is not supported on all browsers.
  1851   * @see http://caniuse.com/Uint8Array
  1852   * This is a type-conversion wrapper around `getTxhash()`
  1853   * @return {!Uint8Array}
  1854   */
  1855  proto.exec.EndTx.prototype.getTxhash_asU8 = function() {
  1856    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  1857        this.getTxhash()));
  1858  };
  1859  
  1860  
  1861  /**
  1862   * @param {!(string|Uint8Array)} value
  1863   * @return {!proto.exec.EndTx} returns this
  1864   */
  1865  proto.exec.EndTx.prototype.setTxhash = function(value) {
  1866    return jspb.Message.setProto3BytesField(this, 3, value);
  1867  };
  1868  
  1869  
  1870  
  1871  
  1872  
  1873  if (jspb.Message.GENERATE_TO_OBJECT) {
  1874  /**
  1875   * Creates an object representation of this proto.
  1876   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  1877   * Optional fields that are not set will be set to undefined.
  1878   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  1879   * For the list of reserved names please see:
  1880   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  1881   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  1882   *     JSPB instance for transitional soy proto support:
  1883   *     http://goto/soy-param-migration
  1884   * @return {!Object}
  1885   */
  1886  proto.exec.TxHeader.prototype.toObject = function(opt_includeInstance) {
  1887    return proto.exec.TxHeader.toObject(opt_includeInstance, this);
  1888  };
  1889  
  1890  
  1891  /**
  1892   * Static version of the {@see toObject} method.
  1893   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  1894   *     the JSPB instance for transitional soy proto support:
  1895   *     http://goto/soy-param-migration
  1896   * @param {!proto.exec.TxHeader} msg The msg instance to transform.
  1897   * @return {!Object}
  1898   * @suppress {unusedLocalVariables} f is only used for nested messages
  1899   */
  1900  proto.exec.TxHeader.toObject = function(includeInstance, msg) {
  1901    var f, obj = {
  1902      txtype: jspb.Message.getFieldWithDefault(msg, 1, 0),
  1903      txhash: msg.getTxhash_asB64(),
  1904      height: jspb.Message.getFieldWithDefault(msg, 3, 0),
  1905      index: jspb.Message.getFieldWithDefault(msg, 4, 0),
  1906      origin: (f = msg.getOrigin()) && proto.exec.Origin.toObject(includeInstance, f)
  1907    };
  1908  
  1909    if (includeInstance) {
  1910      obj.$jspbMessageInstance = msg;
  1911    }
  1912    return obj;
  1913  };
  1914  }
  1915  
  1916  
  1917  /**
  1918   * Deserializes binary data (in protobuf wire format).
  1919   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  1920   * @return {!proto.exec.TxHeader}
  1921   */
  1922  proto.exec.TxHeader.deserializeBinary = function(bytes) {
  1923    var reader = new jspb.BinaryReader(bytes);
  1924    var msg = new proto.exec.TxHeader;
  1925    return proto.exec.TxHeader.deserializeBinaryFromReader(msg, reader);
  1926  };
  1927  
  1928  
  1929  /**
  1930   * Deserializes binary data (in protobuf wire format) from the
  1931   * given reader into the given message object.
  1932   * @param {!proto.exec.TxHeader} msg The message object to deserialize into.
  1933   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  1934   * @return {!proto.exec.TxHeader}
  1935   */
  1936  proto.exec.TxHeader.deserializeBinaryFromReader = function(msg, reader) {
  1937    while (reader.nextField()) {
  1938      if (reader.isEndGroup()) {
  1939        break;
  1940      }
  1941      var field = reader.getFieldNumber();
  1942      switch (field) {
  1943      case 1:
  1944        var value = /** @type {number} */ (reader.readUint32());
  1945        msg.setTxtype(value);
  1946        break;
  1947      case 2:
  1948        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  1949        msg.setTxhash(value);
  1950        break;
  1951      case 3:
  1952        var value = /** @type {number} */ (reader.readUint64());
  1953        msg.setHeight(value);
  1954        break;
  1955      case 4:
  1956        var value = /** @type {number} */ (reader.readUint64());
  1957        msg.setIndex(value);
  1958        break;
  1959      case 5:
  1960        var value = new proto.exec.Origin;
  1961        reader.readMessage(value,proto.exec.Origin.deserializeBinaryFromReader);
  1962        msg.setOrigin(value);
  1963        break;
  1964      default:
  1965        reader.skipField();
  1966        break;
  1967      }
  1968    }
  1969    return msg;
  1970  };
  1971  
  1972  
  1973  /**
  1974   * Serializes the message to binary data (in protobuf wire format).
  1975   * @return {!Uint8Array}
  1976   */
  1977  proto.exec.TxHeader.prototype.serializeBinary = function() {
  1978    var writer = new jspb.BinaryWriter();
  1979    proto.exec.TxHeader.serializeBinaryToWriter(this, writer);
  1980    return writer.getResultBuffer();
  1981  };
  1982  
  1983  
  1984  /**
  1985   * Serializes the given message to binary data (in protobuf wire
  1986   * format), writing to the given BinaryWriter.
  1987   * @param {!proto.exec.TxHeader} message
  1988   * @param {!jspb.BinaryWriter} writer
  1989   * @suppress {unusedLocalVariables} f is only used for nested messages
  1990   */
  1991  proto.exec.TxHeader.serializeBinaryToWriter = function(message, writer) {
  1992    var f = undefined;
  1993    f = message.getTxtype();
  1994    if (f !== 0) {
  1995      writer.writeUint32(
  1996        1,
  1997        f
  1998      );
  1999    }
  2000    f = message.getTxhash_asU8();
  2001    if (f.length > 0) {
  2002      writer.writeBytes(
  2003        2,
  2004        f
  2005      );
  2006    }
  2007    f = message.getHeight();
  2008    if (f !== 0) {
  2009      writer.writeUint64(
  2010        3,
  2011        f
  2012      );
  2013    }
  2014    f = message.getIndex();
  2015    if (f !== 0) {
  2016      writer.writeUint64(
  2017        4,
  2018        f
  2019      );
  2020    }
  2021    f = message.getOrigin();
  2022    if (f != null) {
  2023      writer.writeMessage(
  2024        5,
  2025        f,
  2026        proto.exec.Origin.serializeBinaryToWriter
  2027      );
  2028    }
  2029  };
  2030  
  2031  
  2032  /**
  2033   * optional uint32 TxType = 1;
  2034   * @return {number}
  2035   */
  2036  proto.exec.TxHeader.prototype.getTxtype = function() {
  2037    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0));
  2038  };
  2039  
  2040  
  2041  /**
  2042   * @param {number} value
  2043   * @return {!proto.exec.TxHeader} returns this
  2044   */
  2045  proto.exec.TxHeader.prototype.setTxtype = function(value) {
  2046    return jspb.Message.setProto3IntField(this, 1, value);
  2047  };
  2048  
  2049  
  2050  /**
  2051   * optional bytes TxHash = 2;
  2052   * @return {!(string|Uint8Array)}
  2053   */
  2054  proto.exec.TxHeader.prototype.getTxhash = function() {
  2055    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
  2056  };
  2057  
  2058  
  2059  /**
  2060   * optional bytes TxHash = 2;
  2061   * This is a type-conversion wrapper around `getTxhash()`
  2062   * @return {string}
  2063   */
  2064  proto.exec.TxHeader.prototype.getTxhash_asB64 = function() {
  2065    return /** @type {string} */ (jspb.Message.bytesAsB64(
  2066        this.getTxhash()));
  2067  };
  2068  
  2069  
  2070  /**
  2071   * optional bytes TxHash = 2;
  2072   * Note that Uint8Array is not supported on all browsers.
  2073   * @see http://caniuse.com/Uint8Array
  2074   * This is a type-conversion wrapper around `getTxhash()`
  2075   * @return {!Uint8Array}
  2076   */
  2077  proto.exec.TxHeader.prototype.getTxhash_asU8 = function() {
  2078    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  2079        this.getTxhash()));
  2080  };
  2081  
  2082  
  2083  /**
  2084   * @param {!(string|Uint8Array)} value
  2085   * @return {!proto.exec.TxHeader} returns this
  2086   */
  2087  proto.exec.TxHeader.prototype.setTxhash = function(value) {
  2088    return jspb.Message.setProto3BytesField(this, 2, value);
  2089  };
  2090  
  2091  
  2092  /**
  2093   * optional uint64 Height = 3;
  2094   * @return {number}
  2095   */
  2096  proto.exec.TxHeader.prototype.getHeight = function() {
  2097    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));
  2098  };
  2099  
  2100  
  2101  /**
  2102   * @param {number} value
  2103   * @return {!proto.exec.TxHeader} returns this
  2104   */
  2105  proto.exec.TxHeader.prototype.setHeight = function(value) {
  2106    return jspb.Message.setProto3IntField(this, 3, value);
  2107  };
  2108  
  2109  
  2110  /**
  2111   * optional uint64 Index = 4;
  2112   * @return {number}
  2113   */
  2114  proto.exec.TxHeader.prototype.getIndex = function() {
  2115    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0));
  2116  };
  2117  
  2118  
  2119  /**
  2120   * @param {number} value
  2121   * @return {!proto.exec.TxHeader} returns this
  2122   */
  2123  proto.exec.TxHeader.prototype.setIndex = function(value) {
  2124    return jspb.Message.setProto3IntField(this, 4, value);
  2125  };
  2126  
  2127  
  2128  /**
  2129   * optional Origin Origin = 5;
  2130   * @return {?proto.exec.Origin}
  2131   */
  2132  proto.exec.TxHeader.prototype.getOrigin = function() {
  2133    return /** @type{?proto.exec.Origin} */ (
  2134      jspb.Message.getWrapperField(this, proto.exec.Origin, 5));
  2135  };
  2136  
  2137  
  2138  /**
  2139   * @param {?proto.exec.Origin|undefined} value
  2140   * @return {!proto.exec.TxHeader} returns this
  2141  */
  2142  proto.exec.TxHeader.prototype.setOrigin = function(value) {
  2143    return jspb.Message.setWrapperField(this, 5, value);
  2144  };
  2145  
  2146  
  2147  /**
  2148   * Clears the message field making it undefined.
  2149   * @return {!proto.exec.TxHeader} returns this
  2150   */
  2151  proto.exec.TxHeader.prototype.clearOrigin = function() {
  2152    return this.setOrigin(undefined);
  2153  };
  2154  
  2155  
  2156  /**
  2157   * Returns whether this field is set.
  2158   * @return {boolean}
  2159   */
  2160  proto.exec.TxHeader.prototype.hasOrigin = function() {
  2161    return jspb.Message.getField(this, 5) != null;
  2162  };
  2163  
  2164  
  2165  
  2166  /**
  2167   * List of repeated fields within this message type.
  2168   * @private {!Array<number>}
  2169   * @const
  2170   */
  2171  proto.exec.BlockExecution.repeatedFields_ = [3];
  2172  
  2173  
  2174  
  2175  if (jspb.Message.GENERATE_TO_OBJECT) {
  2176  /**
  2177   * Creates an object representation of this proto.
  2178   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  2179   * Optional fields that are not set will be set to undefined.
  2180   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  2181   * For the list of reserved names please see:
  2182   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  2183   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  2184   *     JSPB instance for transitional soy proto support:
  2185   *     http://goto/soy-param-migration
  2186   * @return {!Object}
  2187   */
  2188  proto.exec.BlockExecution.prototype.toObject = function(opt_includeInstance) {
  2189    return proto.exec.BlockExecution.toObject(opt_includeInstance, this);
  2190  };
  2191  
  2192  
  2193  /**
  2194   * Static version of the {@see toObject} method.
  2195   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  2196   *     the JSPB instance for transitional soy proto support:
  2197   *     http://goto/soy-param-migration
  2198   * @param {!proto.exec.BlockExecution} msg The msg instance to transform.
  2199   * @return {!Object}
  2200   * @suppress {unusedLocalVariables} f is only used for nested messages
  2201   */
  2202  proto.exec.BlockExecution.toObject = function(includeInstance, msg) {
  2203    var f, obj = {
  2204      height: jspb.Message.getFieldWithDefault(msg, 1, 0),
  2205      predecessorheight: jspb.Message.getFieldWithDefault(msg, 4, 0),
  2206      header: (f = msg.getHeader()) && tendermint_types_types_pb.Header.toObject(includeInstance, f),
  2207      txexecutionsList: jspb.Message.toObjectList(msg.getTxexecutionsList(),
  2208      proto.exec.TxExecution.toObject, includeInstance)
  2209    };
  2210  
  2211    if (includeInstance) {
  2212      obj.$jspbMessageInstance = msg;
  2213    }
  2214    return obj;
  2215  };
  2216  }
  2217  
  2218  
  2219  /**
  2220   * Deserializes binary data (in protobuf wire format).
  2221   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  2222   * @return {!proto.exec.BlockExecution}
  2223   */
  2224  proto.exec.BlockExecution.deserializeBinary = function(bytes) {
  2225    var reader = new jspb.BinaryReader(bytes);
  2226    var msg = new proto.exec.BlockExecution;
  2227    return proto.exec.BlockExecution.deserializeBinaryFromReader(msg, reader);
  2228  };
  2229  
  2230  
  2231  /**
  2232   * Deserializes binary data (in protobuf wire format) from the
  2233   * given reader into the given message object.
  2234   * @param {!proto.exec.BlockExecution} msg The message object to deserialize into.
  2235   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  2236   * @return {!proto.exec.BlockExecution}
  2237   */
  2238  proto.exec.BlockExecution.deserializeBinaryFromReader = function(msg, reader) {
  2239    while (reader.nextField()) {
  2240      if (reader.isEndGroup()) {
  2241        break;
  2242      }
  2243      var field = reader.getFieldNumber();
  2244      switch (field) {
  2245      case 1:
  2246        var value = /** @type {number} */ (reader.readUint64());
  2247        msg.setHeight(value);
  2248        break;
  2249      case 4:
  2250        var value = /** @type {number} */ (reader.readUint64());
  2251        msg.setPredecessorheight(value);
  2252        break;
  2253      case 2:
  2254        var value = new tendermint_types_types_pb.Header;
  2255        reader.readMessage(value,tendermint_types_types_pb.Header.deserializeBinaryFromReader);
  2256        msg.setHeader(value);
  2257        break;
  2258      case 3:
  2259        var value = new proto.exec.TxExecution;
  2260        reader.readMessage(value,proto.exec.TxExecution.deserializeBinaryFromReader);
  2261        msg.addTxexecutions(value);
  2262        break;
  2263      default:
  2264        reader.skipField();
  2265        break;
  2266      }
  2267    }
  2268    return msg;
  2269  };
  2270  
  2271  
  2272  /**
  2273   * Serializes the message to binary data (in protobuf wire format).
  2274   * @return {!Uint8Array}
  2275   */
  2276  proto.exec.BlockExecution.prototype.serializeBinary = function() {
  2277    var writer = new jspb.BinaryWriter();
  2278    proto.exec.BlockExecution.serializeBinaryToWriter(this, writer);
  2279    return writer.getResultBuffer();
  2280  };
  2281  
  2282  
  2283  /**
  2284   * Serializes the given message to binary data (in protobuf wire
  2285   * format), writing to the given BinaryWriter.
  2286   * @param {!proto.exec.BlockExecution} message
  2287   * @param {!jspb.BinaryWriter} writer
  2288   * @suppress {unusedLocalVariables} f is only used for nested messages
  2289   */
  2290  proto.exec.BlockExecution.serializeBinaryToWriter = function(message, writer) {
  2291    var f = undefined;
  2292    f = message.getHeight();
  2293    if (f !== 0) {
  2294      writer.writeUint64(
  2295        1,
  2296        f
  2297      );
  2298    }
  2299    f = message.getPredecessorheight();
  2300    if (f !== 0) {
  2301      writer.writeUint64(
  2302        4,
  2303        f
  2304      );
  2305    }
  2306    f = message.getHeader();
  2307    if (f != null) {
  2308      writer.writeMessage(
  2309        2,
  2310        f,
  2311        tendermint_types_types_pb.Header.serializeBinaryToWriter
  2312      );
  2313    }
  2314    f = message.getTxexecutionsList();
  2315    if (f.length > 0) {
  2316      writer.writeRepeatedMessage(
  2317        3,
  2318        f,
  2319        proto.exec.TxExecution.serializeBinaryToWriter
  2320      );
  2321    }
  2322  };
  2323  
  2324  
  2325  /**
  2326   * optional uint64 Height = 1;
  2327   * @return {number}
  2328   */
  2329  proto.exec.BlockExecution.prototype.getHeight = function() {
  2330    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0));
  2331  };
  2332  
  2333  
  2334  /**
  2335   * @param {number} value
  2336   * @return {!proto.exec.BlockExecution} returns this
  2337   */
  2338  proto.exec.BlockExecution.prototype.setHeight = function(value) {
  2339    return jspb.Message.setProto3IntField(this, 1, value);
  2340  };
  2341  
  2342  
  2343  /**
  2344   * optional uint64 PredecessorHeight = 4;
  2345   * @return {number}
  2346   */
  2347  proto.exec.BlockExecution.prototype.getPredecessorheight = function() {
  2348    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0));
  2349  };
  2350  
  2351  
  2352  /**
  2353   * @param {number} value
  2354   * @return {!proto.exec.BlockExecution} returns this
  2355   */
  2356  proto.exec.BlockExecution.prototype.setPredecessorheight = function(value) {
  2357    return jspb.Message.setProto3IntField(this, 4, value);
  2358  };
  2359  
  2360  
  2361  /**
  2362   * optional tendermint.types.Header Header = 2;
  2363   * @return {?proto.tendermint.types.Header}
  2364   */
  2365  proto.exec.BlockExecution.prototype.getHeader = function() {
  2366    return /** @type{?proto.tendermint.types.Header} */ (
  2367      jspb.Message.getWrapperField(this, tendermint_types_types_pb.Header, 2));
  2368  };
  2369  
  2370  
  2371  /**
  2372   * @param {?proto.tendermint.types.Header|undefined} value
  2373   * @return {!proto.exec.BlockExecution} returns this
  2374  */
  2375  proto.exec.BlockExecution.prototype.setHeader = function(value) {
  2376    return jspb.Message.setWrapperField(this, 2, value);
  2377  };
  2378  
  2379  
  2380  /**
  2381   * Clears the message field making it undefined.
  2382   * @return {!proto.exec.BlockExecution} returns this
  2383   */
  2384  proto.exec.BlockExecution.prototype.clearHeader = function() {
  2385    return this.setHeader(undefined);
  2386  };
  2387  
  2388  
  2389  /**
  2390   * Returns whether this field is set.
  2391   * @return {boolean}
  2392   */
  2393  proto.exec.BlockExecution.prototype.hasHeader = function() {
  2394    return jspb.Message.getField(this, 2) != null;
  2395  };
  2396  
  2397  
  2398  /**
  2399   * repeated TxExecution TxExecutions = 3;
  2400   * @return {!Array<!proto.exec.TxExecution>}
  2401   */
  2402  proto.exec.BlockExecution.prototype.getTxexecutionsList = function() {
  2403    return /** @type{!Array<!proto.exec.TxExecution>} */ (
  2404      jspb.Message.getRepeatedWrapperField(this, proto.exec.TxExecution, 3));
  2405  };
  2406  
  2407  
  2408  /**
  2409   * @param {!Array<!proto.exec.TxExecution>} value
  2410   * @return {!proto.exec.BlockExecution} returns this
  2411  */
  2412  proto.exec.BlockExecution.prototype.setTxexecutionsList = function(value) {
  2413    return jspb.Message.setRepeatedWrapperField(this, 3, value);
  2414  };
  2415  
  2416  
  2417  /**
  2418   * @param {!proto.exec.TxExecution=} opt_value
  2419   * @param {number=} opt_index
  2420   * @return {!proto.exec.TxExecution}
  2421   */
  2422  proto.exec.BlockExecution.prototype.addTxexecutions = function(opt_value, opt_index) {
  2423    return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.exec.TxExecution, opt_index);
  2424  };
  2425  
  2426  
  2427  /**
  2428   * Clears the list making it empty but non-null.
  2429   * @return {!proto.exec.BlockExecution} returns this
  2430   */
  2431  proto.exec.BlockExecution.prototype.clearTxexecutionsList = function() {
  2432    return this.setTxexecutionsList([]);
  2433  };
  2434  
  2435  
  2436  
  2437  
  2438  
  2439  if (jspb.Message.GENERATE_TO_OBJECT) {
  2440  /**
  2441   * Creates an object representation of this proto.
  2442   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  2443   * Optional fields that are not set will be set to undefined.
  2444   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  2445   * For the list of reserved names please see:
  2446   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  2447   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  2448   *     JSPB instance for transitional soy proto support:
  2449   *     http://goto/soy-param-migration
  2450   * @return {!Object}
  2451   */
  2452  proto.exec.TxExecutionKey.prototype.toObject = function(opt_includeInstance) {
  2453    return proto.exec.TxExecutionKey.toObject(opt_includeInstance, this);
  2454  };
  2455  
  2456  
  2457  /**
  2458   * Static version of the {@see toObject} method.
  2459   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  2460   *     the JSPB instance for transitional soy proto support:
  2461   *     http://goto/soy-param-migration
  2462   * @param {!proto.exec.TxExecutionKey} msg The msg instance to transform.
  2463   * @return {!Object}
  2464   * @suppress {unusedLocalVariables} f is only used for nested messages
  2465   */
  2466  proto.exec.TxExecutionKey.toObject = function(includeInstance, msg) {
  2467    var f, obj = {
  2468      height: jspb.Message.getFieldWithDefault(msg, 1, 0),
  2469      offset: jspb.Message.getFieldWithDefault(msg, 2, 0)
  2470    };
  2471  
  2472    if (includeInstance) {
  2473      obj.$jspbMessageInstance = msg;
  2474    }
  2475    return obj;
  2476  };
  2477  }
  2478  
  2479  
  2480  /**
  2481   * Deserializes binary data (in protobuf wire format).
  2482   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  2483   * @return {!proto.exec.TxExecutionKey}
  2484   */
  2485  proto.exec.TxExecutionKey.deserializeBinary = function(bytes) {
  2486    var reader = new jspb.BinaryReader(bytes);
  2487    var msg = new proto.exec.TxExecutionKey;
  2488    return proto.exec.TxExecutionKey.deserializeBinaryFromReader(msg, reader);
  2489  };
  2490  
  2491  
  2492  /**
  2493   * Deserializes binary data (in protobuf wire format) from the
  2494   * given reader into the given message object.
  2495   * @param {!proto.exec.TxExecutionKey} msg The message object to deserialize into.
  2496   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  2497   * @return {!proto.exec.TxExecutionKey}
  2498   */
  2499  proto.exec.TxExecutionKey.deserializeBinaryFromReader = function(msg, reader) {
  2500    while (reader.nextField()) {
  2501      if (reader.isEndGroup()) {
  2502        break;
  2503      }
  2504      var field = reader.getFieldNumber();
  2505      switch (field) {
  2506      case 1:
  2507        var value = /** @type {number} */ (reader.readUint64());
  2508        msg.setHeight(value);
  2509        break;
  2510      case 2:
  2511        var value = /** @type {number} */ (reader.readUint64());
  2512        msg.setOffset(value);
  2513        break;
  2514      default:
  2515        reader.skipField();
  2516        break;
  2517      }
  2518    }
  2519    return msg;
  2520  };
  2521  
  2522  
  2523  /**
  2524   * Serializes the message to binary data (in protobuf wire format).
  2525   * @return {!Uint8Array}
  2526   */
  2527  proto.exec.TxExecutionKey.prototype.serializeBinary = function() {
  2528    var writer = new jspb.BinaryWriter();
  2529    proto.exec.TxExecutionKey.serializeBinaryToWriter(this, writer);
  2530    return writer.getResultBuffer();
  2531  };
  2532  
  2533  
  2534  /**
  2535   * Serializes the given message to binary data (in protobuf wire
  2536   * format), writing to the given BinaryWriter.
  2537   * @param {!proto.exec.TxExecutionKey} message
  2538   * @param {!jspb.BinaryWriter} writer
  2539   * @suppress {unusedLocalVariables} f is only used for nested messages
  2540   */
  2541  proto.exec.TxExecutionKey.serializeBinaryToWriter = function(message, writer) {
  2542    var f = undefined;
  2543    f = message.getHeight();
  2544    if (f !== 0) {
  2545      writer.writeUint64(
  2546        1,
  2547        f
  2548      );
  2549    }
  2550    f = message.getOffset();
  2551    if (f !== 0) {
  2552      writer.writeUint64(
  2553        2,
  2554        f
  2555      );
  2556    }
  2557  };
  2558  
  2559  
  2560  /**
  2561   * optional uint64 Height = 1;
  2562   * @return {number}
  2563   */
  2564  proto.exec.TxExecutionKey.prototype.getHeight = function() {
  2565    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0));
  2566  };
  2567  
  2568  
  2569  /**
  2570   * @param {number} value
  2571   * @return {!proto.exec.TxExecutionKey} returns this
  2572   */
  2573  proto.exec.TxExecutionKey.prototype.setHeight = function(value) {
  2574    return jspb.Message.setProto3IntField(this, 1, value);
  2575  };
  2576  
  2577  
  2578  /**
  2579   * optional uint64 Offset = 2;
  2580   * @return {number}
  2581   */
  2582  proto.exec.TxExecutionKey.prototype.getOffset = function() {
  2583    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0));
  2584  };
  2585  
  2586  
  2587  /**
  2588   * @param {number} value
  2589   * @return {!proto.exec.TxExecutionKey} returns this
  2590   */
  2591  proto.exec.TxExecutionKey.prototype.setOffset = function(value) {
  2592    return jspb.Message.setProto3IntField(this, 2, value);
  2593  };
  2594  
  2595  
  2596  
  2597  /**
  2598   * List of repeated fields within this message type.
  2599   * @private {!Array<number>}
  2600   * @const
  2601   */
  2602  proto.exec.TxExecution.repeatedFields_ = [7,11];
  2603  
  2604  
  2605  
  2606  if (jspb.Message.GENERATE_TO_OBJECT) {
  2607  /**
  2608   * Creates an object representation of this proto.
  2609   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  2610   * Optional fields that are not set will be set to undefined.
  2611   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  2612   * For the list of reserved names please see:
  2613   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  2614   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  2615   *     JSPB instance for transitional soy proto support:
  2616   *     http://goto/soy-param-migration
  2617   * @return {!Object}
  2618   */
  2619  proto.exec.TxExecution.prototype.toObject = function(opt_includeInstance) {
  2620    return proto.exec.TxExecution.toObject(opt_includeInstance, this);
  2621  };
  2622  
  2623  
  2624  /**
  2625   * Static version of the {@see toObject} method.
  2626   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  2627   *     the JSPB instance for transitional soy proto support:
  2628   *     http://goto/soy-param-migration
  2629   * @param {!proto.exec.TxExecution} msg The msg instance to transform.
  2630   * @return {!Object}
  2631   * @suppress {unusedLocalVariables} f is only used for nested messages
  2632   */
  2633  proto.exec.TxExecution.toObject = function(includeInstance, msg) {
  2634    var f, obj = {
  2635      header: (f = msg.getHeader()) && proto.exec.TxHeader.toObject(includeInstance, f),
  2636      envelope: (f = msg.getEnvelope()) && txs_pb.Envelope.toObject(includeInstance, f),
  2637      eventsList: jspb.Message.toObjectList(msg.getEventsList(),
  2638      proto.exec.Event.toObject, includeInstance),
  2639      result: (f = msg.getResult()) && proto.exec.Result.toObject(includeInstance, f),
  2640      receipt: (f = msg.getReceipt()) && txs_pb.Receipt.toObject(includeInstance, f),
  2641      exception: (f = msg.getException()) && errors_pb.Exception.toObject(includeInstance, f),
  2642      txexecutionsList: jspb.Message.toObjectList(msg.getTxexecutionsList(),
  2643      proto.exec.TxExecution.toObject, includeInstance)
  2644    };
  2645  
  2646    if (includeInstance) {
  2647      obj.$jspbMessageInstance = msg;
  2648    }
  2649    return obj;
  2650  };
  2651  }
  2652  
  2653  
  2654  /**
  2655   * Deserializes binary data (in protobuf wire format).
  2656   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  2657   * @return {!proto.exec.TxExecution}
  2658   */
  2659  proto.exec.TxExecution.deserializeBinary = function(bytes) {
  2660    var reader = new jspb.BinaryReader(bytes);
  2661    var msg = new proto.exec.TxExecution;
  2662    return proto.exec.TxExecution.deserializeBinaryFromReader(msg, reader);
  2663  };
  2664  
  2665  
  2666  /**
  2667   * Deserializes binary data (in protobuf wire format) from the
  2668   * given reader into the given message object.
  2669   * @param {!proto.exec.TxExecution} msg The message object to deserialize into.
  2670   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  2671   * @return {!proto.exec.TxExecution}
  2672   */
  2673  proto.exec.TxExecution.deserializeBinaryFromReader = function(msg, reader) {
  2674    while (reader.nextField()) {
  2675      if (reader.isEndGroup()) {
  2676        break;
  2677      }
  2678      var field = reader.getFieldNumber();
  2679      switch (field) {
  2680      case 1:
  2681        var value = new proto.exec.TxHeader;
  2682        reader.readMessage(value,proto.exec.TxHeader.deserializeBinaryFromReader);
  2683        msg.setHeader(value);
  2684        break;
  2685      case 6:
  2686        var value = new txs_pb.Envelope;
  2687        reader.readMessage(value,txs_pb.Envelope.deserializeBinaryFromReader);
  2688        msg.setEnvelope(value);
  2689        break;
  2690      case 7:
  2691        var value = new proto.exec.Event;
  2692        reader.readMessage(value,proto.exec.Event.deserializeBinaryFromReader);
  2693        msg.addEvents(value);
  2694        break;
  2695      case 8:
  2696        var value = new proto.exec.Result;
  2697        reader.readMessage(value,proto.exec.Result.deserializeBinaryFromReader);
  2698        msg.setResult(value);
  2699        break;
  2700      case 9:
  2701        var value = new txs_pb.Receipt;
  2702        reader.readMessage(value,txs_pb.Receipt.deserializeBinaryFromReader);
  2703        msg.setReceipt(value);
  2704        break;
  2705      case 10:
  2706        var value = new errors_pb.Exception;
  2707        reader.readMessage(value,errors_pb.Exception.deserializeBinaryFromReader);
  2708        msg.setException(value);
  2709        break;
  2710      case 11:
  2711        var value = new proto.exec.TxExecution;
  2712        reader.readMessage(value,proto.exec.TxExecution.deserializeBinaryFromReader);
  2713        msg.addTxexecutions(value);
  2714        break;
  2715      default:
  2716        reader.skipField();
  2717        break;
  2718      }
  2719    }
  2720    return msg;
  2721  };
  2722  
  2723  
  2724  /**
  2725   * Serializes the message to binary data (in protobuf wire format).
  2726   * @return {!Uint8Array}
  2727   */
  2728  proto.exec.TxExecution.prototype.serializeBinary = function() {
  2729    var writer = new jspb.BinaryWriter();
  2730    proto.exec.TxExecution.serializeBinaryToWriter(this, writer);
  2731    return writer.getResultBuffer();
  2732  };
  2733  
  2734  
  2735  /**
  2736   * Serializes the given message to binary data (in protobuf wire
  2737   * format), writing to the given BinaryWriter.
  2738   * @param {!proto.exec.TxExecution} message
  2739   * @param {!jspb.BinaryWriter} writer
  2740   * @suppress {unusedLocalVariables} f is only used for nested messages
  2741   */
  2742  proto.exec.TxExecution.serializeBinaryToWriter = function(message, writer) {
  2743    var f = undefined;
  2744    f = message.getHeader();
  2745    if (f != null) {
  2746      writer.writeMessage(
  2747        1,
  2748        f,
  2749        proto.exec.TxHeader.serializeBinaryToWriter
  2750      );
  2751    }
  2752    f = message.getEnvelope();
  2753    if (f != null) {
  2754      writer.writeMessage(
  2755        6,
  2756        f,
  2757        txs_pb.Envelope.serializeBinaryToWriter
  2758      );
  2759    }
  2760    f = message.getEventsList();
  2761    if (f.length > 0) {
  2762      writer.writeRepeatedMessage(
  2763        7,
  2764        f,
  2765        proto.exec.Event.serializeBinaryToWriter
  2766      );
  2767    }
  2768    f = message.getResult();
  2769    if (f != null) {
  2770      writer.writeMessage(
  2771        8,
  2772        f,
  2773        proto.exec.Result.serializeBinaryToWriter
  2774      );
  2775    }
  2776    f = message.getReceipt();
  2777    if (f != null) {
  2778      writer.writeMessage(
  2779        9,
  2780        f,
  2781        txs_pb.Receipt.serializeBinaryToWriter
  2782      );
  2783    }
  2784    f = message.getException();
  2785    if (f != null) {
  2786      writer.writeMessage(
  2787        10,
  2788        f,
  2789        errors_pb.Exception.serializeBinaryToWriter
  2790      );
  2791    }
  2792    f = message.getTxexecutionsList();
  2793    if (f.length > 0) {
  2794      writer.writeRepeatedMessage(
  2795        11,
  2796        f,
  2797        proto.exec.TxExecution.serializeBinaryToWriter
  2798      );
  2799    }
  2800  };
  2801  
  2802  
  2803  /**
  2804   * optional TxHeader Header = 1;
  2805   * @return {?proto.exec.TxHeader}
  2806   */
  2807  proto.exec.TxExecution.prototype.getHeader = function() {
  2808    return /** @type{?proto.exec.TxHeader} */ (
  2809      jspb.Message.getWrapperField(this, proto.exec.TxHeader, 1));
  2810  };
  2811  
  2812  
  2813  /**
  2814   * @param {?proto.exec.TxHeader|undefined} value
  2815   * @return {!proto.exec.TxExecution} returns this
  2816  */
  2817  proto.exec.TxExecution.prototype.setHeader = function(value) {
  2818    return jspb.Message.setWrapperField(this, 1, value);
  2819  };
  2820  
  2821  
  2822  /**
  2823   * Clears the message field making it undefined.
  2824   * @return {!proto.exec.TxExecution} returns this
  2825   */
  2826  proto.exec.TxExecution.prototype.clearHeader = function() {
  2827    return this.setHeader(undefined);
  2828  };
  2829  
  2830  
  2831  /**
  2832   * Returns whether this field is set.
  2833   * @return {boolean}
  2834   */
  2835  proto.exec.TxExecution.prototype.hasHeader = function() {
  2836    return jspb.Message.getField(this, 1) != null;
  2837  };
  2838  
  2839  
  2840  /**
  2841   * optional txs.Envelope Envelope = 6;
  2842   * @return {?proto.txs.Envelope}
  2843   */
  2844  proto.exec.TxExecution.prototype.getEnvelope = function() {
  2845    return /** @type{?proto.txs.Envelope} */ (
  2846      jspb.Message.getWrapperField(this, txs_pb.Envelope, 6));
  2847  };
  2848  
  2849  
  2850  /**
  2851   * @param {?proto.txs.Envelope|undefined} value
  2852   * @return {!proto.exec.TxExecution} returns this
  2853  */
  2854  proto.exec.TxExecution.prototype.setEnvelope = function(value) {
  2855    return jspb.Message.setWrapperField(this, 6, value);
  2856  };
  2857  
  2858  
  2859  /**
  2860   * Clears the message field making it undefined.
  2861   * @return {!proto.exec.TxExecution} returns this
  2862   */
  2863  proto.exec.TxExecution.prototype.clearEnvelope = function() {
  2864    return this.setEnvelope(undefined);
  2865  };
  2866  
  2867  
  2868  /**
  2869   * Returns whether this field is set.
  2870   * @return {boolean}
  2871   */
  2872  proto.exec.TxExecution.prototype.hasEnvelope = function() {
  2873    return jspb.Message.getField(this, 6) != null;
  2874  };
  2875  
  2876  
  2877  /**
  2878   * repeated Event Events = 7;
  2879   * @return {!Array<!proto.exec.Event>}
  2880   */
  2881  proto.exec.TxExecution.prototype.getEventsList = function() {
  2882    return /** @type{!Array<!proto.exec.Event>} */ (
  2883      jspb.Message.getRepeatedWrapperField(this, proto.exec.Event, 7));
  2884  };
  2885  
  2886  
  2887  /**
  2888   * @param {!Array<!proto.exec.Event>} value
  2889   * @return {!proto.exec.TxExecution} returns this
  2890  */
  2891  proto.exec.TxExecution.prototype.setEventsList = function(value) {
  2892    return jspb.Message.setRepeatedWrapperField(this, 7, value);
  2893  };
  2894  
  2895  
  2896  /**
  2897   * @param {!proto.exec.Event=} opt_value
  2898   * @param {number=} opt_index
  2899   * @return {!proto.exec.Event}
  2900   */
  2901  proto.exec.TxExecution.prototype.addEvents = function(opt_value, opt_index) {
  2902    return jspb.Message.addToRepeatedWrapperField(this, 7, opt_value, proto.exec.Event, opt_index);
  2903  };
  2904  
  2905  
  2906  /**
  2907   * Clears the list making it empty but non-null.
  2908   * @return {!proto.exec.TxExecution} returns this
  2909   */
  2910  proto.exec.TxExecution.prototype.clearEventsList = function() {
  2911    return this.setEventsList([]);
  2912  };
  2913  
  2914  
  2915  /**
  2916   * optional Result Result = 8;
  2917   * @return {?proto.exec.Result}
  2918   */
  2919  proto.exec.TxExecution.prototype.getResult = function() {
  2920    return /** @type{?proto.exec.Result} */ (
  2921      jspb.Message.getWrapperField(this, proto.exec.Result, 8));
  2922  };
  2923  
  2924  
  2925  /**
  2926   * @param {?proto.exec.Result|undefined} value
  2927   * @return {!proto.exec.TxExecution} returns this
  2928  */
  2929  proto.exec.TxExecution.prototype.setResult = function(value) {
  2930    return jspb.Message.setWrapperField(this, 8, value);
  2931  };
  2932  
  2933  
  2934  /**
  2935   * Clears the message field making it undefined.
  2936   * @return {!proto.exec.TxExecution} returns this
  2937   */
  2938  proto.exec.TxExecution.prototype.clearResult = function() {
  2939    return this.setResult(undefined);
  2940  };
  2941  
  2942  
  2943  /**
  2944   * Returns whether this field is set.
  2945   * @return {boolean}
  2946   */
  2947  proto.exec.TxExecution.prototype.hasResult = function() {
  2948    return jspb.Message.getField(this, 8) != null;
  2949  };
  2950  
  2951  
  2952  /**
  2953   * optional txs.Receipt Receipt = 9;
  2954   * @return {?proto.txs.Receipt}
  2955   */
  2956  proto.exec.TxExecution.prototype.getReceipt = function() {
  2957    return /** @type{?proto.txs.Receipt} */ (
  2958      jspb.Message.getWrapperField(this, txs_pb.Receipt, 9));
  2959  };
  2960  
  2961  
  2962  /**
  2963   * @param {?proto.txs.Receipt|undefined} value
  2964   * @return {!proto.exec.TxExecution} returns this
  2965  */
  2966  proto.exec.TxExecution.prototype.setReceipt = function(value) {
  2967    return jspb.Message.setWrapperField(this, 9, value);
  2968  };
  2969  
  2970  
  2971  /**
  2972   * Clears the message field making it undefined.
  2973   * @return {!proto.exec.TxExecution} returns this
  2974   */
  2975  proto.exec.TxExecution.prototype.clearReceipt = function() {
  2976    return this.setReceipt(undefined);
  2977  };
  2978  
  2979  
  2980  /**
  2981   * Returns whether this field is set.
  2982   * @return {boolean}
  2983   */
  2984  proto.exec.TxExecution.prototype.hasReceipt = function() {
  2985    return jspb.Message.getField(this, 9) != null;
  2986  };
  2987  
  2988  
  2989  /**
  2990   * optional errors.Exception Exception = 10;
  2991   * @return {?proto.errors.Exception}
  2992   */
  2993  proto.exec.TxExecution.prototype.getException = function() {
  2994    return /** @type{?proto.errors.Exception} */ (
  2995      jspb.Message.getWrapperField(this, errors_pb.Exception, 10));
  2996  };
  2997  
  2998  
  2999  /**
  3000   * @param {?proto.errors.Exception|undefined} value
  3001   * @return {!proto.exec.TxExecution} returns this
  3002  */
  3003  proto.exec.TxExecution.prototype.setException = function(value) {
  3004    return jspb.Message.setWrapperField(this, 10, value);
  3005  };
  3006  
  3007  
  3008  /**
  3009   * Clears the message field making it undefined.
  3010   * @return {!proto.exec.TxExecution} returns this
  3011   */
  3012  proto.exec.TxExecution.prototype.clearException = function() {
  3013    return this.setException(undefined);
  3014  };
  3015  
  3016  
  3017  /**
  3018   * Returns whether this field is set.
  3019   * @return {boolean}
  3020   */
  3021  proto.exec.TxExecution.prototype.hasException = function() {
  3022    return jspb.Message.getField(this, 10) != null;
  3023  };
  3024  
  3025  
  3026  /**
  3027   * repeated TxExecution TxExecutions = 11;
  3028   * @return {!Array<!proto.exec.TxExecution>}
  3029   */
  3030  proto.exec.TxExecution.prototype.getTxexecutionsList = function() {
  3031    return /** @type{!Array<!proto.exec.TxExecution>} */ (
  3032      jspb.Message.getRepeatedWrapperField(this, proto.exec.TxExecution, 11));
  3033  };
  3034  
  3035  
  3036  /**
  3037   * @param {!Array<!proto.exec.TxExecution>} value
  3038   * @return {!proto.exec.TxExecution} returns this
  3039  */
  3040  proto.exec.TxExecution.prototype.setTxexecutionsList = function(value) {
  3041    return jspb.Message.setRepeatedWrapperField(this, 11, value);
  3042  };
  3043  
  3044  
  3045  /**
  3046   * @param {!proto.exec.TxExecution=} opt_value
  3047   * @param {number=} opt_index
  3048   * @return {!proto.exec.TxExecution}
  3049   */
  3050  proto.exec.TxExecution.prototype.addTxexecutions = function(opt_value, opt_index) {
  3051    return jspb.Message.addToRepeatedWrapperField(this, 11, opt_value, proto.exec.TxExecution, opt_index);
  3052  };
  3053  
  3054  
  3055  /**
  3056   * Clears the list making it empty but non-null.
  3057   * @return {!proto.exec.TxExecution} returns this
  3058   */
  3059  proto.exec.TxExecution.prototype.clearTxexecutionsList = function() {
  3060    return this.setTxexecutionsList([]);
  3061  };
  3062  
  3063  
  3064  
  3065  
  3066  
  3067  if (jspb.Message.GENERATE_TO_OBJECT) {
  3068  /**
  3069   * Creates an object representation of this proto.
  3070   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  3071   * Optional fields that are not set will be set to undefined.
  3072   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  3073   * For the list of reserved names please see:
  3074   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  3075   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  3076   *     JSPB instance for transitional soy proto support:
  3077   *     http://goto/soy-param-migration
  3078   * @return {!Object}
  3079   */
  3080  proto.exec.Origin.prototype.toObject = function(opt_includeInstance) {
  3081    return proto.exec.Origin.toObject(opt_includeInstance, this);
  3082  };
  3083  
  3084  
  3085  /**
  3086   * Static version of the {@see toObject} method.
  3087   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  3088   *     the JSPB instance for transitional soy proto support:
  3089   *     http://goto/soy-param-migration
  3090   * @param {!proto.exec.Origin} msg The msg instance to transform.
  3091   * @return {!Object}
  3092   * @suppress {unusedLocalVariables} f is only used for nested messages
  3093   */
  3094  proto.exec.Origin.toObject = function(includeInstance, msg) {
  3095    var f, obj = {
  3096      chainid: jspb.Message.getFieldWithDefault(msg, 1, ""),
  3097      height: jspb.Message.getFieldWithDefault(msg, 2, 0),
  3098      index: jspb.Message.getFieldWithDefault(msg, 3, 0),
  3099      time: (f = msg.getTime()) && google_protobuf_timestamp_pb.Timestamp.toObject(includeInstance, f)
  3100    };
  3101  
  3102    if (includeInstance) {
  3103      obj.$jspbMessageInstance = msg;
  3104    }
  3105    return obj;
  3106  };
  3107  }
  3108  
  3109  
  3110  /**
  3111   * Deserializes binary data (in protobuf wire format).
  3112   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  3113   * @return {!proto.exec.Origin}
  3114   */
  3115  proto.exec.Origin.deserializeBinary = function(bytes) {
  3116    var reader = new jspb.BinaryReader(bytes);
  3117    var msg = new proto.exec.Origin;
  3118    return proto.exec.Origin.deserializeBinaryFromReader(msg, reader);
  3119  };
  3120  
  3121  
  3122  /**
  3123   * Deserializes binary data (in protobuf wire format) from the
  3124   * given reader into the given message object.
  3125   * @param {!proto.exec.Origin} msg The message object to deserialize into.
  3126   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  3127   * @return {!proto.exec.Origin}
  3128   */
  3129  proto.exec.Origin.deserializeBinaryFromReader = function(msg, reader) {
  3130    while (reader.nextField()) {
  3131      if (reader.isEndGroup()) {
  3132        break;
  3133      }
  3134      var field = reader.getFieldNumber();
  3135      switch (field) {
  3136      case 1:
  3137        var value = /** @type {string} */ (reader.readString());
  3138        msg.setChainid(value);
  3139        break;
  3140      case 2:
  3141        var value = /** @type {number} */ (reader.readUint64());
  3142        msg.setHeight(value);
  3143        break;
  3144      case 3:
  3145        var value = /** @type {number} */ (reader.readUint64());
  3146        msg.setIndex(value);
  3147        break;
  3148      case 4:
  3149        var value = new google_protobuf_timestamp_pb.Timestamp;
  3150        reader.readMessage(value,google_protobuf_timestamp_pb.Timestamp.deserializeBinaryFromReader);
  3151        msg.setTime(value);
  3152        break;
  3153      default:
  3154        reader.skipField();
  3155        break;
  3156      }
  3157    }
  3158    return msg;
  3159  };
  3160  
  3161  
  3162  /**
  3163   * Serializes the message to binary data (in protobuf wire format).
  3164   * @return {!Uint8Array}
  3165   */
  3166  proto.exec.Origin.prototype.serializeBinary = function() {
  3167    var writer = new jspb.BinaryWriter();
  3168    proto.exec.Origin.serializeBinaryToWriter(this, writer);
  3169    return writer.getResultBuffer();
  3170  };
  3171  
  3172  
  3173  /**
  3174   * Serializes the given message to binary data (in protobuf wire
  3175   * format), writing to the given BinaryWriter.
  3176   * @param {!proto.exec.Origin} message
  3177   * @param {!jspb.BinaryWriter} writer
  3178   * @suppress {unusedLocalVariables} f is only used for nested messages
  3179   */
  3180  proto.exec.Origin.serializeBinaryToWriter = function(message, writer) {
  3181    var f = undefined;
  3182    f = message.getChainid();
  3183    if (f.length > 0) {
  3184      writer.writeString(
  3185        1,
  3186        f
  3187      );
  3188    }
  3189    f = message.getHeight();
  3190    if (f !== 0) {
  3191      writer.writeUint64(
  3192        2,
  3193        f
  3194      );
  3195    }
  3196    f = message.getIndex();
  3197    if (f !== 0) {
  3198      writer.writeUint64(
  3199        3,
  3200        f
  3201      );
  3202    }
  3203    f = message.getTime();
  3204    if (f != null) {
  3205      writer.writeMessage(
  3206        4,
  3207        f,
  3208        google_protobuf_timestamp_pb.Timestamp.serializeBinaryToWriter
  3209      );
  3210    }
  3211  };
  3212  
  3213  
  3214  /**
  3215   * optional string ChainID = 1;
  3216   * @return {string}
  3217   */
  3218  proto.exec.Origin.prototype.getChainid = function() {
  3219    return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
  3220  };
  3221  
  3222  
  3223  /**
  3224   * @param {string} value
  3225   * @return {!proto.exec.Origin} returns this
  3226   */
  3227  proto.exec.Origin.prototype.setChainid = function(value) {
  3228    return jspb.Message.setProto3StringField(this, 1, value);
  3229  };
  3230  
  3231  
  3232  /**
  3233   * optional uint64 Height = 2;
  3234   * @return {number}
  3235   */
  3236  proto.exec.Origin.prototype.getHeight = function() {
  3237    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0));
  3238  };
  3239  
  3240  
  3241  /**
  3242   * @param {number} value
  3243   * @return {!proto.exec.Origin} returns this
  3244   */
  3245  proto.exec.Origin.prototype.setHeight = function(value) {
  3246    return jspb.Message.setProto3IntField(this, 2, value);
  3247  };
  3248  
  3249  
  3250  /**
  3251   * optional uint64 Index = 3;
  3252   * @return {number}
  3253   */
  3254  proto.exec.Origin.prototype.getIndex = function() {
  3255    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));
  3256  };
  3257  
  3258  
  3259  /**
  3260   * @param {number} value
  3261   * @return {!proto.exec.Origin} returns this
  3262   */
  3263  proto.exec.Origin.prototype.setIndex = function(value) {
  3264    return jspb.Message.setProto3IntField(this, 3, value);
  3265  };
  3266  
  3267  
  3268  /**
  3269   * optional google.protobuf.Timestamp Time = 4;
  3270   * @return {?proto.google.protobuf.Timestamp}
  3271   */
  3272  proto.exec.Origin.prototype.getTime = function() {
  3273    return /** @type{?proto.google.protobuf.Timestamp} */ (
  3274      jspb.Message.getWrapperField(this, google_protobuf_timestamp_pb.Timestamp, 4));
  3275  };
  3276  
  3277  
  3278  /**
  3279   * @param {?proto.google.protobuf.Timestamp|undefined} value
  3280   * @return {!proto.exec.Origin} returns this
  3281  */
  3282  proto.exec.Origin.prototype.setTime = function(value) {
  3283    return jspb.Message.setWrapperField(this, 4, value);
  3284  };
  3285  
  3286  
  3287  /**
  3288   * Clears the message field making it undefined.
  3289   * @return {!proto.exec.Origin} returns this
  3290   */
  3291  proto.exec.Origin.prototype.clearTime = function() {
  3292    return this.setTime(undefined);
  3293  };
  3294  
  3295  
  3296  /**
  3297   * Returns whether this field is set.
  3298   * @return {boolean}
  3299   */
  3300  proto.exec.Origin.prototype.hasTime = function() {
  3301    return jspb.Message.getField(this, 4) != null;
  3302  };
  3303  
  3304  
  3305  
  3306  
  3307  
  3308  if (jspb.Message.GENERATE_TO_OBJECT) {
  3309  /**
  3310   * Creates an object representation of this proto.
  3311   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  3312   * Optional fields that are not set will be set to undefined.
  3313   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  3314   * For the list of reserved names please see:
  3315   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  3316   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  3317   *     JSPB instance for transitional soy proto support:
  3318   *     http://goto/soy-param-migration
  3319   * @return {!Object}
  3320   */
  3321  proto.exec.Header.prototype.toObject = function(opt_includeInstance) {
  3322    return proto.exec.Header.toObject(opt_includeInstance, this);
  3323  };
  3324  
  3325  
  3326  /**
  3327   * Static version of the {@see toObject} method.
  3328   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  3329   *     the JSPB instance for transitional soy proto support:
  3330   *     http://goto/soy-param-migration
  3331   * @param {!proto.exec.Header} msg The msg instance to transform.
  3332   * @return {!Object}
  3333   * @suppress {unusedLocalVariables} f is only used for nested messages
  3334   */
  3335  proto.exec.Header.toObject = function(includeInstance, msg) {
  3336    var f, obj = {
  3337      txtype: jspb.Message.getFieldWithDefault(msg, 1, 0),
  3338      txhash: msg.getTxhash_asB64(),
  3339      eventtype: jspb.Message.getFieldWithDefault(msg, 3, 0),
  3340      eventid: jspb.Message.getFieldWithDefault(msg, 4, ""),
  3341      height: jspb.Message.getFieldWithDefault(msg, 5, 0),
  3342      index: jspb.Message.getFieldWithDefault(msg, 6, 0),
  3343      exception: (f = msg.getException()) && errors_pb.Exception.toObject(includeInstance, f)
  3344    };
  3345  
  3346    if (includeInstance) {
  3347      obj.$jspbMessageInstance = msg;
  3348    }
  3349    return obj;
  3350  };
  3351  }
  3352  
  3353  
  3354  /**
  3355   * Deserializes binary data (in protobuf wire format).
  3356   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  3357   * @return {!proto.exec.Header}
  3358   */
  3359  proto.exec.Header.deserializeBinary = function(bytes) {
  3360    var reader = new jspb.BinaryReader(bytes);
  3361    var msg = new proto.exec.Header;
  3362    return proto.exec.Header.deserializeBinaryFromReader(msg, reader);
  3363  };
  3364  
  3365  
  3366  /**
  3367   * Deserializes binary data (in protobuf wire format) from the
  3368   * given reader into the given message object.
  3369   * @param {!proto.exec.Header} msg The message object to deserialize into.
  3370   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  3371   * @return {!proto.exec.Header}
  3372   */
  3373  proto.exec.Header.deserializeBinaryFromReader = function(msg, reader) {
  3374    while (reader.nextField()) {
  3375      if (reader.isEndGroup()) {
  3376        break;
  3377      }
  3378      var field = reader.getFieldNumber();
  3379      switch (field) {
  3380      case 1:
  3381        var value = /** @type {number} */ (reader.readUint32());
  3382        msg.setTxtype(value);
  3383        break;
  3384      case 2:
  3385        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  3386        msg.setTxhash(value);
  3387        break;
  3388      case 3:
  3389        var value = /** @type {number} */ (reader.readUint32());
  3390        msg.setEventtype(value);
  3391        break;
  3392      case 4:
  3393        var value = /** @type {string} */ (reader.readString());
  3394        msg.setEventid(value);
  3395        break;
  3396      case 5:
  3397        var value = /** @type {number} */ (reader.readUint64());
  3398        msg.setHeight(value);
  3399        break;
  3400      case 6:
  3401        var value = /** @type {number} */ (reader.readUint64());
  3402        msg.setIndex(value);
  3403        break;
  3404      case 7:
  3405        var value = new errors_pb.Exception;
  3406        reader.readMessage(value,errors_pb.Exception.deserializeBinaryFromReader);
  3407        msg.setException(value);
  3408        break;
  3409      default:
  3410        reader.skipField();
  3411        break;
  3412      }
  3413    }
  3414    return msg;
  3415  };
  3416  
  3417  
  3418  /**
  3419   * Serializes the message to binary data (in protobuf wire format).
  3420   * @return {!Uint8Array}
  3421   */
  3422  proto.exec.Header.prototype.serializeBinary = function() {
  3423    var writer = new jspb.BinaryWriter();
  3424    proto.exec.Header.serializeBinaryToWriter(this, writer);
  3425    return writer.getResultBuffer();
  3426  };
  3427  
  3428  
  3429  /**
  3430   * Serializes the given message to binary data (in protobuf wire
  3431   * format), writing to the given BinaryWriter.
  3432   * @param {!proto.exec.Header} message
  3433   * @param {!jspb.BinaryWriter} writer
  3434   * @suppress {unusedLocalVariables} f is only used for nested messages
  3435   */
  3436  proto.exec.Header.serializeBinaryToWriter = function(message, writer) {
  3437    var f = undefined;
  3438    f = message.getTxtype();
  3439    if (f !== 0) {
  3440      writer.writeUint32(
  3441        1,
  3442        f
  3443      );
  3444    }
  3445    f = message.getTxhash_asU8();
  3446    if (f.length > 0) {
  3447      writer.writeBytes(
  3448        2,
  3449        f
  3450      );
  3451    }
  3452    f = message.getEventtype();
  3453    if (f !== 0) {
  3454      writer.writeUint32(
  3455        3,
  3456        f
  3457      );
  3458    }
  3459    f = message.getEventid();
  3460    if (f.length > 0) {
  3461      writer.writeString(
  3462        4,
  3463        f
  3464      );
  3465    }
  3466    f = message.getHeight();
  3467    if (f !== 0) {
  3468      writer.writeUint64(
  3469        5,
  3470        f
  3471      );
  3472    }
  3473    f = message.getIndex();
  3474    if (f !== 0) {
  3475      writer.writeUint64(
  3476        6,
  3477        f
  3478      );
  3479    }
  3480    f = message.getException();
  3481    if (f != null) {
  3482      writer.writeMessage(
  3483        7,
  3484        f,
  3485        errors_pb.Exception.serializeBinaryToWriter
  3486      );
  3487    }
  3488  };
  3489  
  3490  
  3491  /**
  3492   * optional uint32 TxType = 1;
  3493   * @return {number}
  3494   */
  3495  proto.exec.Header.prototype.getTxtype = function() {
  3496    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0));
  3497  };
  3498  
  3499  
  3500  /**
  3501   * @param {number} value
  3502   * @return {!proto.exec.Header} returns this
  3503   */
  3504  proto.exec.Header.prototype.setTxtype = function(value) {
  3505    return jspb.Message.setProto3IntField(this, 1, value);
  3506  };
  3507  
  3508  
  3509  /**
  3510   * optional bytes TxHash = 2;
  3511   * @return {!(string|Uint8Array)}
  3512   */
  3513  proto.exec.Header.prototype.getTxhash = function() {
  3514    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
  3515  };
  3516  
  3517  
  3518  /**
  3519   * optional bytes TxHash = 2;
  3520   * This is a type-conversion wrapper around `getTxhash()`
  3521   * @return {string}
  3522   */
  3523  proto.exec.Header.prototype.getTxhash_asB64 = function() {
  3524    return /** @type {string} */ (jspb.Message.bytesAsB64(
  3525        this.getTxhash()));
  3526  };
  3527  
  3528  
  3529  /**
  3530   * optional bytes TxHash = 2;
  3531   * Note that Uint8Array is not supported on all browsers.
  3532   * @see http://caniuse.com/Uint8Array
  3533   * This is a type-conversion wrapper around `getTxhash()`
  3534   * @return {!Uint8Array}
  3535   */
  3536  proto.exec.Header.prototype.getTxhash_asU8 = function() {
  3537    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  3538        this.getTxhash()));
  3539  };
  3540  
  3541  
  3542  /**
  3543   * @param {!(string|Uint8Array)} value
  3544   * @return {!proto.exec.Header} returns this
  3545   */
  3546  proto.exec.Header.prototype.setTxhash = function(value) {
  3547    return jspb.Message.setProto3BytesField(this, 2, value);
  3548  };
  3549  
  3550  
  3551  /**
  3552   * optional uint32 EventType = 3;
  3553   * @return {number}
  3554   */
  3555  proto.exec.Header.prototype.getEventtype = function() {
  3556    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));
  3557  };
  3558  
  3559  
  3560  /**
  3561   * @param {number} value
  3562   * @return {!proto.exec.Header} returns this
  3563   */
  3564  proto.exec.Header.prototype.setEventtype = function(value) {
  3565    return jspb.Message.setProto3IntField(this, 3, value);
  3566  };
  3567  
  3568  
  3569  /**
  3570   * optional string EventID = 4;
  3571   * @return {string}
  3572   */
  3573  proto.exec.Header.prototype.getEventid = function() {
  3574    return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
  3575  };
  3576  
  3577  
  3578  /**
  3579   * @param {string} value
  3580   * @return {!proto.exec.Header} returns this
  3581   */
  3582  proto.exec.Header.prototype.setEventid = function(value) {
  3583    return jspb.Message.setProto3StringField(this, 4, value);
  3584  };
  3585  
  3586  
  3587  /**
  3588   * optional uint64 Height = 5;
  3589   * @return {number}
  3590   */
  3591  proto.exec.Header.prototype.getHeight = function() {
  3592    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0));
  3593  };
  3594  
  3595  
  3596  /**
  3597   * @param {number} value
  3598   * @return {!proto.exec.Header} returns this
  3599   */
  3600  proto.exec.Header.prototype.setHeight = function(value) {
  3601    return jspb.Message.setProto3IntField(this, 5, value);
  3602  };
  3603  
  3604  
  3605  /**
  3606   * optional uint64 Index = 6;
  3607   * @return {number}
  3608   */
  3609  proto.exec.Header.prototype.getIndex = function() {
  3610    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 6, 0));
  3611  };
  3612  
  3613  
  3614  /**
  3615   * @param {number} value
  3616   * @return {!proto.exec.Header} returns this
  3617   */
  3618  proto.exec.Header.prototype.setIndex = function(value) {
  3619    return jspb.Message.setProto3IntField(this, 6, value);
  3620  };
  3621  
  3622  
  3623  /**
  3624   * optional errors.Exception Exception = 7;
  3625   * @return {?proto.errors.Exception}
  3626   */
  3627  proto.exec.Header.prototype.getException = function() {
  3628    return /** @type{?proto.errors.Exception} */ (
  3629      jspb.Message.getWrapperField(this, errors_pb.Exception, 7));
  3630  };
  3631  
  3632  
  3633  /**
  3634   * @param {?proto.errors.Exception|undefined} value
  3635   * @return {!proto.exec.Header} returns this
  3636  */
  3637  proto.exec.Header.prototype.setException = function(value) {
  3638    return jspb.Message.setWrapperField(this, 7, value);
  3639  };
  3640  
  3641  
  3642  /**
  3643   * Clears the message field making it undefined.
  3644   * @return {!proto.exec.Header} returns this
  3645   */
  3646  proto.exec.Header.prototype.clearException = function() {
  3647    return this.setException(undefined);
  3648  };
  3649  
  3650  
  3651  /**
  3652   * Returns whether this field is set.
  3653   * @return {boolean}
  3654   */
  3655  proto.exec.Header.prototype.hasException = function() {
  3656    return jspb.Message.getField(this, 7) != null;
  3657  };
  3658  
  3659  
  3660  
  3661  
  3662  
  3663  if (jspb.Message.GENERATE_TO_OBJECT) {
  3664  /**
  3665   * Creates an object representation of this proto.
  3666   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  3667   * Optional fields that are not set will be set to undefined.
  3668   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  3669   * For the list of reserved names please see:
  3670   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  3671   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  3672   *     JSPB instance for transitional soy proto support:
  3673   *     http://goto/soy-param-migration
  3674   * @return {!Object}
  3675   */
  3676  proto.exec.Event.prototype.toObject = function(opt_includeInstance) {
  3677    return proto.exec.Event.toObject(opt_includeInstance, this);
  3678  };
  3679  
  3680  
  3681  /**
  3682   * Static version of the {@see toObject} method.
  3683   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  3684   *     the JSPB instance for transitional soy proto support:
  3685   *     http://goto/soy-param-migration
  3686   * @param {!proto.exec.Event} msg The msg instance to transform.
  3687   * @return {!Object}
  3688   * @suppress {unusedLocalVariables} f is only used for nested messages
  3689   */
  3690  proto.exec.Event.toObject = function(includeInstance, msg) {
  3691    var f, obj = {
  3692      header: (f = msg.getHeader()) && proto.exec.Header.toObject(includeInstance, f),
  3693      input: (f = msg.getInput()) && proto.exec.InputEvent.toObject(includeInstance, f),
  3694      output: (f = msg.getOutput()) && proto.exec.OutputEvent.toObject(includeInstance, f),
  3695      call: (f = msg.getCall()) && proto.exec.CallEvent.toObject(includeInstance, f),
  3696      log: (f = msg.getLog()) && proto.exec.LogEvent.toObject(includeInstance, f),
  3697      governaccount: (f = msg.getGovernaccount()) && proto.exec.GovernAccountEvent.toObject(includeInstance, f),
  3698      print: (f = msg.getPrint()) && proto.exec.PrintEvent.toObject(includeInstance, f)
  3699    };
  3700  
  3701    if (includeInstance) {
  3702      obj.$jspbMessageInstance = msg;
  3703    }
  3704    return obj;
  3705  };
  3706  }
  3707  
  3708  
  3709  /**
  3710   * Deserializes binary data (in protobuf wire format).
  3711   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  3712   * @return {!proto.exec.Event}
  3713   */
  3714  proto.exec.Event.deserializeBinary = function(bytes) {
  3715    var reader = new jspb.BinaryReader(bytes);
  3716    var msg = new proto.exec.Event;
  3717    return proto.exec.Event.deserializeBinaryFromReader(msg, reader);
  3718  };
  3719  
  3720  
  3721  /**
  3722   * Deserializes binary data (in protobuf wire format) from the
  3723   * given reader into the given message object.
  3724   * @param {!proto.exec.Event} msg The message object to deserialize into.
  3725   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  3726   * @return {!proto.exec.Event}
  3727   */
  3728  proto.exec.Event.deserializeBinaryFromReader = function(msg, reader) {
  3729    while (reader.nextField()) {
  3730      if (reader.isEndGroup()) {
  3731        break;
  3732      }
  3733      var field = reader.getFieldNumber();
  3734      switch (field) {
  3735      case 1:
  3736        var value = new proto.exec.Header;
  3737        reader.readMessage(value,proto.exec.Header.deserializeBinaryFromReader);
  3738        msg.setHeader(value);
  3739        break;
  3740      case 2:
  3741        var value = new proto.exec.InputEvent;
  3742        reader.readMessage(value,proto.exec.InputEvent.deserializeBinaryFromReader);
  3743        msg.setInput(value);
  3744        break;
  3745      case 3:
  3746        var value = new proto.exec.OutputEvent;
  3747        reader.readMessage(value,proto.exec.OutputEvent.deserializeBinaryFromReader);
  3748        msg.setOutput(value);
  3749        break;
  3750      case 4:
  3751        var value = new proto.exec.CallEvent;
  3752        reader.readMessage(value,proto.exec.CallEvent.deserializeBinaryFromReader);
  3753        msg.setCall(value);
  3754        break;
  3755      case 5:
  3756        var value = new proto.exec.LogEvent;
  3757        reader.readMessage(value,proto.exec.LogEvent.deserializeBinaryFromReader);
  3758        msg.setLog(value);
  3759        break;
  3760      case 6:
  3761        var value = new proto.exec.GovernAccountEvent;
  3762        reader.readMessage(value,proto.exec.GovernAccountEvent.deserializeBinaryFromReader);
  3763        msg.setGovernaccount(value);
  3764        break;
  3765      case 7:
  3766        var value = new proto.exec.PrintEvent;
  3767        reader.readMessage(value,proto.exec.PrintEvent.deserializeBinaryFromReader);
  3768        msg.setPrint(value);
  3769        break;
  3770      default:
  3771        reader.skipField();
  3772        break;
  3773      }
  3774    }
  3775    return msg;
  3776  };
  3777  
  3778  
  3779  /**
  3780   * Serializes the message to binary data (in protobuf wire format).
  3781   * @return {!Uint8Array}
  3782   */
  3783  proto.exec.Event.prototype.serializeBinary = function() {
  3784    var writer = new jspb.BinaryWriter();
  3785    proto.exec.Event.serializeBinaryToWriter(this, writer);
  3786    return writer.getResultBuffer();
  3787  };
  3788  
  3789  
  3790  /**
  3791   * Serializes the given message to binary data (in protobuf wire
  3792   * format), writing to the given BinaryWriter.
  3793   * @param {!proto.exec.Event} message
  3794   * @param {!jspb.BinaryWriter} writer
  3795   * @suppress {unusedLocalVariables} f is only used for nested messages
  3796   */
  3797  proto.exec.Event.serializeBinaryToWriter = function(message, writer) {
  3798    var f = undefined;
  3799    f = message.getHeader();
  3800    if (f != null) {
  3801      writer.writeMessage(
  3802        1,
  3803        f,
  3804        proto.exec.Header.serializeBinaryToWriter
  3805      );
  3806    }
  3807    f = message.getInput();
  3808    if (f != null) {
  3809      writer.writeMessage(
  3810        2,
  3811        f,
  3812        proto.exec.InputEvent.serializeBinaryToWriter
  3813      );
  3814    }
  3815    f = message.getOutput();
  3816    if (f != null) {
  3817      writer.writeMessage(
  3818        3,
  3819        f,
  3820        proto.exec.OutputEvent.serializeBinaryToWriter
  3821      );
  3822    }
  3823    f = message.getCall();
  3824    if (f != null) {
  3825      writer.writeMessage(
  3826        4,
  3827        f,
  3828        proto.exec.CallEvent.serializeBinaryToWriter
  3829      );
  3830    }
  3831    f = message.getLog();
  3832    if (f != null) {
  3833      writer.writeMessage(
  3834        5,
  3835        f,
  3836        proto.exec.LogEvent.serializeBinaryToWriter
  3837      );
  3838    }
  3839    f = message.getGovernaccount();
  3840    if (f != null) {
  3841      writer.writeMessage(
  3842        6,
  3843        f,
  3844        proto.exec.GovernAccountEvent.serializeBinaryToWriter
  3845      );
  3846    }
  3847    f = message.getPrint();
  3848    if (f != null) {
  3849      writer.writeMessage(
  3850        7,
  3851        f,
  3852        proto.exec.PrintEvent.serializeBinaryToWriter
  3853      );
  3854    }
  3855  };
  3856  
  3857  
  3858  /**
  3859   * optional Header Header = 1;
  3860   * @return {?proto.exec.Header}
  3861   */
  3862  proto.exec.Event.prototype.getHeader = function() {
  3863    return /** @type{?proto.exec.Header} */ (
  3864      jspb.Message.getWrapperField(this, proto.exec.Header, 1));
  3865  };
  3866  
  3867  
  3868  /**
  3869   * @param {?proto.exec.Header|undefined} value
  3870   * @return {!proto.exec.Event} returns this
  3871  */
  3872  proto.exec.Event.prototype.setHeader = function(value) {
  3873    return jspb.Message.setWrapperField(this, 1, value);
  3874  };
  3875  
  3876  
  3877  /**
  3878   * Clears the message field making it undefined.
  3879   * @return {!proto.exec.Event} returns this
  3880   */
  3881  proto.exec.Event.prototype.clearHeader = function() {
  3882    return this.setHeader(undefined);
  3883  };
  3884  
  3885  
  3886  /**
  3887   * Returns whether this field is set.
  3888   * @return {boolean}
  3889   */
  3890  proto.exec.Event.prototype.hasHeader = function() {
  3891    return jspb.Message.getField(this, 1) != null;
  3892  };
  3893  
  3894  
  3895  /**
  3896   * optional InputEvent Input = 2;
  3897   * @return {?proto.exec.InputEvent}
  3898   */
  3899  proto.exec.Event.prototype.getInput = function() {
  3900    return /** @type{?proto.exec.InputEvent} */ (
  3901      jspb.Message.getWrapperField(this, proto.exec.InputEvent, 2));
  3902  };
  3903  
  3904  
  3905  /**
  3906   * @param {?proto.exec.InputEvent|undefined} value
  3907   * @return {!proto.exec.Event} returns this
  3908  */
  3909  proto.exec.Event.prototype.setInput = function(value) {
  3910    return jspb.Message.setWrapperField(this, 2, value);
  3911  };
  3912  
  3913  
  3914  /**
  3915   * Clears the message field making it undefined.
  3916   * @return {!proto.exec.Event} returns this
  3917   */
  3918  proto.exec.Event.prototype.clearInput = function() {
  3919    return this.setInput(undefined);
  3920  };
  3921  
  3922  
  3923  /**
  3924   * Returns whether this field is set.
  3925   * @return {boolean}
  3926   */
  3927  proto.exec.Event.prototype.hasInput = function() {
  3928    return jspb.Message.getField(this, 2) != null;
  3929  };
  3930  
  3931  
  3932  /**
  3933   * optional OutputEvent Output = 3;
  3934   * @return {?proto.exec.OutputEvent}
  3935   */
  3936  proto.exec.Event.prototype.getOutput = function() {
  3937    return /** @type{?proto.exec.OutputEvent} */ (
  3938      jspb.Message.getWrapperField(this, proto.exec.OutputEvent, 3));
  3939  };
  3940  
  3941  
  3942  /**
  3943   * @param {?proto.exec.OutputEvent|undefined} value
  3944   * @return {!proto.exec.Event} returns this
  3945  */
  3946  proto.exec.Event.prototype.setOutput = function(value) {
  3947    return jspb.Message.setWrapperField(this, 3, value);
  3948  };
  3949  
  3950  
  3951  /**
  3952   * Clears the message field making it undefined.
  3953   * @return {!proto.exec.Event} returns this
  3954   */
  3955  proto.exec.Event.prototype.clearOutput = function() {
  3956    return this.setOutput(undefined);
  3957  };
  3958  
  3959  
  3960  /**
  3961   * Returns whether this field is set.
  3962   * @return {boolean}
  3963   */
  3964  proto.exec.Event.prototype.hasOutput = function() {
  3965    return jspb.Message.getField(this, 3) != null;
  3966  };
  3967  
  3968  
  3969  /**
  3970   * optional CallEvent Call = 4;
  3971   * @return {?proto.exec.CallEvent}
  3972   */
  3973  proto.exec.Event.prototype.getCall = function() {
  3974    return /** @type{?proto.exec.CallEvent} */ (
  3975      jspb.Message.getWrapperField(this, proto.exec.CallEvent, 4));
  3976  };
  3977  
  3978  
  3979  /**
  3980   * @param {?proto.exec.CallEvent|undefined} value
  3981   * @return {!proto.exec.Event} returns this
  3982  */
  3983  proto.exec.Event.prototype.setCall = function(value) {
  3984    return jspb.Message.setWrapperField(this, 4, value);
  3985  };
  3986  
  3987  
  3988  /**
  3989   * Clears the message field making it undefined.
  3990   * @return {!proto.exec.Event} returns this
  3991   */
  3992  proto.exec.Event.prototype.clearCall = function() {
  3993    return this.setCall(undefined);
  3994  };
  3995  
  3996  
  3997  /**
  3998   * Returns whether this field is set.
  3999   * @return {boolean}
  4000   */
  4001  proto.exec.Event.prototype.hasCall = function() {
  4002    return jspb.Message.getField(this, 4) != null;
  4003  };
  4004  
  4005  
  4006  /**
  4007   * optional LogEvent Log = 5;
  4008   * @return {?proto.exec.LogEvent}
  4009   */
  4010  proto.exec.Event.prototype.getLog = function() {
  4011    return /** @type{?proto.exec.LogEvent} */ (
  4012      jspb.Message.getWrapperField(this, proto.exec.LogEvent, 5));
  4013  };
  4014  
  4015  
  4016  /**
  4017   * @param {?proto.exec.LogEvent|undefined} value
  4018   * @return {!proto.exec.Event} returns this
  4019  */
  4020  proto.exec.Event.prototype.setLog = function(value) {
  4021    return jspb.Message.setWrapperField(this, 5, value);
  4022  };
  4023  
  4024  
  4025  /**
  4026   * Clears the message field making it undefined.
  4027   * @return {!proto.exec.Event} returns this
  4028   */
  4029  proto.exec.Event.prototype.clearLog = function() {
  4030    return this.setLog(undefined);
  4031  };
  4032  
  4033  
  4034  /**
  4035   * Returns whether this field is set.
  4036   * @return {boolean}
  4037   */
  4038  proto.exec.Event.prototype.hasLog = function() {
  4039    return jspb.Message.getField(this, 5) != null;
  4040  };
  4041  
  4042  
  4043  /**
  4044   * optional GovernAccountEvent GovernAccount = 6;
  4045   * @return {?proto.exec.GovernAccountEvent}
  4046   */
  4047  proto.exec.Event.prototype.getGovernaccount = function() {
  4048    return /** @type{?proto.exec.GovernAccountEvent} */ (
  4049      jspb.Message.getWrapperField(this, proto.exec.GovernAccountEvent, 6));
  4050  };
  4051  
  4052  
  4053  /**
  4054   * @param {?proto.exec.GovernAccountEvent|undefined} value
  4055   * @return {!proto.exec.Event} returns this
  4056  */
  4057  proto.exec.Event.prototype.setGovernaccount = function(value) {
  4058    return jspb.Message.setWrapperField(this, 6, value);
  4059  };
  4060  
  4061  
  4062  /**
  4063   * Clears the message field making it undefined.
  4064   * @return {!proto.exec.Event} returns this
  4065   */
  4066  proto.exec.Event.prototype.clearGovernaccount = function() {
  4067    return this.setGovernaccount(undefined);
  4068  };
  4069  
  4070  
  4071  /**
  4072   * Returns whether this field is set.
  4073   * @return {boolean}
  4074   */
  4075  proto.exec.Event.prototype.hasGovernaccount = function() {
  4076    return jspb.Message.getField(this, 6) != null;
  4077  };
  4078  
  4079  
  4080  /**
  4081   * optional PrintEvent Print = 7;
  4082   * @return {?proto.exec.PrintEvent}
  4083   */
  4084  proto.exec.Event.prototype.getPrint = function() {
  4085    return /** @type{?proto.exec.PrintEvent} */ (
  4086      jspb.Message.getWrapperField(this, proto.exec.PrintEvent, 7));
  4087  };
  4088  
  4089  
  4090  /**
  4091   * @param {?proto.exec.PrintEvent|undefined} value
  4092   * @return {!proto.exec.Event} returns this
  4093  */
  4094  proto.exec.Event.prototype.setPrint = function(value) {
  4095    return jspb.Message.setWrapperField(this, 7, value);
  4096  };
  4097  
  4098  
  4099  /**
  4100   * Clears the message field making it undefined.
  4101   * @return {!proto.exec.Event} returns this
  4102   */
  4103  proto.exec.Event.prototype.clearPrint = function() {
  4104    return this.setPrint(undefined);
  4105  };
  4106  
  4107  
  4108  /**
  4109   * Returns whether this field is set.
  4110   * @return {boolean}
  4111   */
  4112  proto.exec.Event.prototype.hasPrint = function() {
  4113    return jspb.Message.getField(this, 7) != null;
  4114  };
  4115  
  4116  
  4117  
  4118  
  4119  
  4120  if (jspb.Message.GENERATE_TO_OBJECT) {
  4121  /**
  4122   * Creates an object representation of this proto.
  4123   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  4124   * Optional fields that are not set will be set to undefined.
  4125   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  4126   * For the list of reserved names please see:
  4127   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  4128   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  4129   *     JSPB instance for transitional soy proto support:
  4130   *     http://goto/soy-param-migration
  4131   * @return {!Object}
  4132   */
  4133  proto.exec.Result.prototype.toObject = function(opt_includeInstance) {
  4134    return proto.exec.Result.toObject(opt_includeInstance, this);
  4135  };
  4136  
  4137  
  4138  /**
  4139   * Static version of the {@see toObject} method.
  4140   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  4141   *     the JSPB instance for transitional soy proto support:
  4142   *     http://goto/soy-param-migration
  4143   * @param {!proto.exec.Result} msg The msg instance to transform.
  4144   * @return {!Object}
  4145   * @suppress {unusedLocalVariables} f is only used for nested messages
  4146   */
  4147  proto.exec.Result.toObject = function(includeInstance, msg) {
  4148    var f, obj = {
  4149      pb_return: msg.getReturn_asB64(),
  4150      gasused: jspb.Message.getFieldWithDefault(msg, 2, 0),
  4151      nameentry: (f = msg.getNameentry()) && names_pb.Entry.toObject(includeInstance, f),
  4152      permargs: (f = msg.getPermargs()) && permission_pb.PermArgs.toObject(includeInstance, f)
  4153    };
  4154  
  4155    if (includeInstance) {
  4156      obj.$jspbMessageInstance = msg;
  4157    }
  4158    return obj;
  4159  };
  4160  }
  4161  
  4162  
  4163  /**
  4164   * Deserializes binary data (in protobuf wire format).
  4165   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  4166   * @return {!proto.exec.Result}
  4167   */
  4168  proto.exec.Result.deserializeBinary = function(bytes) {
  4169    var reader = new jspb.BinaryReader(bytes);
  4170    var msg = new proto.exec.Result;
  4171    return proto.exec.Result.deserializeBinaryFromReader(msg, reader);
  4172  };
  4173  
  4174  
  4175  /**
  4176   * Deserializes binary data (in protobuf wire format) from the
  4177   * given reader into the given message object.
  4178   * @param {!proto.exec.Result} msg The message object to deserialize into.
  4179   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  4180   * @return {!proto.exec.Result}
  4181   */
  4182  proto.exec.Result.deserializeBinaryFromReader = function(msg, reader) {
  4183    while (reader.nextField()) {
  4184      if (reader.isEndGroup()) {
  4185        break;
  4186      }
  4187      var field = reader.getFieldNumber();
  4188      switch (field) {
  4189      case 1:
  4190        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  4191        msg.setReturn(value);
  4192        break;
  4193      case 2:
  4194        var value = /** @type {number} */ (reader.readUint64());
  4195        msg.setGasused(value);
  4196        break;
  4197      case 3:
  4198        var value = new names_pb.Entry;
  4199        reader.readMessage(value,names_pb.Entry.deserializeBinaryFromReader);
  4200        msg.setNameentry(value);
  4201        break;
  4202      case 4:
  4203        var value = new permission_pb.PermArgs;
  4204        reader.readMessage(value,permission_pb.PermArgs.deserializeBinaryFromReader);
  4205        msg.setPermargs(value);
  4206        break;
  4207      default:
  4208        reader.skipField();
  4209        break;
  4210      }
  4211    }
  4212    return msg;
  4213  };
  4214  
  4215  
  4216  /**
  4217   * Serializes the message to binary data (in protobuf wire format).
  4218   * @return {!Uint8Array}
  4219   */
  4220  proto.exec.Result.prototype.serializeBinary = function() {
  4221    var writer = new jspb.BinaryWriter();
  4222    proto.exec.Result.serializeBinaryToWriter(this, writer);
  4223    return writer.getResultBuffer();
  4224  };
  4225  
  4226  
  4227  /**
  4228   * Serializes the given message to binary data (in protobuf wire
  4229   * format), writing to the given BinaryWriter.
  4230   * @param {!proto.exec.Result} message
  4231   * @param {!jspb.BinaryWriter} writer
  4232   * @suppress {unusedLocalVariables} f is only used for nested messages
  4233   */
  4234  proto.exec.Result.serializeBinaryToWriter = function(message, writer) {
  4235    var f = undefined;
  4236    f = message.getReturn_asU8();
  4237    if (f.length > 0) {
  4238      writer.writeBytes(
  4239        1,
  4240        f
  4241      );
  4242    }
  4243    f = message.getGasused();
  4244    if (f !== 0) {
  4245      writer.writeUint64(
  4246        2,
  4247        f
  4248      );
  4249    }
  4250    f = message.getNameentry();
  4251    if (f != null) {
  4252      writer.writeMessage(
  4253        3,
  4254        f,
  4255        names_pb.Entry.serializeBinaryToWriter
  4256      );
  4257    }
  4258    f = message.getPermargs();
  4259    if (f != null) {
  4260      writer.writeMessage(
  4261        4,
  4262        f,
  4263        permission_pb.PermArgs.serializeBinaryToWriter
  4264      );
  4265    }
  4266  };
  4267  
  4268  
  4269  /**
  4270   * optional bytes Return = 1;
  4271   * @return {!(string|Uint8Array)}
  4272   */
  4273  proto.exec.Result.prototype.getReturn = function() {
  4274    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
  4275  };
  4276  
  4277  
  4278  /**
  4279   * optional bytes Return = 1;
  4280   * This is a type-conversion wrapper around `getReturn()`
  4281   * @return {string}
  4282   */
  4283  proto.exec.Result.prototype.getReturn_asB64 = function() {
  4284    return /** @type {string} */ (jspb.Message.bytesAsB64(
  4285        this.getReturn()));
  4286  };
  4287  
  4288  
  4289  /**
  4290   * optional bytes Return = 1;
  4291   * Note that Uint8Array is not supported on all browsers.
  4292   * @see http://caniuse.com/Uint8Array
  4293   * This is a type-conversion wrapper around `getReturn()`
  4294   * @return {!Uint8Array}
  4295   */
  4296  proto.exec.Result.prototype.getReturn_asU8 = function() {
  4297    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  4298        this.getReturn()));
  4299  };
  4300  
  4301  
  4302  /**
  4303   * @param {!(string|Uint8Array)} value
  4304   * @return {!proto.exec.Result} returns this
  4305   */
  4306  proto.exec.Result.prototype.setReturn = function(value) {
  4307    return jspb.Message.setProto3BytesField(this, 1, value);
  4308  };
  4309  
  4310  
  4311  /**
  4312   * optional uint64 GasUsed = 2;
  4313   * @return {number}
  4314   */
  4315  proto.exec.Result.prototype.getGasused = function() {
  4316    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0));
  4317  };
  4318  
  4319  
  4320  /**
  4321   * @param {number} value
  4322   * @return {!proto.exec.Result} returns this
  4323   */
  4324  proto.exec.Result.prototype.setGasused = function(value) {
  4325    return jspb.Message.setProto3IntField(this, 2, value);
  4326  };
  4327  
  4328  
  4329  /**
  4330   * optional names.Entry NameEntry = 3;
  4331   * @return {?proto.names.Entry}
  4332   */
  4333  proto.exec.Result.prototype.getNameentry = function() {
  4334    return /** @type{?proto.names.Entry} */ (
  4335      jspb.Message.getWrapperField(this, names_pb.Entry, 3));
  4336  };
  4337  
  4338  
  4339  /**
  4340   * @param {?proto.names.Entry|undefined} value
  4341   * @return {!proto.exec.Result} returns this
  4342  */
  4343  proto.exec.Result.prototype.setNameentry = function(value) {
  4344    return jspb.Message.setWrapperField(this, 3, value);
  4345  };
  4346  
  4347  
  4348  /**
  4349   * Clears the message field making it undefined.
  4350   * @return {!proto.exec.Result} returns this
  4351   */
  4352  proto.exec.Result.prototype.clearNameentry = function() {
  4353    return this.setNameentry(undefined);
  4354  };
  4355  
  4356  
  4357  /**
  4358   * Returns whether this field is set.
  4359   * @return {boolean}
  4360   */
  4361  proto.exec.Result.prototype.hasNameentry = function() {
  4362    return jspb.Message.getField(this, 3) != null;
  4363  };
  4364  
  4365  
  4366  /**
  4367   * optional permission.PermArgs PermArgs = 4;
  4368   * @return {?proto.permission.PermArgs}
  4369   */
  4370  proto.exec.Result.prototype.getPermargs = function() {
  4371    return /** @type{?proto.permission.PermArgs} */ (
  4372      jspb.Message.getWrapperField(this, permission_pb.PermArgs, 4));
  4373  };
  4374  
  4375  
  4376  /**
  4377   * @param {?proto.permission.PermArgs|undefined} value
  4378   * @return {!proto.exec.Result} returns this
  4379  */
  4380  proto.exec.Result.prototype.setPermargs = function(value) {
  4381    return jspb.Message.setWrapperField(this, 4, value);
  4382  };
  4383  
  4384  
  4385  /**
  4386   * Clears the message field making it undefined.
  4387   * @return {!proto.exec.Result} returns this
  4388   */
  4389  proto.exec.Result.prototype.clearPermargs = function() {
  4390    return this.setPermargs(undefined);
  4391  };
  4392  
  4393  
  4394  /**
  4395   * Returns whether this field is set.
  4396   * @return {boolean}
  4397   */
  4398  proto.exec.Result.prototype.hasPermargs = function() {
  4399    return jspb.Message.getField(this, 4) != null;
  4400  };
  4401  
  4402  
  4403  
  4404  /**
  4405   * List of repeated fields within this message type.
  4406   * @private {!Array<number>}
  4407   * @const
  4408   */
  4409  proto.exec.LogEvent.repeatedFields_ = [3];
  4410  
  4411  
  4412  
  4413  if (jspb.Message.GENERATE_TO_OBJECT) {
  4414  /**
  4415   * Creates an object representation of this proto.
  4416   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  4417   * Optional fields that are not set will be set to undefined.
  4418   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  4419   * For the list of reserved names please see:
  4420   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  4421   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  4422   *     JSPB instance for transitional soy proto support:
  4423   *     http://goto/soy-param-migration
  4424   * @return {!Object}
  4425   */
  4426  proto.exec.LogEvent.prototype.toObject = function(opt_includeInstance) {
  4427    return proto.exec.LogEvent.toObject(opt_includeInstance, this);
  4428  };
  4429  
  4430  
  4431  /**
  4432   * Static version of the {@see toObject} method.
  4433   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  4434   *     the JSPB instance for transitional soy proto support:
  4435   *     http://goto/soy-param-migration
  4436   * @param {!proto.exec.LogEvent} msg The msg instance to transform.
  4437   * @return {!Object}
  4438   * @suppress {unusedLocalVariables} f is only used for nested messages
  4439   */
  4440  proto.exec.LogEvent.toObject = function(includeInstance, msg) {
  4441    var f, obj = {
  4442      address: msg.getAddress_asB64(),
  4443      data: msg.getData_asB64(),
  4444      topicsList: msg.getTopicsList_asB64()
  4445    };
  4446  
  4447    if (includeInstance) {
  4448      obj.$jspbMessageInstance = msg;
  4449    }
  4450    return obj;
  4451  };
  4452  }
  4453  
  4454  
  4455  /**
  4456   * Deserializes binary data (in protobuf wire format).
  4457   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  4458   * @return {!proto.exec.LogEvent}
  4459   */
  4460  proto.exec.LogEvent.deserializeBinary = function(bytes) {
  4461    var reader = new jspb.BinaryReader(bytes);
  4462    var msg = new proto.exec.LogEvent;
  4463    return proto.exec.LogEvent.deserializeBinaryFromReader(msg, reader);
  4464  };
  4465  
  4466  
  4467  /**
  4468   * Deserializes binary data (in protobuf wire format) from the
  4469   * given reader into the given message object.
  4470   * @param {!proto.exec.LogEvent} msg The message object to deserialize into.
  4471   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  4472   * @return {!proto.exec.LogEvent}
  4473   */
  4474  proto.exec.LogEvent.deserializeBinaryFromReader = function(msg, reader) {
  4475    while (reader.nextField()) {
  4476      if (reader.isEndGroup()) {
  4477        break;
  4478      }
  4479      var field = reader.getFieldNumber();
  4480      switch (field) {
  4481      case 1:
  4482        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  4483        msg.setAddress(value);
  4484        break;
  4485      case 2:
  4486        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  4487        msg.setData(value);
  4488        break;
  4489      case 3:
  4490        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  4491        msg.addTopics(value);
  4492        break;
  4493      default:
  4494        reader.skipField();
  4495        break;
  4496      }
  4497    }
  4498    return msg;
  4499  };
  4500  
  4501  
  4502  /**
  4503   * Serializes the message to binary data (in protobuf wire format).
  4504   * @return {!Uint8Array}
  4505   */
  4506  proto.exec.LogEvent.prototype.serializeBinary = function() {
  4507    var writer = new jspb.BinaryWriter();
  4508    proto.exec.LogEvent.serializeBinaryToWriter(this, writer);
  4509    return writer.getResultBuffer();
  4510  };
  4511  
  4512  
  4513  /**
  4514   * Serializes the given message to binary data (in protobuf wire
  4515   * format), writing to the given BinaryWriter.
  4516   * @param {!proto.exec.LogEvent} message
  4517   * @param {!jspb.BinaryWriter} writer
  4518   * @suppress {unusedLocalVariables} f is only used for nested messages
  4519   */
  4520  proto.exec.LogEvent.serializeBinaryToWriter = function(message, writer) {
  4521    var f = undefined;
  4522    f = message.getAddress_asU8();
  4523    if (f.length > 0) {
  4524      writer.writeBytes(
  4525        1,
  4526        f
  4527      );
  4528    }
  4529    f = message.getData_asU8();
  4530    if (f.length > 0) {
  4531      writer.writeBytes(
  4532        2,
  4533        f
  4534      );
  4535    }
  4536    f = message.getTopicsList_asU8();
  4537    if (f.length > 0) {
  4538      writer.writeRepeatedBytes(
  4539        3,
  4540        f
  4541      );
  4542    }
  4543  };
  4544  
  4545  
  4546  /**
  4547   * optional bytes Address = 1;
  4548   * @return {!(string|Uint8Array)}
  4549   */
  4550  proto.exec.LogEvent.prototype.getAddress = function() {
  4551    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
  4552  };
  4553  
  4554  
  4555  /**
  4556   * optional bytes Address = 1;
  4557   * This is a type-conversion wrapper around `getAddress()`
  4558   * @return {string}
  4559   */
  4560  proto.exec.LogEvent.prototype.getAddress_asB64 = function() {
  4561    return /** @type {string} */ (jspb.Message.bytesAsB64(
  4562        this.getAddress()));
  4563  };
  4564  
  4565  
  4566  /**
  4567   * optional bytes Address = 1;
  4568   * Note that Uint8Array is not supported on all browsers.
  4569   * @see http://caniuse.com/Uint8Array
  4570   * This is a type-conversion wrapper around `getAddress()`
  4571   * @return {!Uint8Array}
  4572   */
  4573  proto.exec.LogEvent.prototype.getAddress_asU8 = function() {
  4574    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  4575        this.getAddress()));
  4576  };
  4577  
  4578  
  4579  /**
  4580   * @param {!(string|Uint8Array)} value
  4581   * @return {!proto.exec.LogEvent} returns this
  4582   */
  4583  proto.exec.LogEvent.prototype.setAddress = function(value) {
  4584    return jspb.Message.setProto3BytesField(this, 1, value);
  4585  };
  4586  
  4587  
  4588  /**
  4589   * optional bytes Data = 2;
  4590   * @return {!(string|Uint8Array)}
  4591   */
  4592  proto.exec.LogEvent.prototype.getData = function() {
  4593    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
  4594  };
  4595  
  4596  
  4597  /**
  4598   * optional bytes Data = 2;
  4599   * This is a type-conversion wrapper around `getData()`
  4600   * @return {string}
  4601   */
  4602  proto.exec.LogEvent.prototype.getData_asB64 = function() {
  4603    return /** @type {string} */ (jspb.Message.bytesAsB64(
  4604        this.getData()));
  4605  };
  4606  
  4607  
  4608  /**
  4609   * optional bytes Data = 2;
  4610   * Note that Uint8Array is not supported on all browsers.
  4611   * @see http://caniuse.com/Uint8Array
  4612   * This is a type-conversion wrapper around `getData()`
  4613   * @return {!Uint8Array}
  4614   */
  4615  proto.exec.LogEvent.prototype.getData_asU8 = function() {
  4616    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  4617        this.getData()));
  4618  };
  4619  
  4620  
  4621  /**
  4622   * @param {!(string|Uint8Array)} value
  4623   * @return {!proto.exec.LogEvent} returns this
  4624   */
  4625  proto.exec.LogEvent.prototype.setData = function(value) {
  4626    return jspb.Message.setProto3BytesField(this, 2, value);
  4627  };
  4628  
  4629  
  4630  /**
  4631   * repeated bytes Topics = 3;
  4632   * @return {!(Array<!Uint8Array>|Array<string>)}
  4633   */
  4634  proto.exec.LogEvent.prototype.getTopicsList = function() {
  4635    return /** @type {!(Array<!Uint8Array>|Array<string>)} */ (jspb.Message.getRepeatedField(this, 3));
  4636  };
  4637  
  4638  
  4639  /**
  4640   * repeated bytes Topics = 3;
  4641   * This is a type-conversion wrapper around `getTopicsList()`
  4642   * @return {!Array<string>}
  4643   */
  4644  proto.exec.LogEvent.prototype.getTopicsList_asB64 = function() {
  4645    return /** @type {!Array<string>} */ (jspb.Message.bytesListAsB64(
  4646        this.getTopicsList()));
  4647  };
  4648  
  4649  
  4650  /**
  4651   * repeated bytes Topics = 3;
  4652   * Note that Uint8Array is not supported on all browsers.
  4653   * @see http://caniuse.com/Uint8Array
  4654   * This is a type-conversion wrapper around `getTopicsList()`
  4655   * @return {!Array<!Uint8Array>}
  4656   */
  4657  proto.exec.LogEvent.prototype.getTopicsList_asU8 = function() {
  4658    return /** @type {!Array<!Uint8Array>} */ (jspb.Message.bytesListAsU8(
  4659        this.getTopicsList()));
  4660  };
  4661  
  4662  
  4663  /**
  4664   * @param {!(Array<!Uint8Array>|Array<string>)} value
  4665   * @return {!proto.exec.LogEvent} returns this
  4666   */
  4667  proto.exec.LogEvent.prototype.setTopicsList = function(value) {
  4668    return jspb.Message.setField(this, 3, value || []);
  4669  };
  4670  
  4671  
  4672  /**
  4673   * @param {!(string|Uint8Array)} value
  4674   * @param {number=} opt_index
  4675   * @return {!proto.exec.LogEvent} returns this
  4676   */
  4677  proto.exec.LogEvent.prototype.addTopics = function(value, opt_index) {
  4678    return jspb.Message.addToRepeatedField(this, 3, value, opt_index);
  4679  };
  4680  
  4681  
  4682  /**
  4683   * Clears the list making it empty but non-null.
  4684   * @return {!proto.exec.LogEvent} returns this
  4685   */
  4686  proto.exec.LogEvent.prototype.clearTopicsList = function() {
  4687    return this.setTopicsList([]);
  4688  };
  4689  
  4690  
  4691  
  4692  
  4693  
  4694  if (jspb.Message.GENERATE_TO_OBJECT) {
  4695  /**
  4696   * Creates an object representation of this proto.
  4697   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  4698   * Optional fields that are not set will be set to undefined.
  4699   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  4700   * For the list of reserved names please see:
  4701   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  4702   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  4703   *     JSPB instance for transitional soy proto support:
  4704   *     http://goto/soy-param-migration
  4705   * @return {!Object}
  4706   */
  4707  proto.exec.CallEvent.prototype.toObject = function(opt_includeInstance) {
  4708    return proto.exec.CallEvent.toObject(opt_includeInstance, this);
  4709  };
  4710  
  4711  
  4712  /**
  4713   * Static version of the {@see toObject} method.
  4714   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  4715   *     the JSPB instance for transitional soy proto support:
  4716   *     http://goto/soy-param-migration
  4717   * @param {!proto.exec.CallEvent} msg The msg instance to transform.
  4718   * @return {!Object}
  4719   * @suppress {unusedLocalVariables} f is only used for nested messages
  4720   */
  4721  proto.exec.CallEvent.toObject = function(includeInstance, msg) {
  4722    var f, obj = {
  4723      calltype: jspb.Message.getFieldWithDefault(msg, 5, 0),
  4724      calldata: (f = msg.getCalldata()) && proto.exec.CallData.toObject(includeInstance, f),
  4725      origin: msg.getOrigin_asB64(),
  4726      stackdepth: jspb.Message.getFieldWithDefault(msg, 3, 0),
  4727      pb_return: msg.getReturn_asB64()
  4728    };
  4729  
  4730    if (includeInstance) {
  4731      obj.$jspbMessageInstance = msg;
  4732    }
  4733    return obj;
  4734  };
  4735  }
  4736  
  4737  
  4738  /**
  4739   * Deserializes binary data (in protobuf wire format).
  4740   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  4741   * @return {!proto.exec.CallEvent}
  4742   */
  4743  proto.exec.CallEvent.deserializeBinary = function(bytes) {
  4744    var reader = new jspb.BinaryReader(bytes);
  4745    var msg = new proto.exec.CallEvent;
  4746    return proto.exec.CallEvent.deserializeBinaryFromReader(msg, reader);
  4747  };
  4748  
  4749  
  4750  /**
  4751   * Deserializes binary data (in protobuf wire format) from the
  4752   * given reader into the given message object.
  4753   * @param {!proto.exec.CallEvent} msg The message object to deserialize into.
  4754   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  4755   * @return {!proto.exec.CallEvent}
  4756   */
  4757  proto.exec.CallEvent.deserializeBinaryFromReader = function(msg, reader) {
  4758    while (reader.nextField()) {
  4759      if (reader.isEndGroup()) {
  4760        break;
  4761      }
  4762      var field = reader.getFieldNumber();
  4763      switch (field) {
  4764      case 5:
  4765        var value = /** @type {number} */ (reader.readUint32());
  4766        msg.setCalltype(value);
  4767        break;
  4768      case 1:
  4769        var value = new proto.exec.CallData;
  4770        reader.readMessage(value,proto.exec.CallData.deserializeBinaryFromReader);
  4771        msg.setCalldata(value);
  4772        break;
  4773      case 2:
  4774        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  4775        msg.setOrigin(value);
  4776        break;
  4777      case 3:
  4778        var value = /** @type {number} */ (reader.readUint64());
  4779        msg.setStackdepth(value);
  4780        break;
  4781      case 4:
  4782        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  4783        msg.setReturn(value);
  4784        break;
  4785      default:
  4786        reader.skipField();
  4787        break;
  4788      }
  4789    }
  4790    return msg;
  4791  };
  4792  
  4793  
  4794  /**
  4795   * Serializes the message to binary data (in protobuf wire format).
  4796   * @return {!Uint8Array}
  4797   */
  4798  proto.exec.CallEvent.prototype.serializeBinary = function() {
  4799    var writer = new jspb.BinaryWriter();
  4800    proto.exec.CallEvent.serializeBinaryToWriter(this, writer);
  4801    return writer.getResultBuffer();
  4802  };
  4803  
  4804  
  4805  /**
  4806   * Serializes the given message to binary data (in protobuf wire
  4807   * format), writing to the given BinaryWriter.
  4808   * @param {!proto.exec.CallEvent} message
  4809   * @param {!jspb.BinaryWriter} writer
  4810   * @suppress {unusedLocalVariables} f is only used for nested messages
  4811   */
  4812  proto.exec.CallEvent.serializeBinaryToWriter = function(message, writer) {
  4813    var f = undefined;
  4814    f = message.getCalltype();
  4815    if (f !== 0) {
  4816      writer.writeUint32(
  4817        5,
  4818        f
  4819      );
  4820    }
  4821    f = message.getCalldata();
  4822    if (f != null) {
  4823      writer.writeMessage(
  4824        1,
  4825        f,
  4826        proto.exec.CallData.serializeBinaryToWriter
  4827      );
  4828    }
  4829    f = message.getOrigin_asU8();
  4830    if (f.length > 0) {
  4831      writer.writeBytes(
  4832        2,
  4833        f
  4834      );
  4835    }
  4836    f = message.getStackdepth();
  4837    if (f !== 0) {
  4838      writer.writeUint64(
  4839        3,
  4840        f
  4841      );
  4842    }
  4843    f = message.getReturn_asU8();
  4844    if (f.length > 0) {
  4845      writer.writeBytes(
  4846        4,
  4847        f
  4848      );
  4849    }
  4850  };
  4851  
  4852  
  4853  /**
  4854   * optional uint32 CallType = 5;
  4855   * @return {number}
  4856   */
  4857  proto.exec.CallEvent.prototype.getCalltype = function() {
  4858    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0));
  4859  };
  4860  
  4861  
  4862  /**
  4863   * @param {number} value
  4864   * @return {!proto.exec.CallEvent} returns this
  4865   */
  4866  proto.exec.CallEvent.prototype.setCalltype = function(value) {
  4867    return jspb.Message.setProto3IntField(this, 5, value);
  4868  };
  4869  
  4870  
  4871  /**
  4872   * optional CallData CallData = 1;
  4873   * @return {?proto.exec.CallData}
  4874   */
  4875  proto.exec.CallEvent.prototype.getCalldata = function() {
  4876    return /** @type{?proto.exec.CallData} */ (
  4877      jspb.Message.getWrapperField(this, proto.exec.CallData, 1));
  4878  };
  4879  
  4880  
  4881  /**
  4882   * @param {?proto.exec.CallData|undefined} value
  4883   * @return {!proto.exec.CallEvent} returns this
  4884  */
  4885  proto.exec.CallEvent.prototype.setCalldata = function(value) {
  4886    return jspb.Message.setWrapperField(this, 1, value);
  4887  };
  4888  
  4889  
  4890  /**
  4891   * Clears the message field making it undefined.
  4892   * @return {!proto.exec.CallEvent} returns this
  4893   */
  4894  proto.exec.CallEvent.prototype.clearCalldata = function() {
  4895    return this.setCalldata(undefined);
  4896  };
  4897  
  4898  
  4899  /**
  4900   * Returns whether this field is set.
  4901   * @return {boolean}
  4902   */
  4903  proto.exec.CallEvent.prototype.hasCalldata = function() {
  4904    return jspb.Message.getField(this, 1) != null;
  4905  };
  4906  
  4907  
  4908  /**
  4909   * optional bytes Origin = 2;
  4910   * @return {!(string|Uint8Array)}
  4911   */
  4912  proto.exec.CallEvent.prototype.getOrigin = function() {
  4913    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
  4914  };
  4915  
  4916  
  4917  /**
  4918   * optional bytes Origin = 2;
  4919   * This is a type-conversion wrapper around `getOrigin()`
  4920   * @return {string}
  4921   */
  4922  proto.exec.CallEvent.prototype.getOrigin_asB64 = function() {
  4923    return /** @type {string} */ (jspb.Message.bytesAsB64(
  4924        this.getOrigin()));
  4925  };
  4926  
  4927  
  4928  /**
  4929   * optional bytes Origin = 2;
  4930   * Note that Uint8Array is not supported on all browsers.
  4931   * @see http://caniuse.com/Uint8Array
  4932   * This is a type-conversion wrapper around `getOrigin()`
  4933   * @return {!Uint8Array}
  4934   */
  4935  proto.exec.CallEvent.prototype.getOrigin_asU8 = function() {
  4936    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  4937        this.getOrigin()));
  4938  };
  4939  
  4940  
  4941  /**
  4942   * @param {!(string|Uint8Array)} value
  4943   * @return {!proto.exec.CallEvent} returns this
  4944   */
  4945  proto.exec.CallEvent.prototype.setOrigin = function(value) {
  4946    return jspb.Message.setProto3BytesField(this, 2, value);
  4947  };
  4948  
  4949  
  4950  /**
  4951   * optional uint64 StackDepth = 3;
  4952   * @return {number}
  4953   */
  4954  proto.exec.CallEvent.prototype.getStackdepth = function() {
  4955    return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));
  4956  };
  4957  
  4958  
  4959  /**
  4960   * @param {number} value
  4961   * @return {!proto.exec.CallEvent} returns this
  4962   */
  4963  proto.exec.CallEvent.prototype.setStackdepth = function(value) {
  4964    return jspb.Message.setProto3IntField(this, 3, value);
  4965  };
  4966  
  4967  
  4968  /**
  4969   * optional bytes Return = 4;
  4970   * @return {!(string|Uint8Array)}
  4971   */
  4972  proto.exec.CallEvent.prototype.getReturn = function() {
  4973    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
  4974  };
  4975  
  4976  
  4977  /**
  4978   * optional bytes Return = 4;
  4979   * This is a type-conversion wrapper around `getReturn()`
  4980   * @return {string}
  4981   */
  4982  proto.exec.CallEvent.prototype.getReturn_asB64 = function() {
  4983    return /** @type {string} */ (jspb.Message.bytesAsB64(
  4984        this.getReturn()));
  4985  };
  4986  
  4987  
  4988  /**
  4989   * optional bytes Return = 4;
  4990   * Note that Uint8Array is not supported on all browsers.
  4991   * @see http://caniuse.com/Uint8Array
  4992   * This is a type-conversion wrapper around `getReturn()`
  4993   * @return {!Uint8Array}
  4994   */
  4995  proto.exec.CallEvent.prototype.getReturn_asU8 = function() {
  4996    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  4997        this.getReturn()));
  4998  };
  4999  
  5000  
  5001  /**
  5002   * @param {!(string|Uint8Array)} value
  5003   * @return {!proto.exec.CallEvent} returns this
  5004   */
  5005  proto.exec.CallEvent.prototype.setReturn = function(value) {
  5006    return jspb.Message.setProto3BytesField(this, 4, value);
  5007  };
  5008  
  5009  
  5010  
  5011  
  5012  
  5013  if (jspb.Message.GENERATE_TO_OBJECT) {
  5014  /**
  5015   * Creates an object representation of this proto.
  5016   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  5017   * Optional fields that are not set will be set to undefined.
  5018   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  5019   * For the list of reserved names please see:
  5020   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  5021   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  5022   *     JSPB instance for transitional soy proto support:
  5023   *     http://goto/soy-param-migration
  5024   * @return {!Object}
  5025   */
  5026  proto.exec.PrintEvent.prototype.toObject = function(opt_includeInstance) {
  5027    return proto.exec.PrintEvent.toObject(opt_includeInstance, this);
  5028  };
  5029  
  5030  
  5031  /**
  5032   * Static version of the {@see toObject} method.
  5033   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  5034   *     the JSPB instance for transitional soy proto support:
  5035   *     http://goto/soy-param-migration
  5036   * @param {!proto.exec.PrintEvent} msg The msg instance to transform.
  5037   * @return {!Object}
  5038   * @suppress {unusedLocalVariables} f is only used for nested messages
  5039   */
  5040  proto.exec.PrintEvent.toObject = function(includeInstance, msg) {
  5041    var f, obj = {
  5042      address: msg.getAddress_asB64(),
  5043      data: msg.getData_asB64()
  5044    };
  5045  
  5046    if (includeInstance) {
  5047      obj.$jspbMessageInstance = msg;
  5048    }
  5049    return obj;
  5050  };
  5051  }
  5052  
  5053  
  5054  /**
  5055   * Deserializes binary data (in protobuf wire format).
  5056   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  5057   * @return {!proto.exec.PrintEvent}
  5058   */
  5059  proto.exec.PrintEvent.deserializeBinary = function(bytes) {
  5060    var reader = new jspb.BinaryReader(bytes);
  5061    var msg = new proto.exec.PrintEvent;
  5062    return proto.exec.PrintEvent.deserializeBinaryFromReader(msg, reader);
  5063  };
  5064  
  5065  
  5066  /**
  5067   * Deserializes binary data (in protobuf wire format) from the
  5068   * given reader into the given message object.
  5069   * @param {!proto.exec.PrintEvent} msg The message object to deserialize into.
  5070   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  5071   * @return {!proto.exec.PrintEvent}
  5072   */
  5073  proto.exec.PrintEvent.deserializeBinaryFromReader = function(msg, reader) {
  5074    while (reader.nextField()) {
  5075      if (reader.isEndGroup()) {
  5076        break;
  5077      }
  5078      var field = reader.getFieldNumber();
  5079      switch (field) {
  5080      case 1:
  5081        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  5082        msg.setAddress(value);
  5083        break;
  5084      case 2:
  5085        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  5086        msg.setData(value);
  5087        break;
  5088      default:
  5089        reader.skipField();
  5090        break;
  5091      }
  5092    }
  5093    return msg;
  5094  };
  5095  
  5096  
  5097  /**
  5098   * Serializes the message to binary data (in protobuf wire format).
  5099   * @return {!Uint8Array}
  5100   */
  5101  proto.exec.PrintEvent.prototype.serializeBinary = function() {
  5102    var writer = new jspb.BinaryWriter();
  5103    proto.exec.PrintEvent.serializeBinaryToWriter(this, writer);
  5104    return writer.getResultBuffer();
  5105  };
  5106  
  5107  
  5108  /**
  5109   * Serializes the given message to binary data (in protobuf wire
  5110   * format), writing to the given BinaryWriter.
  5111   * @param {!proto.exec.PrintEvent} message
  5112   * @param {!jspb.BinaryWriter} writer
  5113   * @suppress {unusedLocalVariables} f is only used for nested messages
  5114   */
  5115  proto.exec.PrintEvent.serializeBinaryToWriter = function(message, writer) {
  5116    var f = undefined;
  5117    f = message.getAddress_asU8();
  5118    if (f.length > 0) {
  5119      writer.writeBytes(
  5120        1,
  5121        f
  5122      );
  5123    }
  5124    f = message.getData_asU8();
  5125    if (f.length > 0) {
  5126      writer.writeBytes(
  5127        2,
  5128        f
  5129      );
  5130    }
  5131  };
  5132  
  5133  
  5134  /**
  5135   * optional bytes Address = 1;
  5136   * @return {!(string|Uint8Array)}
  5137   */
  5138  proto.exec.PrintEvent.prototype.getAddress = function() {
  5139    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
  5140  };
  5141  
  5142  
  5143  /**
  5144   * optional bytes Address = 1;
  5145   * This is a type-conversion wrapper around `getAddress()`
  5146   * @return {string}
  5147   */
  5148  proto.exec.PrintEvent.prototype.getAddress_asB64 = function() {
  5149    return /** @type {string} */ (jspb.Message.bytesAsB64(
  5150        this.getAddress()));
  5151  };
  5152  
  5153  
  5154  /**
  5155   * optional bytes Address = 1;
  5156   * Note that Uint8Array is not supported on all browsers.
  5157   * @see http://caniuse.com/Uint8Array
  5158   * This is a type-conversion wrapper around `getAddress()`
  5159   * @return {!Uint8Array}
  5160   */
  5161  proto.exec.PrintEvent.prototype.getAddress_asU8 = function() {
  5162    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  5163        this.getAddress()));
  5164  };
  5165  
  5166  
  5167  /**
  5168   * @param {!(string|Uint8Array)} value
  5169   * @return {!proto.exec.PrintEvent} returns this
  5170   */
  5171  proto.exec.PrintEvent.prototype.setAddress = function(value) {
  5172    return jspb.Message.setProto3BytesField(this, 1, value);
  5173  };
  5174  
  5175  
  5176  /**
  5177   * optional bytes Data = 2;
  5178   * @return {!(string|Uint8Array)}
  5179   */
  5180  proto.exec.PrintEvent.prototype.getData = function() {
  5181    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
  5182  };
  5183  
  5184  
  5185  /**
  5186   * optional bytes Data = 2;
  5187   * This is a type-conversion wrapper around `getData()`
  5188   * @return {string}
  5189   */
  5190  proto.exec.PrintEvent.prototype.getData_asB64 = function() {
  5191    return /** @type {string} */ (jspb.Message.bytesAsB64(
  5192        this.getData()));
  5193  };
  5194  
  5195  
  5196  /**
  5197   * optional bytes Data = 2;
  5198   * Note that Uint8Array is not supported on all browsers.
  5199   * @see http://caniuse.com/Uint8Array
  5200   * This is a type-conversion wrapper around `getData()`
  5201   * @return {!Uint8Array}
  5202   */
  5203  proto.exec.PrintEvent.prototype.getData_asU8 = function() {
  5204    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  5205        this.getData()));
  5206  };
  5207  
  5208  
  5209  /**
  5210   * @param {!(string|Uint8Array)} value
  5211   * @return {!proto.exec.PrintEvent} returns this
  5212   */
  5213  proto.exec.PrintEvent.prototype.setData = function(value) {
  5214    return jspb.Message.setProto3BytesField(this, 2, value);
  5215  };
  5216  
  5217  
  5218  
  5219  
  5220  
  5221  if (jspb.Message.GENERATE_TO_OBJECT) {
  5222  /**
  5223   * Creates an object representation of this proto.
  5224   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  5225   * Optional fields that are not set will be set to undefined.
  5226   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  5227   * For the list of reserved names please see:
  5228   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  5229   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  5230   *     JSPB instance for transitional soy proto support:
  5231   *     http://goto/soy-param-migration
  5232   * @return {!Object}
  5233   */
  5234  proto.exec.GovernAccountEvent.prototype.toObject = function(opt_includeInstance) {
  5235    return proto.exec.GovernAccountEvent.toObject(opt_includeInstance, this);
  5236  };
  5237  
  5238  
  5239  /**
  5240   * Static version of the {@see toObject} method.
  5241   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  5242   *     the JSPB instance for transitional soy proto support:
  5243   *     http://goto/soy-param-migration
  5244   * @param {!proto.exec.GovernAccountEvent} msg The msg instance to transform.
  5245   * @return {!Object}
  5246   * @suppress {unusedLocalVariables} f is only used for nested messages
  5247   */
  5248  proto.exec.GovernAccountEvent.toObject = function(includeInstance, msg) {
  5249    var f, obj = {
  5250      accountupdate: (f = msg.getAccountupdate()) && spec_pb.TemplateAccount.toObject(includeInstance, f)
  5251    };
  5252  
  5253    if (includeInstance) {
  5254      obj.$jspbMessageInstance = msg;
  5255    }
  5256    return obj;
  5257  };
  5258  }
  5259  
  5260  
  5261  /**
  5262   * Deserializes binary data (in protobuf wire format).
  5263   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  5264   * @return {!proto.exec.GovernAccountEvent}
  5265   */
  5266  proto.exec.GovernAccountEvent.deserializeBinary = function(bytes) {
  5267    var reader = new jspb.BinaryReader(bytes);
  5268    var msg = new proto.exec.GovernAccountEvent;
  5269    return proto.exec.GovernAccountEvent.deserializeBinaryFromReader(msg, reader);
  5270  };
  5271  
  5272  
  5273  /**
  5274   * Deserializes binary data (in protobuf wire format) from the
  5275   * given reader into the given message object.
  5276   * @param {!proto.exec.GovernAccountEvent} msg The message object to deserialize into.
  5277   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  5278   * @return {!proto.exec.GovernAccountEvent}
  5279   */
  5280  proto.exec.GovernAccountEvent.deserializeBinaryFromReader = function(msg, reader) {
  5281    while (reader.nextField()) {
  5282      if (reader.isEndGroup()) {
  5283        break;
  5284      }
  5285      var field = reader.getFieldNumber();
  5286      switch (field) {
  5287      case 1:
  5288        var value = new spec_pb.TemplateAccount;
  5289        reader.readMessage(value,spec_pb.TemplateAccount.deserializeBinaryFromReader);
  5290        msg.setAccountupdate(value);
  5291        break;
  5292      default:
  5293        reader.skipField();
  5294        break;
  5295      }
  5296    }
  5297    return msg;
  5298  };
  5299  
  5300  
  5301  /**
  5302   * Serializes the message to binary data (in protobuf wire format).
  5303   * @return {!Uint8Array}
  5304   */
  5305  proto.exec.GovernAccountEvent.prototype.serializeBinary = function() {
  5306    var writer = new jspb.BinaryWriter();
  5307    proto.exec.GovernAccountEvent.serializeBinaryToWriter(this, writer);
  5308    return writer.getResultBuffer();
  5309  };
  5310  
  5311  
  5312  /**
  5313   * Serializes the given message to binary data (in protobuf wire
  5314   * format), writing to the given BinaryWriter.
  5315   * @param {!proto.exec.GovernAccountEvent} message
  5316   * @param {!jspb.BinaryWriter} writer
  5317   * @suppress {unusedLocalVariables} f is only used for nested messages
  5318   */
  5319  proto.exec.GovernAccountEvent.serializeBinaryToWriter = function(message, writer) {
  5320    var f = undefined;
  5321    f = message.getAccountupdate();
  5322    if (f != null) {
  5323      writer.writeMessage(
  5324        1,
  5325        f,
  5326        spec_pb.TemplateAccount.serializeBinaryToWriter
  5327      );
  5328    }
  5329  };
  5330  
  5331  
  5332  /**
  5333   * optional spec.TemplateAccount AccountUpdate = 1;
  5334   * @return {?proto.spec.TemplateAccount}
  5335   */
  5336  proto.exec.GovernAccountEvent.prototype.getAccountupdate = function() {
  5337    return /** @type{?proto.spec.TemplateAccount} */ (
  5338      jspb.Message.getWrapperField(this, spec_pb.TemplateAccount, 1));
  5339  };
  5340  
  5341  
  5342  /**
  5343   * @param {?proto.spec.TemplateAccount|undefined} value
  5344   * @return {!proto.exec.GovernAccountEvent} returns this
  5345  */
  5346  proto.exec.GovernAccountEvent.prototype.setAccountupdate = function(value) {
  5347    return jspb.Message.setWrapperField(this, 1, value);
  5348  };
  5349  
  5350  
  5351  /**
  5352   * Clears the message field making it undefined.
  5353   * @return {!proto.exec.GovernAccountEvent} returns this
  5354   */
  5355  proto.exec.GovernAccountEvent.prototype.clearAccountupdate = function() {
  5356    return this.setAccountupdate(undefined);
  5357  };
  5358  
  5359  
  5360  /**
  5361   * Returns whether this field is set.
  5362   * @return {boolean}
  5363   */
  5364  proto.exec.GovernAccountEvent.prototype.hasAccountupdate = function() {
  5365    return jspb.Message.getField(this, 1) != null;
  5366  };
  5367  
  5368  
  5369  
  5370  
  5371  
  5372  if (jspb.Message.GENERATE_TO_OBJECT) {
  5373  /**
  5374   * Creates an object representation of this proto.
  5375   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  5376   * Optional fields that are not set will be set to undefined.
  5377   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  5378   * For the list of reserved names please see:
  5379   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  5380   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  5381   *     JSPB instance for transitional soy proto support:
  5382   *     http://goto/soy-param-migration
  5383   * @return {!Object}
  5384   */
  5385  proto.exec.InputEvent.prototype.toObject = function(opt_includeInstance) {
  5386    return proto.exec.InputEvent.toObject(opt_includeInstance, this);
  5387  };
  5388  
  5389  
  5390  /**
  5391   * Static version of the {@see toObject} method.
  5392   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  5393   *     the JSPB instance for transitional soy proto support:
  5394   *     http://goto/soy-param-migration
  5395   * @param {!proto.exec.InputEvent} msg The msg instance to transform.
  5396   * @return {!Object}
  5397   * @suppress {unusedLocalVariables} f is only used for nested messages
  5398   */
  5399  proto.exec.InputEvent.toObject = function(includeInstance, msg) {
  5400    var f, obj = {
  5401      address: msg.getAddress_asB64()
  5402    };
  5403  
  5404    if (includeInstance) {
  5405      obj.$jspbMessageInstance = msg;
  5406    }
  5407    return obj;
  5408  };
  5409  }
  5410  
  5411  
  5412  /**
  5413   * Deserializes binary data (in protobuf wire format).
  5414   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  5415   * @return {!proto.exec.InputEvent}
  5416   */
  5417  proto.exec.InputEvent.deserializeBinary = function(bytes) {
  5418    var reader = new jspb.BinaryReader(bytes);
  5419    var msg = new proto.exec.InputEvent;
  5420    return proto.exec.InputEvent.deserializeBinaryFromReader(msg, reader);
  5421  };
  5422  
  5423  
  5424  /**
  5425   * Deserializes binary data (in protobuf wire format) from the
  5426   * given reader into the given message object.
  5427   * @param {!proto.exec.InputEvent} msg The message object to deserialize into.
  5428   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  5429   * @return {!proto.exec.InputEvent}
  5430   */
  5431  proto.exec.InputEvent.deserializeBinaryFromReader = function(msg, reader) {
  5432    while (reader.nextField()) {
  5433      if (reader.isEndGroup()) {
  5434        break;
  5435      }
  5436      var field = reader.getFieldNumber();
  5437      switch (field) {
  5438      case 1:
  5439        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  5440        msg.setAddress(value);
  5441        break;
  5442      default:
  5443        reader.skipField();
  5444        break;
  5445      }
  5446    }
  5447    return msg;
  5448  };
  5449  
  5450  
  5451  /**
  5452   * Serializes the message to binary data (in protobuf wire format).
  5453   * @return {!Uint8Array}
  5454   */
  5455  proto.exec.InputEvent.prototype.serializeBinary = function() {
  5456    var writer = new jspb.BinaryWriter();
  5457    proto.exec.InputEvent.serializeBinaryToWriter(this, writer);
  5458    return writer.getResultBuffer();
  5459  };
  5460  
  5461  
  5462  /**
  5463   * Serializes the given message to binary data (in protobuf wire
  5464   * format), writing to the given BinaryWriter.
  5465   * @param {!proto.exec.InputEvent} message
  5466   * @param {!jspb.BinaryWriter} writer
  5467   * @suppress {unusedLocalVariables} f is only used for nested messages
  5468   */
  5469  proto.exec.InputEvent.serializeBinaryToWriter = function(message, writer) {
  5470    var f = undefined;
  5471    f = message.getAddress_asU8();
  5472    if (f.length > 0) {
  5473      writer.writeBytes(
  5474        1,
  5475        f
  5476      );
  5477    }
  5478  };
  5479  
  5480  
  5481  /**
  5482   * optional bytes Address = 1;
  5483   * @return {!(string|Uint8Array)}
  5484   */
  5485  proto.exec.InputEvent.prototype.getAddress = function() {
  5486    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
  5487  };
  5488  
  5489  
  5490  /**
  5491   * optional bytes Address = 1;
  5492   * This is a type-conversion wrapper around `getAddress()`
  5493   * @return {string}
  5494   */
  5495  proto.exec.InputEvent.prototype.getAddress_asB64 = function() {
  5496    return /** @type {string} */ (jspb.Message.bytesAsB64(
  5497        this.getAddress()));
  5498  };
  5499  
  5500  
  5501  /**
  5502   * optional bytes Address = 1;
  5503   * Note that Uint8Array is not supported on all browsers.
  5504   * @see http://caniuse.com/Uint8Array
  5505   * This is a type-conversion wrapper around `getAddress()`
  5506   * @return {!Uint8Array}
  5507   */
  5508  proto.exec.InputEvent.prototype.getAddress_asU8 = function() {
  5509    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  5510        this.getAddress()));
  5511  };
  5512  
  5513  
  5514  /**
  5515   * @param {!(string|Uint8Array)} value
  5516   * @return {!proto.exec.InputEvent} returns this
  5517   */
  5518  proto.exec.InputEvent.prototype.setAddress = function(value) {
  5519    return jspb.Message.setProto3BytesField(this, 1, value);
  5520  };
  5521  
  5522  
  5523  
  5524  
  5525  
  5526  if (jspb.Message.GENERATE_TO_OBJECT) {
  5527  /**
  5528   * Creates an object representation of this proto.
  5529   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  5530   * Optional fields that are not set will be set to undefined.
  5531   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  5532   * For the list of reserved names please see:
  5533   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  5534   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  5535   *     JSPB instance for transitional soy proto support:
  5536   *     http://goto/soy-param-migration
  5537   * @return {!Object}
  5538   */
  5539  proto.exec.OutputEvent.prototype.toObject = function(opt_includeInstance) {
  5540    return proto.exec.OutputEvent.toObject(opt_includeInstance, this);
  5541  };
  5542  
  5543  
  5544  /**
  5545   * Static version of the {@see toObject} method.
  5546   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  5547   *     the JSPB instance for transitional soy proto support:
  5548   *     http://goto/soy-param-migration
  5549   * @param {!proto.exec.OutputEvent} msg The msg instance to transform.
  5550   * @return {!Object}
  5551   * @suppress {unusedLocalVariables} f is only used for nested messages
  5552   */
  5553  proto.exec.OutputEvent.toObject = function(includeInstance, msg) {
  5554    var f, obj = {
  5555      address: msg.getAddress_asB64()
  5556    };
  5557  
  5558    if (includeInstance) {
  5559      obj.$jspbMessageInstance = msg;
  5560    }
  5561    return obj;
  5562  };
  5563  }
  5564  
  5565  
  5566  /**
  5567   * Deserializes binary data (in protobuf wire format).
  5568   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  5569   * @return {!proto.exec.OutputEvent}
  5570   */
  5571  proto.exec.OutputEvent.deserializeBinary = function(bytes) {
  5572    var reader = new jspb.BinaryReader(bytes);
  5573    var msg = new proto.exec.OutputEvent;
  5574    return proto.exec.OutputEvent.deserializeBinaryFromReader(msg, reader);
  5575  };
  5576  
  5577  
  5578  /**
  5579   * Deserializes binary data (in protobuf wire format) from the
  5580   * given reader into the given message object.
  5581   * @param {!proto.exec.OutputEvent} msg The message object to deserialize into.
  5582   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  5583   * @return {!proto.exec.OutputEvent}
  5584   */
  5585  proto.exec.OutputEvent.deserializeBinaryFromReader = function(msg, reader) {
  5586    while (reader.nextField()) {
  5587      if (reader.isEndGroup()) {
  5588        break;
  5589      }
  5590      var field = reader.getFieldNumber();
  5591      switch (field) {
  5592      case 1:
  5593        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  5594        msg.setAddress(value);
  5595        break;
  5596      default:
  5597        reader.skipField();
  5598        break;
  5599      }
  5600    }
  5601    return msg;
  5602  };
  5603  
  5604  
  5605  /**
  5606   * Serializes the message to binary data (in protobuf wire format).
  5607   * @return {!Uint8Array}
  5608   */
  5609  proto.exec.OutputEvent.prototype.serializeBinary = function() {
  5610    var writer = new jspb.BinaryWriter();
  5611    proto.exec.OutputEvent.serializeBinaryToWriter(this, writer);
  5612    return writer.getResultBuffer();
  5613  };
  5614  
  5615  
  5616  /**
  5617   * Serializes the given message to binary data (in protobuf wire
  5618   * format), writing to the given BinaryWriter.
  5619   * @param {!proto.exec.OutputEvent} message
  5620   * @param {!jspb.BinaryWriter} writer
  5621   * @suppress {unusedLocalVariables} f is only used for nested messages
  5622   */
  5623  proto.exec.OutputEvent.serializeBinaryToWriter = function(message, writer) {
  5624    var f = undefined;
  5625    f = message.getAddress_asU8();
  5626    if (f.length > 0) {
  5627      writer.writeBytes(
  5628        1,
  5629        f
  5630      );
  5631    }
  5632  };
  5633  
  5634  
  5635  /**
  5636   * optional bytes Address = 1;
  5637   * @return {!(string|Uint8Array)}
  5638   */
  5639  proto.exec.OutputEvent.prototype.getAddress = function() {
  5640    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
  5641  };
  5642  
  5643  
  5644  /**
  5645   * optional bytes Address = 1;
  5646   * This is a type-conversion wrapper around `getAddress()`
  5647   * @return {string}
  5648   */
  5649  proto.exec.OutputEvent.prototype.getAddress_asB64 = function() {
  5650    return /** @type {string} */ (jspb.Message.bytesAsB64(
  5651        this.getAddress()));
  5652  };
  5653  
  5654  
  5655  /**
  5656   * optional bytes Address = 1;
  5657   * Note that Uint8Array is not supported on all browsers.
  5658   * @see http://caniuse.com/Uint8Array
  5659   * This is a type-conversion wrapper around `getAddress()`
  5660   * @return {!Uint8Array}
  5661   */
  5662  proto.exec.OutputEvent.prototype.getAddress_asU8 = function() {
  5663    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  5664        this.getAddress()));
  5665  };
  5666  
  5667  
  5668  /**
  5669   * @param {!(string|Uint8Array)} value
  5670   * @return {!proto.exec.OutputEvent} returns this
  5671   */
  5672  proto.exec.OutputEvent.prototype.setAddress = function(value) {
  5673    return jspb.Message.setProto3BytesField(this, 1, value);
  5674  };
  5675  
  5676  
  5677  
  5678  
  5679  
  5680  if (jspb.Message.GENERATE_TO_OBJECT) {
  5681  /**
  5682   * Creates an object representation of this proto.
  5683   * Field names that are reserved in JavaScript and will be renamed to pb_name.
  5684   * Optional fields that are not set will be set to undefined.
  5685   * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
  5686   * For the list of reserved names please see:
  5687   *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
  5688   * @param {boolean=} opt_includeInstance Deprecated. whether to include the
  5689   *     JSPB instance for transitional soy proto support:
  5690   *     http://goto/soy-param-migration
  5691   * @return {!Object}
  5692   */
  5693  proto.exec.CallData.prototype.toObject = function(opt_includeInstance) {
  5694    return proto.exec.CallData.toObject(opt_includeInstance, this);
  5695  };
  5696  
  5697  
  5698  /**
  5699   * Static version of the {@see toObject} method.
  5700   * @param {boolean|undefined} includeInstance Deprecated. Whether to include
  5701   *     the JSPB instance for transitional soy proto support:
  5702   *     http://goto/soy-param-migration
  5703   * @param {!proto.exec.CallData} msg The msg instance to transform.
  5704   * @return {!Object}
  5705   * @suppress {unusedLocalVariables} f is only used for nested messages
  5706   */
  5707  proto.exec.CallData.toObject = function(includeInstance, msg) {
  5708    var f, obj = {
  5709      caller: msg.getCaller_asB64(),
  5710      callee: msg.getCallee_asB64(),
  5711      data: msg.getData_asB64(),
  5712      value: msg.getValue_asB64(),
  5713      gas: msg.getGas_asB64()
  5714    };
  5715  
  5716    if (includeInstance) {
  5717      obj.$jspbMessageInstance = msg;
  5718    }
  5719    return obj;
  5720  };
  5721  }
  5722  
  5723  
  5724  /**
  5725   * Deserializes binary data (in protobuf wire format).
  5726   * @param {jspb.ByteSource} bytes The bytes to deserialize.
  5727   * @return {!proto.exec.CallData}
  5728   */
  5729  proto.exec.CallData.deserializeBinary = function(bytes) {
  5730    var reader = new jspb.BinaryReader(bytes);
  5731    var msg = new proto.exec.CallData;
  5732    return proto.exec.CallData.deserializeBinaryFromReader(msg, reader);
  5733  };
  5734  
  5735  
  5736  /**
  5737   * Deserializes binary data (in protobuf wire format) from the
  5738   * given reader into the given message object.
  5739   * @param {!proto.exec.CallData} msg The message object to deserialize into.
  5740   * @param {!jspb.BinaryReader} reader The BinaryReader to use.
  5741   * @return {!proto.exec.CallData}
  5742   */
  5743  proto.exec.CallData.deserializeBinaryFromReader = function(msg, reader) {
  5744    while (reader.nextField()) {
  5745      if (reader.isEndGroup()) {
  5746        break;
  5747      }
  5748      var field = reader.getFieldNumber();
  5749      switch (field) {
  5750      case 1:
  5751        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  5752        msg.setCaller(value);
  5753        break;
  5754      case 2:
  5755        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  5756        msg.setCallee(value);
  5757        break;
  5758      case 3:
  5759        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  5760        msg.setData(value);
  5761        break;
  5762      case 4:
  5763        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  5764        msg.setValue(value);
  5765        break;
  5766      case 5:
  5767        var value = /** @type {!Uint8Array} */ (reader.readBytes());
  5768        msg.setGas(value);
  5769        break;
  5770      default:
  5771        reader.skipField();
  5772        break;
  5773      }
  5774    }
  5775    return msg;
  5776  };
  5777  
  5778  
  5779  /**
  5780   * Serializes the message to binary data (in protobuf wire format).
  5781   * @return {!Uint8Array}
  5782   */
  5783  proto.exec.CallData.prototype.serializeBinary = function() {
  5784    var writer = new jspb.BinaryWriter();
  5785    proto.exec.CallData.serializeBinaryToWriter(this, writer);
  5786    return writer.getResultBuffer();
  5787  };
  5788  
  5789  
  5790  /**
  5791   * Serializes the given message to binary data (in protobuf wire
  5792   * format), writing to the given BinaryWriter.
  5793   * @param {!proto.exec.CallData} message
  5794   * @param {!jspb.BinaryWriter} writer
  5795   * @suppress {unusedLocalVariables} f is only used for nested messages
  5796   */
  5797  proto.exec.CallData.serializeBinaryToWriter = function(message, writer) {
  5798    var f = undefined;
  5799    f = message.getCaller_asU8();
  5800    if (f.length > 0) {
  5801      writer.writeBytes(
  5802        1,
  5803        f
  5804      );
  5805    }
  5806    f = message.getCallee_asU8();
  5807    if (f.length > 0) {
  5808      writer.writeBytes(
  5809        2,
  5810        f
  5811      );
  5812    }
  5813    f = message.getData_asU8();
  5814    if (f.length > 0) {
  5815      writer.writeBytes(
  5816        3,
  5817        f
  5818      );
  5819    }
  5820    f = message.getValue_asU8();
  5821    if (f.length > 0) {
  5822      writer.writeBytes(
  5823        4,
  5824        f
  5825      );
  5826    }
  5827    f = message.getGas_asU8();
  5828    if (f.length > 0) {
  5829      writer.writeBytes(
  5830        5,
  5831        f
  5832      );
  5833    }
  5834  };
  5835  
  5836  
  5837  /**
  5838   * optional bytes Caller = 1;
  5839   * @return {!(string|Uint8Array)}
  5840   */
  5841  proto.exec.CallData.prototype.getCaller = function() {
  5842    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
  5843  };
  5844  
  5845  
  5846  /**
  5847   * optional bytes Caller = 1;
  5848   * This is a type-conversion wrapper around `getCaller()`
  5849   * @return {string}
  5850   */
  5851  proto.exec.CallData.prototype.getCaller_asB64 = function() {
  5852    return /** @type {string} */ (jspb.Message.bytesAsB64(
  5853        this.getCaller()));
  5854  };
  5855  
  5856  
  5857  /**
  5858   * optional bytes Caller = 1;
  5859   * Note that Uint8Array is not supported on all browsers.
  5860   * @see http://caniuse.com/Uint8Array
  5861   * This is a type-conversion wrapper around `getCaller()`
  5862   * @return {!Uint8Array}
  5863   */
  5864  proto.exec.CallData.prototype.getCaller_asU8 = function() {
  5865    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  5866        this.getCaller()));
  5867  };
  5868  
  5869  
  5870  /**
  5871   * @param {!(string|Uint8Array)} value
  5872   * @return {!proto.exec.CallData} returns this
  5873   */
  5874  proto.exec.CallData.prototype.setCaller = function(value) {
  5875    return jspb.Message.setProto3BytesField(this, 1, value);
  5876  };
  5877  
  5878  
  5879  /**
  5880   * optional bytes Callee = 2;
  5881   * @return {!(string|Uint8Array)}
  5882   */
  5883  proto.exec.CallData.prototype.getCallee = function() {
  5884    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
  5885  };
  5886  
  5887  
  5888  /**
  5889   * optional bytes Callee = 2;
  5890   * This is a type-conversion wrapper around `getCallee()`
  5891   * @return {string}
  5892   */
  5893  proto.exec.CallData.prototype.getCallee_asB64 = function() {
  5894    return /** @type {string} */ (jspb.Message.bytesAsB64(
  5895        this.getCallee()));
  5896  };
  5897  
  5898  
  5899  /**
  5900   * optional bytes Callee = 2;
  5901   * Note that Uint8Array is not supported on all browsers.
  5902   * @see http://caniuse.com/Uint8Array
  5903   * This is a type-conversion wrapper around `getCallee()`
  5904   * @return {!Uint8Array}
  5905   */
  5906  proto.exec.CallData.prototype.getCallee_asU8 = function() {
  5907    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  5908        this.getCallee()));
  5909  };
  5910  
  5911  
  5912  /**
  5913   * @param {!(string|Uint8Array)} value
  5914   * @return {!proto.exec.CallData} returns this
  5915   */
  5916  proto.exec.CallData.prototype.setCallee = function(value) {
  5917    return jspb.Message.setProto3BytesField(this, 2, value);
  5918  };
  5919  
  5920  
  5921  /**
  5922   * optional bytes Data = 3;
  5923   * @return {!(string|Uint8Array)}
  5924   */
  5925  proto.exec.CallData.prototype.getData = function() {
  5926    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
  5927  };
  5928  
  5929  
  5930  /**
  5931   * optional bytes Data = 3;
  5932   * This is a type-conversion wrapper around `getData()`
  5933   * @return {string}
  5934   */
  5935  proto.exec.CallData.prototype.getData_asB64 = function() {
  5936    return /** @type {string} */ (jspb.Message.bytesAsB64(
  5937        this.getData()));
  5938  };
  5939  
  5940  
  5941  /**
  5942   * optional bytes Data = 3;
  5943   * Note that Uint8Array is not supported on all browsers.
  5944   * @see http://caniuse.com/Uint8Array
  5945   * This is a type-conversion wrapper around `getData()`
  5946   * @return {!Uint8Array}
  5947   */
  5948  proto.exec.CallData.prototype.getData_asU8 = function() {
  5949    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  5950        this.getData()));
  5951  };
  5952  
  5953  
  5954  /**
  5955   * @param {!(string|Uint8Array)} value
  5956   * @return {!proto.exec.CallData} returns this
  5957   */
  5958  proto.exec.CallData.prototype.setData = function(value) {
  5959    return jspb.Message.setProto3BytesField(this, 3, value);
  5960  };
  5961  
  5962  
  5963  /**
  5964   * optional bytes Value = 4;
  5965   * @return {!(string|Uint8Array)}
  5966   */
  5967  proto.exec.CallData.prototype.getValue = function() {
  5968    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
  5969  };
  5970  
  5971  
  5972  /**
  5973   * optional bytes Value = 4;
  5974   * This is a type-conversion wrapper around `getValue()`
  5975   * @return {string}
  5976   */
  5977  proto.exec.CallData.prototype.getValue_asB64 = function() {
  5978    return /** @type {string} */ (jspb.Message.bytesAsB64(
  5979        this.getValue()));
  5980  };
  5981  
  5982  
  5983  /**
  5984   * optional bytes Value = 4;
  5985   * Note that Uint8Array is not supported on all browsers.
  5986   * @see http://caniuse.com/Uint8Array
  5987   * This is a type-conversion wrapper around `getValue()`
  5988   * @return {!Uint8Array}
  5989   */
  5990  proto.exec.CallData.prototype.getValue_asU8 = function() {
  5991    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  5992        this.getValue()));
  5993  };
  5994  
  5995  
  5996  /**
  5997   * @param {!(string|Uint8Array)} value
  5998   * @return {!proto.exec.CallData} returns this
  5999   */
  6000  proto.exec.CallData.prototype.setValue = function(value) {
  6001    return jspb.Message.setProto3BytesField(this, 4, value);
  6002  };
  6003  
  6004  
  6005  /**
  6006   * optional bytes Gas = 5;
  6007   * @return {!(string|Uint8Array)}
  6008   */
  6009  proto.exec.CallData.prototype.getGas = function() {
  6010    return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, ""));
  6011  };
  6012  
  6013  
  6014  /**
  6015   * optional bytes Gas = 5;
  6016   * This is a type-conversion wrapper around `getGas()`
  6017   * @return {string}
  6018   */
  6019  proto.exec.CallData.prototype.getGas_asB64 = function() {
  6020    return /** @type {string} */ (jspb.Message.bytesAsB64(
  6021        this.getGas()));
  6022  };
  6023  
  6024  
  6025  /**
  6026   * optional bytes Gas = 5;
  6027   * Note that Uint8Array is not supported on all browsers.
  6028   * @see http://caniuse.com/Uint8Array
  6029   * This is a type-conversion wrapper around `getGas()`
  6030   * @return {!Uint8Array}
  6031   */
  6032  proto.exec.CallData.prototype.getGas_asU8 = function() {
  6033    return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
  6034        this.getGas()));
  6035  };
  6036  
  6037  
  6038  /**
  6039   * @param {!(string|Uint8Array)} value
  6040   * @return {!proto.exec.CallData} returns this
  6041   */
  6042  proto.exec.CallData.prototype.setGas = function(value) {
  6043    return jspb.Message.setProto3BytesField(this, 5, value);
  6044  };
  6045  
  6046  
  6047  goog.object.extend(exports, proto.exec);