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);