dash-platform-sdk 1.5.0-dev.7 → 1.5.0-dev.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -9070,6 +9070,1309 @@ class GetAddressesInfosResponse_GetAddressesInfosResponseV0$Type extends Message
9070
9070
  */
9071
9071
  export const GetAddressesInfosResponse_GetAddressesInfosResponseV0 = new GetAddressesInfosResponse_GetAddressesInfosResponseV0$Type();
9072
9072
  // @generated message type with reflection information, may provide speed optimized methods
9073
+ class AddressBalanceChange$Type extends MessageType {
9074
+ constructor() {
9075
+ super("org.dash.platform.dapi.v0.AddressBalanceChange", [
9076
+ { no: 1, name: "address", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
9077
+ { no: 2, name: "set_balance", kind: "scalar", oneof: "operation", T: 4 /*ScalarType.UINT64*/ },
9078
+ { no: 3, name: "add_to_balance", kind: "scalar", oneof: "operation", T: 4 /*ScalarType.UINT64*/ }
9079
+ ]);
9080
+ }
9081
+ create(value) {
9082
+ const message = globalThis.Object.create((this.messagePrototype));
9083
+ message.address = new Uint8Array(0);
9084
+ message.operation = { oneofKind: undefined };
9085
+ if (value !== undefined)
9086
+ reflectionMergePartial(this, message, value);
9087
+ return message;
9088
+ }
9089
+ internalBinaryRead(reader, length, options, target) {
9090
+ let message = target ?? this.create(), end = reader.pos + length;
9091
+ while (reader.pos < end) {
9092
+ let [fieldNo, wireType] = reader.tag();
9093
+ switch (fieldNo) {
9094
+ case /* bytes address */ 1:
9095
+ message.address = reader.bytes();
9096
+ break;
9097
+ case /* uint64 set_balance = 2 [jstype = JS_STRING] */ 2:
9098
+ message.operation = {
9099
+ oneofKind: "setBalance",
9100
+ setBalance: reader.uint64().toString()
9101
+ };
9102
+ break;
9103
+ case /* uint64 add_to_balance = 3 [jstype = JS_STRING] */ 3:
9104
+ message.operation = {
9105
+ oneofKind: "addToBalance",
9106
+ addToBalance: reader.uint64().toString()
9107
+ };
9108
+ break;
9109
+ default:
9110
+ let u = options.readUnknownField;
9111
+ if (u === "throw")
9112
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9113
+ let d = reader.skip(wireType);
9114
+ if (u !== false)
9115
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9116
+ }
9117
+ }
9118
+ return message;
9119
+ }
9120
+ internalBinaryWrite(message, writer, options) {
9121
+ /* bytes address = 1; */
9122
+ if (message.address.length)
9123
+ writer.tag(1, WireType.LengthDelimited).bytes(message.address);
9124
+ /* uint64 set_balance = 2 [jstype = JS_STRING]; */
9125
+ if (message.operation.oneofKind === "setBalance")
9126
+ writer.tag(2, WireType.Varint).uint64(message.operation.setBalance);
9127
+ /* uint64 add_to_balance = 3 [jstype = JS_STRING]; */
9128
+ if (message.operation.oneofKind === "addToBalance")
9129
+ writer.tag(3, WireType.Varint).uint64(message.operation.addToBalance);
9130
+ let u = options.writeUnknownFields;
9131
+ if (u !== false)
9132
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9133
+ return writer;
9134
+ }
9135
+ }
9136
+ /**
9137
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.AddressBalanceChange
9138
+ */
9139
+ export const AddressBalanceChange = new AddressBalanceChange$Type();
9140
+ // @generated message type with reflection information, may provide speed optimized methods
9141
+ class BlockAddressBalanceChanges$Type extends MessageType {
9142
+ constructor() {
9143
+ super("org.dash.platform.dapi.v0.BlockAddressBalanceChanges", [
9144
+ { no: 1, name: "block_height", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
9145
+ { no: 2, name: "changes", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => AddressBalanceChange }
9146
+ ]);
9147
+ }
9148
+ create(value) {
9149
+ const message = globalThis.Object.create((this.messagePrototype));
9150
+ message.blockHeight = "0";
9151
+ message.changes = [];
9152
+ if (value !== undefined)
9153
+ reflectionMergePartial(this, message, value);
9154
+ return message;
9155
+ }
9156
+ internalBinaryRead(reader, length, options, target) {
9157
+ let message = target ?? this.create(), end = reader.pos + length;
9158
+ while (reader.pos < end) {
9159
+ let [fieldNo, wireType] = reader.tag();
9160
+ switch (fieldNo) {
9161
+ case /* uint64 block_height = 1 [jstype = JS_STRING] */ 1:
9162
+ message.blockHeight = reader.uint64().toString();
9163
+ break;
9164
+ case /* repeated org.dash.platform.dapi.v0.AddressBalanceChange changes */ 2:
9165
+ message.changes.push(AddressBalanceChange.internalBinaryRead(reader, reader.uint32(), options));
9166
+ break;
9167
+ default:
9168
+ let u = options.readUnknownField;
9169
+ if (u === "throw")
9170
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9171
+ let d = reader.skip(wireType);
9172
+ if (u !== false)
9173
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9174
+ }
9175
+ }
9176
+ return message;
9177
+ }
9178
+ internalBinaryWrite(message, writer, options) {
9179
+ /* uint64 block_height = 1 [jstype = JS_STRING]; */
9180
+ if (message.blockHeight !== "0")
9181
+ writer.tag(1, WireType.Varint).uint64(message.blockHeight);
9182
+ /* repeated org.dash.platform.dapi.v0.AddressBalanceChange changes = 2; */
9183
+ for (let i = 0; i < message.changes.length; i++)
9184
+ AddressBalanceChange.internalBinaryWrite(message.changes[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
9185
+ let u = options.writeUnknownFields;
9186
+ if (u !== false)
9187
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9188
+ return writer;
9189
+ }
9190
+ }
9191
+ /**
9192
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.BlockAddressBalanceChanges
9193
+ */
9194
+ export const BlockAddressBalanceChanges = new BlockAddressBalanceChanges$Type();
9195
+ // @generated message type with reflection information, may provide speed optimized methods
9196
+ class AddressBalanceUpdateEntries$Type extends MessageType {
9197
+ constructor() {
9198
+ super("org.dash.platform.dapi.v0.AddressBalanceUpdateEntries", [
9199
+ { no: 1, name: "block_changes", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => BlockAddressBalanceChanges }
9200
+ ]);
9201
+ }
9202
+ create(value) {
9203
+ const message = globalThis.Object.create((this.messagePrototype));
9204
+ message.blockChanges = [];
9205
+ if (value !== undefined)
9206
+ reflectionMergePartial(this, message, value);
9207
+ return message;
9208
+ }
9209
+ internalBinaryRead(reader, length, options, target) {
9210
+ let message = target ?? this.create(), end = reader.pos + length;
9211
+ while (reader.pos < end) {
9212
+ let [fieldNo, wireType] = reader.tag();
9213
+ switch (fieldNo) {
9214
+ case /* repeated org.dash.platform.dapi.v0.BlockAddressBalanceChanges block_changes */ 1:
9215
+ message.blockChanges.push(BlockAddressBalanceChanges.internalBinaryRead(reader, reader.uint32(), options));
9216
+ break;
9217
+ default:
9218
+ let u = options.readUnknownField;
9219
+ if (u === "throw")
9220
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9221
+ let d = reader.skip(wireType);
9222
+ if (u !== false)
9223
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9224
+ }
9225
+ }
9226
+ return message;
9227
+ }
9228
+ internalBinaryWrite(message, writer, options) {
9229
+ /* repeated org.dash.platform.dapi.v0.BlockAddressBalanceChanges block_changes = 1; */
9230
+ for (let i = 0; i < message.blockChanges.length; i++)
9231
+ BlockAddressBalanceChanges.internalBinaryWrite(message.blockChanges[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
9232
+ let u = options.writeUnknownFields;
9233
+ if (u !== false)
9234
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9235
+ return writer;
9236
+ }
9237
+ }
9238
+ /**
9239
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.AddressBalanceUpdateEntries
9240
+ */
9241
+ export const AddressBalanceUpdateEntries = new AddressBalanceUpdateEntries$Type();
9242
+ // @generated message type with reflection information, may provide speed optimized methods
9243
+ class GetAddressesTrunkStateRequest$Type extends MessageType {
9244
+ constructor() {
9245
+ super("org.dash.platform.dapi.v0.GetAddressesTrunkStateRequest", [
9246
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetAddressesTrunkStateRequest_GetAddressesTrunkStateRequestV0 }
9247
+ ]);
9248
+ }
9249
+ create(value) {
9250
+ const message = globalThis.Object.create((this.messagePrototype));
9251
+ message.version = { oneofKind: undefined };
9252
+ if (value !== undefined)
9253
+ reflectionMergePartial(this, message, value);
9254
+ return message;
9255
+ }
9256
+ internalBinaryRead(reader, length, options, target) {
9257
+ let message = target ?? this.create(), end = reader.pos + length;
9258
+ while (reader.pos < end) {
9259
+ let [fieldNo, wireType] = reader.tag();
9260
+ switch (fieldNo) {
9261
+ case /* org.dash.platform.dapi.v0.GetAddressesTrunkStateRequest.GetAddressesTrunkStateRequestV0 v0 */ 1:
9262
+ message.version = {
9263
+ oneofKind: "v0",
9264
+ v0: GetAddressesTrunkStateRequest_GetAddressesTrunkStateRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
9265
+ };
9266
+ break;
9267
+ default:
9268
+ let u = options.readUnknownField;
9269
+ if (u === "throw")
9270
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9271
+ let d = reader.skip(wireType);
9272
+ if (u !== false)
9273
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9274
+ }
9275
+ }
9276
+ return message;
9277
+ }
9278
+ internalBinaryWrite(message, writer, options) {
9279
+ /* org.dash.platform.dapi.v0.GetAddressesTrunkStateRequest.GetAddressesTrunkStateRequestV0 v0 = 1; */
9280
+ if (message.version.oneofKind === "v0")
9281
+ GetAddressesTrunkStateRequest_GetAddressesTrunkStateRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
9282
+ let u = options.writeUnknownFields;
9283
+ if (u !== false)
9284
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9285
+ return writer;
9286
+ }
9287
+ }
9288
+ /**
9289
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesTrunkStateRequest
9290
+ */
9291
+ export const GetAddressesTrunkStateRequest = new GetAddressesTrunkStateRequest$Type();
9292
+ // @generated message type with reflection information, may provide speed optimized methods
9293
+ class GetAddressesTrunkStateRequest_GetAddressesTrunkStateRequestV0$Type extends MessageType {
9294
+ constructor() {
9295
+ super("org.dash.platform.dapi.v0.GetAddressesTrunkStateRequest.GetAddressesTrunkStateRequestV0", []);
9296
+ }
9297
+ create(value) {
9298
+ const message = globalThis.Object.create((this.messagePrototype));
9299
+ if (value !== undefined)
9300
+ reflectionMergePartial(this, message, value);
9301
+ return message;
9302
+ }
9303
+ internalBinaryRead(reader, length, options, target) {
9304
+ let message = target ?? this.create(), end = reader.pos + length;
9305
+ while (reader.pos < end) {
9306
+ let [fieldNo, wireType] = reader.tag();
9307
+ switch (fieldNo) {
9308
+ default:
9309
+ let u = options.readUnknownField;
9310
+ if (u === "throw")
9311
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9312
+ let d = reader.skip(wireType);
9313
+ if (u !== false)
9314
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9315
+ }
9316
+ }
9317
+ return message;
9318
+ }
9319
+ internalBinaryWrite(message, writer, options) {
9320
+ let u = options.writeUnknownFields;
9321
+ if (u !== false)
9322
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9323
+ return writer;
9324
+ }
9325
+ }
9326
+ /**
9327
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesTrunkStateRequest.GetAddressesTrunkStateRequestV0
9328
+ */
9329
+ export const GetAddressesTrunkStateRequest_GetAddressesTrunkStateRequestV0 = new GetAddressesTrunkStateRequest_GetAddressesTrunkStateRequestV0$Type();
9330
+ // @generated message type with reflection information, may provide speed optimized methods
9331
+ class GetAddressesTrunkStateResponse$Type extends MessageType {
9332
+ constructor() {
9333
+ super("org.dash.platform.dapi.v0.GetAddressesTrunkStateResponse", [
9334
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetAddressesTrunkStateResponse_GetAddressesTrunkStateResponseV0 }
9335
+ ]);
9336
+ }
9337
+ create(value) {
9338
+ const message = globalThis.Object.create((this.messagePrototype));
9339
+ message.version = { oneofKind: undefined };
9340
+ if (value !== undefined)
9341
+ reflectionMergePartial(this, message, value);
9342
+ return message;
9343
+ }
9344
+ internalBinaryRead(reader, length, options, target) {
9345
+ let message = target ?? this.create(), end = reader.pos + length;
9346
+ while (reader.pos < end) {
9347
+ let [fieldNo, wireType] = reader.tag();
9348
+ switch (fieldNo) {
9349
+ case /* org.dash.platform.dapi.v0.GetAddressesTrunkStateResponse.GetAddressesTrunkStateResponseV0 v0 */ 1:
9350
+ message.version = {
9351
+ oneofKind: "v0",
9352
+ v0: GetAddressesTrunkStateResponse_GetAddressesTrunkStateResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
9353
+ };
9354
+ break;
9355
+ default:
9356
+ let u = options.readUnknownField;
9357
+ if (u === "throw")
9358
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9359
+ let d = reader.skip(wireType);
9360
+ if (u !== false)
9361
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9362
+ }
9363
+ }
9364
+ return message;
9365
+ }
9366
+ internalBinaryWrite(message, writer, options) {
9367
+ /* org.dash.platform.dapi.v0.GetAddressesTrunkStateResponse.GetAddressesTrunkStateResponseV0 v0 = 1; */
9368
+ if (message.version.oneofKind === "v0")
9369
+ GetAddressesTrunkStateResponse_GetAddressesTrunkStateResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
9370
+ let u = options.writeUnknownFields;
9371
+ if (u !== false)
9372
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9373
+ return writer;
9374
+ }
9375
+ }
9376
+ /**
9377
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesTrunkStateResponse
9378
+ */
9379
+ export const GetAddressesTrunkStateResponse = new GetAddressesTrunkStateResponse$Type();
9380
+ // @generated message type with reflection information, may provide speed optimized methods
9381
+ class GetAddressesTrunkStateResponse_GetAddressesTrunkStateResponseV0$Type extends MessageType {
9382
+ constructor() {
9383
+ super("org.dash.platform.dapi.v0.GetAddressesTrunkStateResponse.GetAddressesTrunkStateResponseV0", [
9384
+ { no: 2, name: "proof", kind: "message", T: () => Proof },
9385
+ { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
9386
+ ]);
9387
+ }
9388
+ create(value) {
9389
+ const message = globalThis.Object.create((this.messagePrototype));
9390
+ if (value !== undefined)
9391
+ reflectionMergePartial(this, message, value);
9392
+ return message;
9393
+ }
9394
+ internalBinaryRead(reader, length, options, target) {
9395
+ let message = target ?? this.create(), end = reader.pos + length;
9396
+ while (reader.pos < end) {
9397
+ let [fieldNo, wireType] = reader.tag();
9398
+ switch (fieldNo) {
9399
+ case /* org.dash.platform.dapi.v0.Proof proof */ 2:
9400
+ message.proof = Proof.internalBinaryRead(reader, reader.uint32(), options, message.proof);
9401
+ break;
9402
+ case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
9403
+ message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
9404
+ break;
9405
+ default:
9406
+ let u = options.readUnknownField;
9407
+ if (u === "throw")
9408
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9409
+ let d = reader.skip(wireType);
9410
+ if (u !== false)
9411
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9412
+ }
9413
+ }
9414
+ return message;
9415
+ }
9416
+ internalBinaryWrite(message, writer, options) {
9417
+ /* org.dash.platform.dapi.v0.Proof proof = 2; */
9418
+ if (message.proof)
9419
+ Proof.internalBinaryWrite(message.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
9420
+ /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
9421
+ if (message.metadata)
9422
+ ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
9423
+ let u = options.writeUnknownFields;
9424
+ if (u !== false)
9425
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9426
+ return writer;
9427
+ }
9428
+ }
9429
+ /**
9430
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesTrunkStateResponse.GetAddressesTrunkStateResponseV0
9431
+ */
9432
+ export const GetAddressesTrunkStateResponse_GetAddressesTrunkStateResponseV0 = new GetAddressesTrunkStateResponse_GetAddressesTrunkStateResponseV0$Type();
9433
+ // @generated message type with reflection information, may provide speed optimized methods
9434
+ class GetAddressesBranchStateRequest$Type extends MessageType {
9435
+ constructor() {
9436
+ super("org.dash.platform.dapi.v0.GetAddressesBranchStateRequest", [
9437
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetAddressesBranchStateRequest_GetAddressesBranchStateRequestV0 }
9438
+ ]);
9439
+ }
9440
+ create(value) {
9441
+ const message = globalThis.Object.create((this.messagePrototype));
9442
+ message.version = { oneofKind: undefined };
9443
+ if (value !== undefined)
9444
+ reflectionMergePartial(this, message, value);
9445
+ return message;
9446
+ }
9447
+ internalBinaryRead(reader, length, options, target) {
9448
+ let message = target ?? this.create(), end = reader.pos + length;
9449
+ while (reader.pos < end) {
9450
+ let [fieldNo, wireType] = reader.tag();
9451
+ switch (fieldNo) {
9452
+ case /* org.dash.platform.dapi.v0.GetAddressesBranchStateRequest.GetAddressesBranchStateRequestV0 v0 */ 1:
9453
+ message.version = {
9454
+ oneofKind: "v0",
9455
+ v0: GetAddressesBranchStateRequest_GetAddressesBranchStateRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
9456
+ };
9457
+ break;
9458
+ default:
9459
+ let u = options.readUnknownField;
9460
+ if (u === "throw")
9461
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9462
+ let d = reader.skip(wireType);
9463
+ if (u !== false)
9464
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9465
+ }
9466
+ }
9467
+ return message;
9468
+ }
9469
+ internalBinaryWrite(message, writer, options) {
9470
+ /* org.dash.platform.dapi.v0.GetAddressesBranchStateRequest.GetAddressesBranchStateRequestV0 v0 = 1; */
9471
+ if (message.version.oneofKind === "v0")
9472
+ GetAddressesBranchStateRequest_GetAddressesBranchStateRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
9473
+ let u = options.writeUnknownFields;
9474
+ if (u !== false)
9475
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9476
+ return writer;
9477
+ }
9478
+ }
9479
+ /**
9480
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesBranchStateRequest
9481
+ */
9482
+ export const GetAddressesBranchStateRequest = new GetAddressesBranchStateRequest$Type();
9483
+ // @generated message type with reflection information, may provide speed optimized methods
9484
+ class GetAddressesBranchStateRequest_GetAddressesBranchStateRequestV0$Type extends MessageType {
9485
+ constructor() {
9486
+ super("org.dash.platform.dapi.v0.GetAddressesBranchStateRequest.GetAddressesBranchStateRequestV0", [
9487
+ { no: 1, name: "key", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
9488
+ { no: 2, name: "depth", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
9489
+ { no: 3, name: "checkpoint_height", kind: "scalar", T: 4 /*ScalarType.UINT64*/ }
9490
+ ]);
9491
+ }
9492
+ create(value) {
9493
+ const message = globalThis.Object.create((this.messagePrototype));
9494
+ message.key = new Uint8Array(0);
9495
+ message.depth = 0;
9496
+ message.checkpointHeight = "0";
9497
+ if (value !== undefined)
9498
+ reflectionMergePartial(this, message, value);
9499
+ return message;
9500
+ }
9501
+ internalBinaryRead(reader, length, options, target) {
9502
+ let message = target ?? this.create(), end = reader.pos + length;
9503
+ while (reader.pos < end) {
9504
+ let [fieldNo, wireType] = reader.tag();
9505
+ switch (fieldNo) {
9506
+ case /* bytes key */ 1:
9507
+ message.key = reader.bytes();
9508
+ break;
9509
+ case /* uint32 depth */ 2:
9510
+ message.depth = reader.uint32();
9511
+ break;
9512
+ case /* uint64 checkpoint_height */ 3:
9513
+ message.checkpointHeight = reader.uint64().toString();
9514
+ break;
9515
+ default:
9516
+ let u = options.readUnknownField;
9517
+ if (u === "throw")
9518
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9519
+ let d = reader.skip(wireType);
9520
+ if (u !== false)
9521
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9522
+ }
9523
+ }
9524
+ return message;
9525
+ }
9526
+ internalBinaryWrite(message, writer, options) {
9527
+ /* bytes key = 1; */
9528
+ if (message.key.length)
9529
+ writer.tag(1, WireType.LengthDelimited).bytes(message.key);
9530
+ /* uint32 depth = 2; */
9531
+ if (message.depth !== 0)
9532
+ writer.tag(2, WireType.Varint).uint32(message.depth);
9533
+ /* uint64 checkpoint_height = 3; */
9534
+ if (message.checkpointHeight !== "0")
9535
+ writer.tag(3, WireType.Varint).uint64(message.checkpointHeight);
9536
+ let u = options.writeUnknownFields;
9537
+ if (u !== false)
9538
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9539
+ return writer;
9540
+ }
9541
+ }
9542
+ /**
9543
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesBranchStateRequest.GetAddressesBranchStateRequestV0
9544
+ */
9545
+ export const GetAddressesBranchStateRequest_GetAddressesBranchStateRequestV0 = new GetAddressesBranchStateRequest_GetAddressesBranchStateRequestV0$Type();
9546
+ // @generated message type with reflection information, may provide speed optimized methods
9547
+ class GetAddressesBranchStateResponse$Type extends MessageType {
9548
+ constructor() {
9549
+ super("org.dash.platform.dapi.v0.GetAddressesBranchStateResponse", [
9550
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetAddressesBranchStateResponse_GetAddressesBranchStateResponseV0 }
9551
+ ]);
9552
+ }
9553
+ create(value) {
9554
+ const message = globalThis.Object.create((this.messagePrototype));
9555
+ message.version = { oneofKind: undefined };
9556
+ if (value !== undefined)
9557
+ reflectionMergePartial(this, message, value);
9558
+ return message;
9559
+ }
9560
+ internalBinaryRead(reader, length, options, target) {
9561
+ let message = target ?? this.create(), end = reader.pos + length;
9562
+ while (reader.pos < end) {
9563
+ let [fieldNo, wireType] = reader.tag();
9564
+ switch (fieldNo) {
9565
+ case /* org.dash.platform.dapi.v0.GetAddressesBranchStateResponse.GetAddressesBranchStateResponseV0 v0 */ 1:
9566
+ message.version = {
9567
+ oneofKind: "v0",
9568
+ v0: GetAddressesBranchStateResponse_GetAddressesBranchStateResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
9569
+ };
9570
+ break;
9571
+ default:
9572
+ let u = options.readUnknownField;
9573
+ if (u === "throw")
9574
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9575
+ let d = reader.skip(wireType);
9576
+ if (u !== false)
9577
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9578
+ }
9579
+ }
9580
+ return message;
9581
+ }
9582
+ internalBinaryWrite(message, writer, options) {
9583
+ /* org.dash.platform.dapi.v0.GetAddressesBranchStateResponse.GetAddressesBranchStateResponseV0 v0 = 1; */
9584
+ if (message.version.oneofKind === "v0")
9585
+ GetAddressesBranchStateResponse_GetAddressesBranchStateResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
9586
+ let u = options.writeUnknownFields;
9587
+ if (u !== false)
9588
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9589
+ return writer;
9590
+ }
9591
+ }
9592
+ /**
9593
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesBranchStateResponse
9594
+ */
9595
+ export const GetAddressesBranchStateResponse = new GetAddressesBranchStateResponse$Type();
9596
+ // @generated message type with reflection information, may provide speed optimized methods
9597
+ class GetAddressesBranchStateResponse_GetAddressesBranchStateResponseV0$Type extends MessageType {
9598
+ constructor() {
9599
+ super("org.dash.platform.dapi.v0.GetAddressesBranchStateResponse.GetAddressesBranchStateResponseV0", [
9600
+ { no: 2, name: "merk_proof", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
9601
+ ]);
9602
+ }
9603
+ create(value) {
9604
+ const message = globalThis.Object.create((this.messagePrototype));
9605
+ message.merkProof = new Uint8Array(0);
9606
+ if (value !== undefined)
9607
+ reflectionMergePartial(this, message, value);
9608
+ return message;
9609
+ }
9610
+ internalBinaryRead(reader, length, options, target) {
9611
+ let message = target ?? this.create(), end = reader.pos + length;
9612
+ while (reader.pos < end) {
9613
+ let [fieldNo, wireType] = reader.tag();
9614
+ switch (fieldNo) {
9615
+ case /* bytes merk_proof */ 2:
9616
+ message.merkProof = reader.bytes();
9617
+ break;
9618
+ default:
9619
+ let u = options.readUnknownField;
9620
+ if (u === "throw")
9621
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9622
+ let d = reader.skip(wireType);
9623
+ if (u !== false)
9624
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9625
+ }
9626
+ }
9627
+ return message;
9628
+ }
9629
+ internalBinaryWrite(message, writer, options) {
9630
+ /* bytes merk_proof = 2; */
9631
+ if (message.merkProof.length)
9632
+ writer.tag(2, WireType.LengthDelimited).bytes(message.merkProof);
9633
+ let u = options.writeUnknownFields;
9634
+ if (u !== false)
9635
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9636
+ return writer;
9637
+ }
9638
+ }
9639
+ /**
9640
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesBranchStateResponse.GetAddressesBranchStateResponseV0
9641
+ */
9642
+ export const GetAddressesBranchStateResponse_GetAddressesBranchStateResponseV0 = new GetAddressesBranchStateResponse_GetAddressesBranchStateResponseV0$Type();
9643
+ // @generated message type with reflection information, may provide speed optimized methods
9644
+ class GetRecentAddressBalanceChangesRequest$Type extends MessageType {
9645
+ constructor() {
9646
+ super("org.dash.platform.dapi.v0.GetRecentAddressBalanceChangesRequest", [
9647
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetRecentAddressBalanceChangesRequest_GetRecentAddressBalanceChangesRequestV0 }
9648
+ ]);
9649
+ }
9650
+ create(value) {
9651
+ const message = globalThis.Object.create((this.messagePrototype));
9652
+ message.version = { oneofKind: undefined };
9653
+ if (value !== undefined)
9654
+ reflectionMergePartial(this, message, value);
9655
+ return message;
9656
+ }
9657
+ internalBinaryRead(reader, length, options, target) {
9658
+ let message = target ?? this.create(), end = reader.pos + length;
9659
+ while (reader.pos < end) {
9660
+ let [fieldNo, wireType] = reader.tag();
9661
+ switch (fieldNo) {
9662
+ case /* org.dash.platform.dapi.v0.GetRecentAddressBalanceChangesRequest.GetRecentAddressBalanceChangesRequestV0 v0 */ 1:
9663
+ message.version = {
9664
+ oneofKind: "v0",
9665
+ v0: GetRecentAddressBalanceChangesRequest_GetRecentAddressBalanceChangesRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
9666
+ };
9667
+ break;
9668
+ default:
9669
+ let u = options.readUnknownField;
9670
+ if (u === "throw")
9671
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9672
+ let d = reader.skip(wireType);
9673
+ if (u !== false)
9674
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9675
+ }
9676
+ }
9677
+ return message;
9678
+ }
9679
+ internalBinaryWrite(message, writer, options) {
9680
+ /* org.dash.platform.dapi.v0.GetRecentAddressBalanceChangesRequest.GetRecentAddressBalanceChangesRequestV0 v0 = 1; */
9681
+ if (message.version.oneofKind === "v0")
9682
+ GetRecentAddressBalanceChangesRequest_GetRecentAddressBalanceChangesRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
9683
+ let u = options.writeUnknownFields;
9684
+ if (u !== false)
9685
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9686
+ return writer;
9687
+ }
9688
+ }
9689
+ /**
9690
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetRecentAddressBalanceChangesRequest
9691
+ */
9692
+ export const GetRecentAddressBalanceChangesRequest = new GetRecentAddressBalanceChangesRequest$Type();
9693
+ // @generated message type with reflection information, may provide speed optimized methods
9694
+ class GetRecentAddressBalanceChangesRequest_GetRecentAddressBalanceChangesRequestV0$Type extends MessageType {
9695
+ constructor() {
9696
+ super("org.dash.platform.dapi.v0.GetRecentAddressBalanceChangesRequest.GetRecentAddressBalanceChangesRequestV0", [
9697
+ { no: 1, name: "start_height", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
9698
+ { no: 2, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
9699
+ { no: 3, name: "start_height_exclusive", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
9700
+ ]);
9701
+ }
9702
+ create(value) {
9703
+ const message = globalThis.Object.create((this.messagePrototype));
9704
+ message.startHeight = "0";
9705
+ message.prove = false;
9706
+ message.startHeightExclusive = false;
9707
+ if (value !== undefined)
9708
+ reflectionMergePartial(this, message, value);
9709
+ return message;
9710
+ }
9711
+ internalBinaryRead(reader, length, options, target) {
9712
+ let message = target ?? this.create(), end = reader.pos + length;
9713
+ while (reader.pos < end) {
9714
+ let [fieldNo, wireType] = reader.tag();
9715
+ switch (fieldNo) {
9716
+ case /* uint64 start_height = 1 [jstype = JS_STRING] */ 1:
9717
+ message.startHeight = reader.uint64().toString();
9718
+ break;
9719
+ case /* bool prove */ 2:
9720
+ message.prove = reader.bool();
9721
+ break;
9722
+ case /* bool start_height_exclusive */ 3:
9723
+ message.startHeightExclusive = reader.bool();
9724
+ break;
9725
+ default:
9726
+ let u = options.readUnknownField;
9727
+ if (u === "throw")
9728
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9729
+ let d = reader.skip(wireType);
9730
+ if (u !== false)
9731
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9732
+ }
9733
+ }
9734
+ return message;
9735
+ }
9736
+ internalBinaryWrite(message, writer, options) {
9737
+ /* uint64 start_height = 1 [jstype = JS_STRING]; */
9738
+ if (message.startHeight !== "0")
9739
+ writer.tag(1, WireType.Varint).uint64(message.startHeight);
9740
+ /* bool prove = 2; */
9741
+ if (message.prove !== false)
9742
+ writer.tag(2, WireType.Varint).bool(message.prove);
9743
+ /* bool start_height_exclusive = 3; */
9744
+ if (message.startHeightExclusive !== false)
9745
+ writer.tag(3, WireType.Varint).bool(message.startHeightExclusive);
9746
+ let u = options.writeUnknownFields;
9747
+ if (u !== false)
9748
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9749
+ return writer;
9750
+ }
9751
+ }
9752
+ /**
9753
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetRecentAddressBalanceChangesRequest.GetRecentAddressBalanceChangesRequestV0
9754
+ */
9755
+ export const GetRecentAddressBalanceChangesRequest_GetRecentAddressBalanceChangesRequestV0 = new GetRecentAddressBalanceChangesRequest_GetRecentAddressBalanceChangesRequestV0$Type();
9756
+ // @generated message type with reflection information, may provide speed optimized methods
9757
+ class GetRecentAddressBalanceChangesResponse$Type extends MessageType {
9758
+ constructor() {
9759
+ super("org.dash.platform.dapi.v0.GetRecentAddressBalanceChangesResponse", [
9760
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetRecentAddressBalanceChangesResponse_GetRecentAddressBalanceChangesResponseV0 }
9761
+ ]);
9762
+ }
9763
+ create(value) {
9764
+ const message = globalThis.Object.create((this.messagePrototype));
9765
+ message.version = { oneofKind: undefined };
9766
+ if (value !== undefined)
9767
+ reflectionMergePartial(this, message, value);
9768
+ return message;
9769
+ }
9770
+ internalBinaryRead(reader, length, options, target) {
9771
+ let message = target ?? this.create(), end = reader.pos + length;
9772
+ while (reader.pos < end) {
9773
+ let [fieldNo, wireType] = reader.tag();
9774
+ switch (fieldNo) {
9775
+ case /* org.dash.platform.dapi.v0.GetRecentAddressBalanceChangesResponse.GetRecentAddressBalanceChangesResponseV0 v0 */ 1:
9776
+ message.version = {
9777
+ oneofKind: "v0",
9778
+ v0: GetRecentAddressBalanceChangesResponse_GetRecentAddressBalanceChangesResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
9779
+ };
9780
+ break;
9781
+ default:
9782
+ let u = options.readUnknownField;
9783
+ if (u === "throw")
9784
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9785
+ let d = reader.skip(wireType);
9786
+ if (u !== false)
9787
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9788
+ }
9789
+ }
9790
+ return message;
9791
+ }
9792
+ internalBinaryWrite(message, writer, options) {
9793
+ /* org.dash.platform.dapi.v0.GetRecentAddressBalanceChangesResponse.GetRecentAddressBalanceChangesResponseV0 v0 = 1; */
9794
+ if (message.version.oneofKind === "v0")
9795
+ GetRecentAddressBalanceChangesResponse_GetRecentAddressBalanceChangesResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
9796
+ let u = options.writeUnknownFields;
9797
+ if (u !== false)
9798
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9799
+ return writer;
9800
+ }
9801
+ }
9802
+ /**
9803
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetRecentAddressBalanceChangesResponse
9804
+ */
9805
+ export const GetRecentAddressBalanceChangesResponse = new GetRecentAddressBalanceChangesResponse$Type();
9806
+ // @generated message type with reflection information, may provide speed optimized methods
9807
+ class GetRecentAddressBalanceChangesResponse_GetRecentAddressBalanceChangesResponseV0$Type extends MessageType {
9808
+ constructor() {
9809
+ super("org.dash.platform.dapi.v0.GetRecentAddressBalanceChangesResponse.GetRecentAddressBalanceChangesResponseV0", [
9810
+ { no: 1, name: "address_balance_update_entries", kind: "message", oneof: "result", T: () => AddressBalanceUpdateEntries },
9811
+ { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
9812
+ { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
9813
+ ]);
9814
+ }
9815
+ create(value) {
9816
+ const message = globalThis.Object.create((this.messagePrototype));
9817
+ message.result = { oneofKind: undefined };
9818
+ if (value !== undefined)
9819
+ reflectionMergePartial(this, message, value);
9820
+ return message;
9821
+ }
9822
+ internalBinaryRead(reader, length, options, target) {
9823
+ let message = target ?? this.create(), end = reader.pos + length;
9824
+ while (reader.pos < end) {
9825
+ let [fieldNo, wireType] = reader.tag();
9826
+ switch (fieldNo) {
9827
+ case /* org.dash.platform.dapi.v0.AddressBalanceUpdateEntries address_balance_update_entries */ 1:
9828
+ message.result = {
9829
+ oneofKind: "addressBalanceUpdateEntries",
9830
+ addressBalanceUpdateEntries: AddressBalanceUpdateEntries.internalBinaryRead(reader, reader.uint32(), options, message.result.addressBalanceUpdateEntries)
9831
+ };
9832
+ break;
9833
+ case /* org.dash.platform.dapi.v0.Proof proof */ 2:
9834
+ message.result = {
9835
+ oneofKind: "proof",
9836
+ proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
9837
+ };
9838
+ break;
9839
+ case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
9840
+ message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
9841
+ break;
9842
+ default:
9843
+ let u = options.readUnknownField;
9844
+ if (u === "throw")
9845
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9846
+ let d = reader.skip(wireType);
9847
+ if (u !== false)
9848
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9849
+ }
9850
+ }
9851
+ return message;
9852
+ }
9853
+ internalBinaryWrite(message, writer, options) {
9854
+ /* org.dash.platform.dapi.v0.AddressBalanceUpdateEntries address_balance_update_entries = 1; */
9855
+ if (message.result.oneofKind === "addressBalanceUpdateEntries")
9856
+ AddressBalanceUpdateEntries.internalBinaryWrite(message.result.addressBalanceUpdateEntries, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
9857
+ /* org.dash.platform.dapi.v0.Proof proof = 2; */
9858
+ if (message.result.oneofKind === "proof")
9859
+ Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
9860
+ /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
9861
+ if (message.metadata)
9862
+ ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
9863
+ let u = options.writeUnknownFields;
9864
+ if (u !== false)
9865
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9866
+ return writer;
9867
+ }
9868
+ }
9869
+ /**
9870
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetRecentAddressBalanceChangesResponse.GetRecentAddressBalanceChangesResponseV0
9871
+ */
9872
+ export const GetRecentAddressBalanceChangesResponse_GetRecentAddressBalanceChangesResponseV0 = new GetRecentAddressBalanceChangesResponse_GetRecentAddressBalanceChangesResponseV0$Type();
9873
+ // @generated message type with reflection information, may provide speed optimized methods
9874
+ class BlockHeightCreditEntry$Type extends MessageType {
9875
+ constructor() {
9876
+ super("org.dash.platform.dapi.v0.BlockHeightCreditEntry", [
9877
+ { no: 1, name: "block_height", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
9878
+ { no: 2, name: "credits", kind: "scalar", T: 4 /*ScalarType.UINT64*/ }
9879
+ ]);
9880
+ }
9881
+ create(value) {
9882
+ const message = globalThis.Object.create((this.messagePrototype));
9883
+ message.blockHeight = "0";
9884
+ message.credits = "0";
9885
+ if (value !== undefined)
9886
+ reflectionMergePartial(this, message, value);
9887
+ return message;
9888
+ }
9889
+ internalBinaryRead(reader, length, options, target) {
9890
+ let message = target ?? this.create(), end = reader.pos + length;
9891
+ while (reader.pos < end) {
9892
+ let [fieldNo, wireType] = reader.tag();
9893
+ switch (fieldNo) {
9894
+ case /* uint64 block_height = 1 [jstype = JS_STRING] */ 1:
9895
+ message.blockHeight = reader.uint64().toString();
9896
+ break;
9897
+ case /* uint64 credits = 2 [jstype = JS_STRING] */ 2:
9898
+ message.credits = reader.uint64().toString();
9899
+ break;
9900
+ default:
9901
+ let u = options.readUnknownField;
9902
+ if (u === "throw")
9903
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9904
+ let d = reader.skip(wireType);
9905
+ if (u !== false)
9906
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9907
+ }
9908
+ }
9909
+ return message;
9910
+ }
9911
+ internalBinaryWrite(message, writer, options) {
9912
+ /* uint64 block_height = 1 [jstype = JS_STRING]; */
9913
+ if (message.blockHeight !== "0")
9914
+ writer.tag(1, WireType.Varint).uint64(message.blockHeight);
9915
+ /* uint64 credits = 2 [jstype = JS_STRING]; */
9916
+ if (message.credits !== "0")
9917
+ writer.tag(2, WireType.Varint).uint64(message.credits);
9918
+ let u = options.writeUnknownFields;
9919
+ if (u !== false)
9920
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9921
+ return writer;
9922
+ }
9923
+ }
9924
+ /**
9925
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.BlockHeightCreditEntry
9926
+ */
9927
+ export const BlockHeightCreditEntry = new BlockHeightCreditEntry$Type();
9928
+ // @generated message type with reflection information, may provide speed optimized methods
9929
+ class CompactedAddressBalanceChange$Type extends MessageType {
9930
+ constructor() {
9931
+ super("org.dash.platform.dapi.v0.CompactedAddressBalanceChange", [
9932
+ { no: 1, name: "address", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
9933
+ { no: 2, name: "set_credits", kind: "scalar", oneof: "operation", T: 4 /*ScalarType.UINT64*/ },
9934
+ { no: 3, name: "add_to_credits_operations", kind: "message", oneof: "operation", T: () => AddToCreditsOperations }
9935
+ ]);
9936
+ }
9937
+ create(value) {
9938
+ const message = globalThis.Object.create((this.messagePrototype));
9939
+ message.address = new Uint8Array(0);
9940
+ message.operation = { oneofKind: undefined };
9941
+ if (value !== undefined)
9942
+ reflectionMergePartial(this, message, value);
9943
+ return message;
9944
+ }
9945
+ internalBinaryRead(reader, length, options, target) {
9946
+ let message = target ?? this.create(), end = reader.pos + length;
9947
+ while (reader.pos < end) {
9948
+ let [fieldNo, wireType] = reader.tag();
9949
+ switch (fieldNo) {
9950
+ case /* bytes address */ 1:
9951
+ message.address = reader.bytes();
9952
+ break;
9953
+ case /* uint64 set_credits = 2 [jstype = JS_STRING] */ 2:
9954
+ message.operation = {
9955
+ oneofKind: "setCredits",
9956
+ setCredits: reader.uint64().toString()
9957
+ };
9958
+ break;
9959
+ case /* org.dash.platform.dapi.v0.AddToCreditsOperations add_to_credits_operations */ 3:
9960
+ message.operation = {
9961
+ oneofKind: "addToCreditsOperations",
9962
+ addToCreditsOperations: AddToCreditsOperations.internalBinaryRead(reader, reader.uint32(), options, message.operation.addToCreditsOperations)
9963
+ };
9964
+ break;
9965
+ default:
9966
+ let u = options.readUnknownField;
9967
+ if (u === "throw")
9968
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
9969
+ let d = reader.skip(wireType);
9970
+ if (u !== false)
9971
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
9972
+ }
9973
+ }
9974
+ return message;
9975
+ }
9976
+ internalBinaryWrite(message, writer, options) {
9977
+ /* bytes address = 1; */
9978
+ if (message.address.length)
9979
+ writer.tag(1, WireType.LengthDelimited).bytes(message.address);
9980
+ /* uint64 set_credits = 2 [jstype = JS_STRING]; */
9981
+ if (message.operation.oneofKind === "setCredits")
9982
+ writer.tag(2, WireType.Varint).uint64(message.operation.setCredits);
9983
+ /* org.dash.platform.dapi.v0.AddToCreditsOperations add_to_credits_operations = 3; */
9984
+ if (message.operation.oneofKind === "addToCreditsOperations")
9985
+ AddToCreditsOperations.internalBinaryWrite(message.operation.addToCreditsOperations, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
9986
+ let u = options.writeUnknownFields;
9987
+ if (u !== false)
9988
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
9989
+ return writer;
9990
+ }
9991
+ }
9992
+ /**
9993
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.CompactedAddressBalanceChange
9994
+ */
9995
+ export const CompactedAddressBalanceChange = new CompactedAddressBalanceChange$Type();
9996
+ // @generated message type with reflection information, may provide speed optimized methods
9997
+ class AddToCreditsOperations$Type extends MessageType {
9998
+ constructor() {
9999
+ super("org.dash.platform.dapi.v0.AddToCreditsOperations", [
10000
+ { no: 1, name: "entries", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => BlockHeightCreditEntry }
10001
+ ]);
10002
+ }
10003
+ create(value) {
10004
+ const message = globalThis.Object.create((this.messagePrototype));
10005
+ message.entries = [];
10006
+ if (value !== undefined)
10007
+ reflectionMergePartial(this, message, value);
10008
+ return message;
10009
+ }
10010
+ internalBinaryRead(reader, length, options, target) {
10011
+ let message = target ?? this.create(), end = reader.pos + length;
10012
+ while (reader.pos < end) {
10013
+ let [fieldNo, wireType] = reader.tag();
10014
+ switch (fieldNo) {
10015
+ case /* repeated org.dash.platform.dapi.v0.BlockHeightCreditEntry entries */ 1:
10016
+ message.entries.push(BlockHeightCreditEntry.internalBinaryRead(reader, reader.uint32(), options));
10017
+ break;
10018
+ default:
10019
+ let u = options.readUnknownField;
10020
+ if (u === "throw")
10021
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10022
+ let d = reader.skip(wireType);
10023
+ if (u !== false)
10024
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10025
+ }
10026
+ }
10027
+ return message;
10028
+ }
10029
+ internalBinaryWrite(message, writer, options) {
10030
+ /* repeated org.dash.platform.dapi.v0.BlockHeightCreditEntry entries = 1; */
10031
+ for (let i = 0; i < message.entries.length; i++)
10032
+ BlockHeightCreditEntry.internalBinaryWrite(message.entries[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
10033
+ let u = options.writeUnknownFields;
10034
+ if (u !== false)
10035
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10036
+ return writer;
10037
+ }
10038
+ }
10039
+ /**
10040
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.AddToCreditsOperations
10041
+ */
10042
+ export const AddToCreditsOperations = new AddToCreditsOperations$Type();
10043
+ // @generated message type with reflection information, may provide speed optimized methods
10044
+ class CompactedBlockAddressBalanceChanges$Type extends MessageType {
10045
+ constructor() {
10046
+ super("org.dash.platform.dapi.v0.CompactedBlockAddressBalanceChanges", [
10047
+ { no: 1, name: "start_block_height", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
10048
+ { no: 2, name: "end_block_height", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
10049
+ { no: 3, name: "changes", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => CompactedAddressBalanceChange }
10050
+ ]);
10051
+ }
10052
+ create(value) {
10053
+ const message = globalThis.Object.create((this.messagePrototype));
10054
+ message.startBlockHeight = "0";
10055
+ message.endBlockHeight = "0";
10056
+ message.changes = [];
10057
+ if (value !== undefined)
10058
+ reflectionMergePartial(this, message, value);
10059
+ return message;
10060
+ }
10061
+ internalBinaryRead(reader, length, options, target) {
10062
+ let message = target ?? this.create(), end = reader.pos + length;
10063
+ while (reader.pos < end) {
10064
+ let [fieldNo, wireType] = reader.tag();
10065
+ switch (fieldNo) {
10066
+ case /* uint64 start_block_height = 1 [jstype = JS_STRING] */ 1:
10067
+ message.startBlockHeight = reader.uint64().toString();
10068
+ break;
10069
+ case /* uint64 end_block_height = 2 [jstype = JS_STRING] */ 2:
10070
+ message.endBlockHeight = reader.uint64().toString();
10071
+ break;
10072
+ case /* repeated org.dash.platform.dapi.v0.CompactedAddressBalanceChange changes */ 3:
10073
+ message.changes.push(CompactedAddressBalanceChange.internalBinaryRead(reader, reader.uint32(), options));
10074
+ break;
10075
+ default:
10076
+ let u = options.readUnknownField;
10077
+ if (u === "throw")
10078
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10079
+ let d = reader.skip(wireType);
10080
+ if (u !== false)
10081
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10082
+ }
10083
+ }
10084
+ return message;
10085
+ }
10086
+ internalBinaryWrite(message, writer, options) {
10087
+ /* uint64 start_block_height = 1 [jstype = JS_STRING]; */
10088
+ if (message.startBlockHeight !== "0")
10089
+ writer.tag(1, WireType.Varint).uint64(message.startBlockHeight);
10090
+ /* uint64 end_block_height = 2 [jstype = JS_STRING]; */
10091
+ if (message.endBlockHeight !== "0")
10092
+ writer.tag(2, WireType.Varint).uint64(message.endBlockHeight);
10093
+ /* repeated org.dash.platform.dapi.v0.CompactedAddressBalanceChange changes = 3; */
10094
+ for (let i = 0; i < message.changes.length; i++)
10095
+ CompactedAddressBalanceChange.internalBinaryWrite(message.changes[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
10096
+ let u = options.writeUnknownFields;
10097
+ if (u !== false)
10098
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10099
+ return writer;
10100
+ }
10101
+ }
10102
+ /**
10103
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.CompactedBlockAddressBalanceChanges
10104
+ */
10105
+ export const CompactedBlockAddressBalanceChanges = new CompactedBlockAddressBalanceChanges$Type();
10106
+ // @generated message type with reflection information, may provide speed optimized methods
10107
+ class CompactedAddressBalanceUpdateEntries$Type extends MessageType {
10108
+ constructor() {
10109
+ super("org.dash.platform.dapi.v0.CompactedAddressBalanceUpdateEntries", [
10110
+ { no: 1, name: "compacted_block_changes", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => CompactedBlockAddressBalanceChanges }
10111
+ ]);
10112
+ }
10113
+ create(value) {
10114
+ const message = globalThis.Object.create((this.messagePrototype));
10115
+ message.compactedBlockChanges = [];
10116
+ if (value !== undefined)
10117
+ reflectionMergePartial(this, message, value);
10118
+ return message;
10119
+ }
10120
+ internalBinaryRead(reader, length, options, target) {
10121
+ let message = target ?? this.create(), end = reader.pos + length;
10122
+ while (reader.pos < end) {
10123
+ let [fieldNo, wireType] = reader.tag();
10124
+ switch (fieldNo) {
10125
+ case /* repeated org.dash.platform.dapi.v0.CompactedBlockAddressBalanceChanges compacted_block_changes */ 1:
10126
+ message.compactedBlockChanges.push(CompactedBlockAddressBalanceChanges.internalBinaryRead(reader, reader.uint32(), options));
10127
+ break;
10128
+ default:
10129
+ let u = options.readUnknownField;
10130
+ if (u === "throw")
10131
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10132
+ let d = reader.skip(wireType);
10133
+ if (u !== false)
10134
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10135
+ }
10136
+ }
10137
+ return message;
10138
+ }
10139
+ internalBinaryWrite(message, writer, options) {
10140
+ /* repeated org.dash.platform.dapi.v0.CompactedBlockAddressBalanceChanges compacted_block_changes = 1; */
10141
+ for (let i = 0; i < message.compactedBlockChanges.length; i++)
10142
+ CompactedBlockAddressBalanceChanges.internalBinaryWrite(message.compactedBlockChanges[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
10143
+ let u = options.writeUnknownFields;
10144
+ if (u !== false)
10145
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10146
+ return writer;
10147
+ }
10148
+ }
10149
+ /**
10150
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.CompactedAddressBalanceUpdateEntries
10151
+ */
10152
+ export const CompactedAddressBalanceUpdateEntries = new CompactedAddressBalanceUpdateEntries$Type();
10153
+ // @generated message type with reflection information, may provide speed optimized methods
10154
+ class GetRecentCompactedAddressBalanceChangesRequest$Type extends MessageType {
10155
+ constructor() {
10156
+ super("org.dash.platform.dapi.v0.GetRecentCompactedAddressBalanceChangesRequest", [
10157
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetRecentCompactedAddressBalanceChangesRequest_GetRecentCompactedAddressBalanceChangesRequestV0 }
10158
+ ]);
10159
+ }
10160
+ create(value) {
10161
+ const message = globalThis.Object.create((this.messagePrototype));
10162
+ message.version = { oneofKind: undefined };
10163
+ if (value !== undefined)
10164
+ reflectionMergePartial(this, message, value);
10165
+ return message;
10166
+ }
10167
+ internalBinaryRead(reader, length, options, target) {
10168
+ let message = target ?? this.create(), end = reader.pos + length;
10169
+ while (reader.pos < end) {
10170
+ let [fieldNo, wireType] = reader.tag();
10171
+ switch (fieldNo) {
10172
+ case /* org.dash.platform.dapi.v0.GetRecentCompactedAddressBalanceChangesRequest.GetRecentCompactedAddressBalanceChangesRequestV0 v0 */ 1:
10173
+ message.version = {
10174
+ oneofKind: "v0",
10175
+ v0: GetRecentCompactedAddressBalanceChangesRequest_GetRecentCompactedAddressBalanceChangesRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
10176
+ };
10177
+ break;
10178
+ default:
10179
+ let u = options.readUnknownField;
10180
+ if (u === "throw")
10181
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10182
+ let d = reader.skip(wireType);
10183
+ if (u !== false)
10184
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10185
+ }
10186
+ }
10187
+ return message;
10188
+ }
10189
+ internalBinaryWrite(message, writer, options) {
10190
+ /* org.dash.platform.dapi.v0.GetRecentCompactedAddressBalanceChangesRequest.GetRecentCompactedAddressBalanceChangesRequestV0 v0 = 1; */
10191
+ if (message.version.oneofKind === "v0")
10192
+ GetRecentCompactedAddressBalanceChangesRequest_GetRecentCompactedAddressBalanceChangesRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
10193
+ let u = options.writeUnknownFields;
10194
+ if (u !== false)
10195
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10196
+ return writer;
10197
+ }
10198
+ }
10199
+ /**
10200
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetRecentCompactedAddressBalanceChangesRequest
10201
+ */
10202
+ export const GetRecentCompactedAddressBalanceChangesRequest = new GetRecentCompactedAddressBalanceChangesRequest$Type();
10203
+ // @generated message type with reflection information, may provide speed optimized methods
10204
+ class GetRecentCompactedAddressBalanceChangesRequest_GetRecentCompactedAddressBalanceChangesRequestV0$Type extends MessageType {
10205
+ constructor() {
10206
+ super("org.dash.platform.dapi.v0.GetRecentCompactedAddressBalanceChangesRequest.GetRecentCompactedAddressBalanceChangesRequestV0", [
10207
+ { no: 1, name: "start_block_height", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
10208
+ { no: 2, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
10209
+ ]);
10210
+ }
10211
+ create(value) {
10212
+ const message = globalThis.Object.create((this.messagePrototype));
10213
+ message.startBlockHeight = "0";
10214
+ message.prove = false;
10215
+ if (value !== undefined)
10216
+ reflectionMergePartial(this, message, value);
10217
+ return message;
10218
+ }
10219
+ internalBinaryRead(reader, length, options, target) {
10220
+ let message = target ?? this.create(), end = reader.pos + length;
10221
+ while (reader.pos < end) {
10222
+ let [fieldNo, wireType] = reader.tag();
10223
+ switch (fieldNo) {
10224
+ case /* uint64 start_block_height = 1 [jstype = JS_STRING] */ 1:
10225
+ message.startBlockHeight = reader.uint64().toString();
10226
+ break;
10227
+ case /* bool prove */ 2:
10228
+ message.prove = reader.bool();
10229
+ break;
10230
+ default:
10231
+ let u = options.readUnknownField;
10232
+ if (u === "throw")
10233
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10234
+ let d = reader.skip(wireType);
10235
+ if (u !== false)
10236
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10237
+ }
10238
+ }
10239
+ return message;
10240
+ }
10241
+ internalBinaryWrite(message, writer, options) {
10242
+ /* uint64 start_block_height = 1 [jstype = JS_STRING]; */
10243
+ if (message.startBlockHeight !== "0")
10244
+ writer.tag(1, WireType.Varint).uint64(message.startBlockHeight);
10245
+ /* bool prove = 2; */
10246
+ if (message.prove !== false)
10247
+ writer.tag(2, WireType.Varint).bool(message.prove);
10248
+ let u = options.writeUnknownFields;
10249
+ if (u !== false)
10250
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10251
+ return writer;
10252
+ }
10253
+ }
10254
+ /**
10255
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetRecentCompactedAddressBalanceChangesRequest.GetRecentCompactedAddressBalanceChangesRequestV0
10256
+ */
10257
+ export const GetRecentCompactedAddressBalanceChangesRequest_GetRecentCompactedAddressBalanceChangesRequestV0 = new GetRecentCompactedAddressBalanceChangesRequest_GetRecentCompactedAddressBalanceChangesRequestV0$Type();
10258
+ // @generated message type with reflection information, may provide speed optimized methods
10259
+ class GetRecentCompactedAddressBalanceChangesResponse$Type extends MessageType {
10260
+ constructor() {
10261
+ super("org.dash.platform.dapi.v0.GetRecentCompactedAddressBalanceChangesResponse", [
10262
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetRecentCompactedAddressBalanceChangesResponse_GetRecentCompactedAddressBalanceChangesResponseV0 }
10263
+ ]);
10264
+ }
10265
+ create(value) {
10266
+ const message = globalThis.Object.create((this.messagePrototype));
10267
+ message.version = { oneofKind: undefined };
10268
+ if (value !== undefined)
10269
+ reflectionMergePartial(this, message, value);
10270
+ return message;
10271
+ }
10272
+ internalBinaryRead(reader, length, options, target) {
10273
+ let message = target ?? this.create(), end = reader.pos + length;
10274
+ while (reader.pos < end) {
10275
+ let [fieldNo, wireType] = reader.tag();
10276
+ switch (fieldNo) {
10277
+ case /* org.dash.platform.dapi.v0.GetRecentCompactedAddressBalanceChangesResponse.GetRecentCompactedAddressBalanceChangesResponseV0 v0 */ 1:
10278
+ message.version = {
10279
+ oneofKind: "v0",
10280
+ v0: GetRecentCompactedAddressBalanceChangesResponse_GetRecentCompactedAddressBalanceChangesResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
10281
+ };
10282
+ break;
10283
+ default:
10284
+ let u = options.readUnknownField;
10285
+ if (u === "throw")
10286
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10287
+ let d = reader.skip(wireType);
10288
+ if (u !== false)
10289
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10290
+ }
10291
+ }
10292
+ return message;
10293
+ }
10294
+ internalBinaryWrite(message, writer, options) {
10295
+ /* org.dash.platform.dapi.v0.GetRecentCompactedAddressBalanceChangesResponse.GetRecentCompactedAddressBalanceChangesResponseV0 v0 = 1; */
10296
+ if (message.version.oneofKind === "v0")
10297
+ GetRecentCompactedAddressBalanceChangesResponse_GetRecentCompactedAddressBalanceChangesResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
10298
+ let u = options.writeUnknownFields;
10299
+ if (u !== false)
10300
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10301
+ return writer;
10302
+ }
10303
+ }
10304
+ /**
10305
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetRecentCompactedAddressBalanceChangesResponse
10306
+ */
10307
+ export const GetRecentCompactedAddressBalanceChangesResponse = new GetRecentCompactedAddressBalanceChangesResponse$Type();
10308
+ // @generated message type with reflection information, may provide speed optimized methods
10309
+ class GetRecentCompactedAddressBalanceChangesResponse_GetRecentCompactedAddressBalanceChangesResponseV0$Type extends MessageType {
10310
+ constructor() {
10311
+ super("org.dash.platform.dapi.v0.GetRecentCompactedAddressBalanceChangesResponse.GetRecentCompactedAddressBalanceChangesResponseV0", [
10312
+ { no: 1, name: "compacted_address_balance_update_entries", kind: "message", oneof: "result", T: () => CompactedAddressBalanceUpdateEntries },
10313
+ { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
10314
+ { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
10315
+ ]);
10316
+ }
10317
+ create(value) {
10318
+ const message = globalThis.Object.create((this.messagePrototype));
10319
+ message.result = { oneofKind: undefined };
10320
+ if (value !== undefined)
10321
+ reflectionMergePartial(this, message, value);
10322
+ return message;
10323
+ }
10324
+ internalBinaryRead(reader, length, options, target) {
10325
+ let message = target ?? this.create(), end = reader.pos + length;
10326
+ while (reader.pos < end) {
10327
+ let [fieldNo, wireType] = reader.tag();
10328
+ switch (fieldNo) {
10329
+ case /* org.dash.platform.dapi.v0.CompactedAddressBalanceUpdateEntries compacted_address_balance_update_entries */ 1:
10330
+ message.result = {
10331
+ oneofKind: "compactedAddressBalanceUpdateEntries",
10332
+ compactedAddressBalanceUpdateEntries: CompactedAddressBalanceUpdateEntries.internalBinaryRead(reader, reader.uint32(), options, message.result.compactedAddressBalanceUpdateEntries)
10333
+ };
10334
+ break;
10335
+ case /* org.dash.platform.dapi.v0.Proof proof */ 2:
10336
+ message.result = {
10337
+ oneofKind: "proof",
10338
+ proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
10339
+ };
10340
+ break;
10341
+ case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
10342
+ message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
10343
+ break;
10344
+ default:
10345
+ let u = options.readUnknownField;
10346
+ if (u === "throw")
10347
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10348
+ let d = reader.skip(wireType);
10349
+ if (u !== false)
10350
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10351
+ }
10352
+ }
10353
+ return message;
10354
+ }
10355
+ internalBinaryWrite(message, writer, options) {
10356
+ /* org.dash.platform.dapi.v0.CompactedAddressBalanceUpdateEntries compacted_address_balance_update_entries = 1; */
10357
+ if (message.result.oneofKind === "compactedAddressBalanceUpdateEntries")
10358
+ CompactedAddressBalanceUpdateEntries.internalBinaryWrite(message.result.compactedAddressBalanceUpdateEntries, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
10359
+ /* org.dash.platform.dapi.v0.Proof proof = 2; */
10360
+ if (message.result.oneofKind === "proof")
10361
+ Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
10362
+ /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
10363
+ if (message.metadata)
10364
+ ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
10365
+ let u = options.writeUnknownFields;
10366
+ if (u !== false)
10367
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10368
+ return writer;
10369
+ }
10370
+ }
10371
+ /**
10372
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetRecentCompactedAddressBalanceChangesResponse.GetRecentCompactedAddressBalanceChangesResponseV0
10373
+ */
10374
+ export const GetRecentCompactedAddressBalanceChangesResponse_GetRecentCompactedAddressBalanceChangesResponseV0 = new GetRecentCompactedAddressBalanceChangesResponse_GetRecentCompactedAddressBalanceChangesResponseV0$Type();
10375
+ // @generated message type with reflection information, may provide speed optimized methods
9073
10376
  class GetShieldedEncryptedNotesRequest$Type extends MessageType {
9074
10377
  constructor() {
9075
10378
  super("org.dash.platform.dapi.v0.GetShieldedEncryptedNotesRequest", [
@@ -11166,6 +12469,10 @@ export const Platform = new ServiceType("org.dash.platform.dapi.v0.Platform", [
11166
12469
  { name: "waitForStateTransitionResult", options: {}, I: WaitForStateTransitionResultRequest, O: WaitForStateTransitionResultResponse },
11167
12470
  { name: "getAddressInfo", options: {}, I: GetAddressInfoRequest, O: GetAddressInfoResponse },
11168
12471
  { name: "getAddressesInfos", options: {}, I: GetAddressesInfosRequest, O: GetAddressesInfosResponse },
12472
+ { name: "getAddressesTrunkState", options: {}, I: GetAddressesTrunkStateRequest, O: GetAddressesTrunkStateResponse },
12473
+ { name: "getAddressesBranchState", options: {}, I: GetAddressesBranchStateRequest, O: GetAddressesBranchStateResponse },
12474
+ { name: "getRecentAddressBalanceChanges", options: {}, I: GetRecentAddressBalanceChangesRequest, O: GetRecentAddressBalanceChangesResponse },
12475
+ { name: "getRecentCompactedAddressBalanceChanges", options: {}, I: GetRecentCompactedAddressBalanceChangesRequest, O: GetRecentCompactedAddressBalanceChangesResponse },
11169
12476
  { name: "getShieldedEncryptedNotes", options: {}, I: GetShieldedEncryptedNotesRequest, O: GetShieldedEncryptedNotesResponse },
11170
12477
  { name: "getShieldedAnchors", options: {}, I: GetShieldedAnchorsRequest, O: GetShieldedAnchorsResponse },
11171
12478
  { name: "getMostRecentShieldedAnchor", options: {}, I: GetMostRecentShieldedAnchorRequest, O: GetMostRecentShieldedAnchorResponse },