dash-platform-sdk 1.4.0 → 1.5.0-dev.10

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.
Files changed (57) hide show
  1. package/README.md +16 -15
  2. package/bundle.min.js +1 -21
  3. package/package.json +4 -3
  4. package/proto/generated/platform.client.d.ts +110 -0
  5. package/proto/generated/platform.client.js +89 -12
  6. package/proto/generated/platform.d.ts +1671 -0
  7. package/proto/generated/platform.js +3381 -1
  8. package/src/DashPlatformSDK.d.ts +2 -0
  9. package/src/DashPlatformSDK.js +3 -0
  10. package/src/constants.d.ts +2 -1
  11. package/src/constants.js +2 -1
  12. package/src/identities/createStateTransition.js +2 -2
  13. package/src/keyPair/index.d.ts +87 -0
  14. package/src/keyPair/index.js +128 -0
  15. package/src/node/{epochs.d.ts → epochInfos.d.ts} +1 -1
  16. package/src/node/{epochs.js → epochInfos.js} +1 -1
  17. package/src/node/finalizedEpochInfos.d.ts +21 -0
  18. package/src/node/finalizedEpochInfos.js +54 -0
  19. package/src/node/index.d.ts +9 -1
  20. package/src/node/index.js +11 -1
  21. package/src/platformAddresses/createStateTransition.d.ts +12 -0
  22. package/src/platformAddresses/createStateTransition.js +62 -0
  23. package/src/platformAddresses/getAddressesBranchState.d.ts +3 -0
  24. package/src/platformAddresses/getAddressesBranchState.js +21 -0
  25. package/src/platformAddresses/getAddressesTrunkState.d.ts +3 -0
  26. package/src/platformAddresses/getAddressesTrunkState.js +33 -0
  27. package/src/platformAddresses/getRecentAddressBalanceChanges.d.ts +3 -0
  28. package/src/platformAddresses/getRecentAddressBalanceChanges.js +38 -0
  29. package/src/platformAddresses/getRecentCompactedAddressBalanceChanges.d.ts +3 -0
  30. package/src/platformAddresses/getRecentCompactedAddressBalanceChanges.js +37 -0
  31. package/src/platformAddresses/index.d.ts +63 -2
  32. package/src/platformAddresses/index.js +76 -0
  33. package/src/shielded/createStateTransition.d.ts +3 -0
  34. package/src/shielded/createStateTransition.js +60 -0
  35. package/src/shielded/getMostRecentShieldedAnchor.d.ts +2 -0
  36. package/src/shielded/getMostRecentShieldedAnchor.js +36 -0
  37. package/src/shielded/getShieldedAnchors.d.ts +2 -0
  38. package/src/shielded/getShieldedAnchors.js +36 -0
  39. package/src/shielded/getShieldedEncryptedNotes.d.ts +3 -0
  40. package/src/shielded/getShieldedEncryptedNotes.js +43 -0
  41. package/src/shielded/getShieldedNotesCount.d.ts +2 -0
  42. package/src/shielded/getShieldedNotesCount.js +36 -0
  43. package/src/shielded/getShieldedNullifiers.d.ts +3 -0
  44. package/src/shielded/getShieldedNullifiers.js +40 -0
  45. package/src/shielded/getShieldedPoolState.d.ts +2 -0
  46. package/src/shielded/getShieldedPoolState.js +36 -0
  47. package/src/shielded/index.d.ts +131 -0
  48. package/src/shielded/index.js +188 -0
  49. package/src/utils/verifyTenderdashProof.js +3 -0
  50. package/test/unit/Identity.spec.js +1 -1
  51. package/test/unit/KeyPair.spec.js +80 -0
  52. package/test/unit/Node.spec.js +6 -0
  53. package/test/unit/PlatformAddress.spec.js +155 -1
  54. package/test/unit/Shielded.spec.d.ts +1 -0
  55. package/test/unit/Shielded.spec.js +237 -0
  56. package/types.d.ts +153 -2
  57. package/types.js +1 -1
@@ -9069,6 +9069,3375 @@ class GetAddressesInfosResponse_GetAddressesInfosResponseV0$Type extends Message
9069
9069
  * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesInfosResponse.GetAddressesInfosResponseV0
9070
9070
  */
9071
9071
  export const GetAddressesInfosResponse_GetAddressesInfosResponseV0 = new GetAddressesInfosResponse_GetAddressesInfosResponseV0$Type();
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
10376
+ class GetShieldedEncryptedNotesRequest$Type extends MessageType {
10377
+ constructor() {
10378
+ super("org.dash.platform.dapi.v0.GetShieldedEncryptedNotesRequest", [
10379
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedEncryptedNotesRequest_GetShieldedEncryptedNotesRequestV0 }
10380
+ ]);
10381
+ }
10382
+ create(value) {
10383
+ const message = globalThis.Object.create((this.messagePrototype));
10384
+ message.version = { oneofKind: undefined };
10385
+ if (value !== undefined)
10386
+ reflectionMergePartial(this, message, value);
10387
+ return message;
10388
+ }
10389
+ internalBinaryRead(reader, length, options, target) {
10390
+ let message = target ?? this.create(), end = reader.pos + length;
10391
+ while (reader.pos < end) {
10392
+ let [fieldNo, wireType] = reader.tag();
10393
+ switch (fieldNo) {
10394
+ case /* org.dash.platform.dapi.v0.GetShieldedEncryptedNotesRequest.GetShieldedEncryptedNotesRequestV0 v0 */ 1:
10395
+ message.version = {
10396
+ oneofKind: "v0",
10397
+ v0: GetShieldedEncryptedNotesRequest_GetShieldedEncryptedNotesRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
10398
+ };
10399
+ break;
10400
+ default:
10401
+ let u = options.readUnknownField;
10402
+ if (u === "throw")
10403
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10404
+ let d = reader.skip(wireType);
10405
+ if (u !== false)
10406
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10407
+ }
10408
+ }
10409
+ return message;
10410
+ }
10411
+ internalBinaryWrite(message, writer, options) {
10412
+ /* org.dash.platform.dapi.v0.GetShieldedEncryptedNotesRequest.GetShieldedEncryptedNotesRequestV0 v0 = 1; */
10413
+ if (message.version.oneofKind === "v0")
10414
+ GetShieldedEncryptedNotesRequest_GetShieldedEncryptedNotesRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
10415
+ let u = options.writeUnknownFields;
10416
+ if (u !== false)
10417
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10418
+ return writer;
10419
+ }
10420
+ }
10421
+ /**
10422
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedEncryptedNotesRequest
10423
+ */
10424
+ export const GetShieldedEncryptedNotesRequest = new GetShieldedEncryptedNotesRequest$Type();
10425
+ // @generated message type with reflection information, may provide speed optimized methods
10426
+ class GetShieldedEncryptedNotesRequest_GetShieldedEncryptedNotesRequestV0$Type extends MessageType {
10427
+ constructor() {
10428
+ super("org.dash.platform.dapi.v0.GetShieldedEncryptedNotesRequest.GetShieldedEncryptedNotesRequestV0", [
10429
+ { no: 1, name: "start_index", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
10430
+ { no: 2, name: "count", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
10431
+ { no: 3, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
10432
+ ]);
10433
+ }
10434
+ create(value) {
10435
+ const message = globalThis.Object.create((this.messagePrototype));
10436
+ message.startIndex = "0";
10437
+ message.count = 0;
10438
+ message.prove = false;
10439
+ if (value !== undefined)
10440
+ reflectionMergePartial(this, message, value);
10441
+ return message;
10442
+ }
10443
+ internalBinaryRead(reader, length, options, target) {
10444
+ let message = target ?? this.create(), end = reader.pos + length;
10445
+ while (reader.pos < end) {
10446
+ let [fieldNo, wireType] = reader.tag();
10447
+ switch (fieldNo) {
10448
+ case /* uint64 start_index */ 1:
10449
+ message.startIndex = reader.uint64().toString();
10450
+ break;
10451
+ case /* uint32 count */ 2:
10452
+ message.count = reader.uint32();
10453
+ break;
10454
+ case /* bool prove */ 3:
10455
+ message.prove = reader.bool();
10456
+ break;
10457
+ default:
10458
+ let u = options.readUnknownField;
10459
+ if (u === "throw")
10460
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10461
+ let d = reader.skip(wireType);
10462
+ if (u !== false)
10463
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10464
+ }
10465
+ }
10466
+ return message;
10467
+ }
10468
+ internalBinaryWrite(message, writer, options) {
10469
+ /* uint64 start_index = 1; */
10470
+ if (message.startIndex !== "0")
10471
+ writer.tag(1, WireType.Varint).uint64(message.startIndex);
10472
+ /* uint32 count = 2; */
10473
+ if (message.count !== 0)
10474
+ writer.tag(2, WireType.Varint).uint32(message.count);
10475
+ /* bool prove = 3; */
10476
+ if (message.prove !== false)
10477
+ writer.tag(3, WireType.Varint).bool(message.prove);
10478
+ let u = options.writeUnknownFields;
10479
+ if (u !== false)
10480
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10481
+ return writer;
10482
+ }
10483
+ }
10484
+ /**
10485
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedEncryptedNotesRequest.GetShieldedEncryptedNotesRequestV0
10486
+ */
10487
+ export const GetShieldedEncryptedNotesRequest_GetShieldedEncryptedNotesRequestV0 = new GetShieldedEncryptedNotesRequest_GetShieldedEncryptedNotesRequestV0$Type();
10488
+ // @generated message type with reflection information, may provide speed optimized methods
10489
+ class GetShieldedEncryptedNotesResponse$Type extends MessageType {
10490
+ constructor() {
10491
+ super("org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse", [
10492
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0 }
10493
+ ]);
10494
+ }
10495
+ create(value) {
10496
+ const message = globalThis.Object.create((this.messagePrototype));
10497
+ message.version = { oneofKind: undefined };
10498
+ if (value !== undefined)
10499
+ reflectionMergePartial(this, message, value);
10500
+ return message;
10501
+ }
10502
+ internalBinaryRead(reader, length, options, target) {
10503
+ let message = target ?? this.create(), end = reader.pos + length;
10504
+ while (reader.pos < end) {
10505
+ let [fieldNo, wireType] = reader.tag();
10506
+ switch (fieldNo) {
10507
+ case /* org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0 v0 */ 1:
10508
+ message.version = {
10509
+ oneofKind: "v0",
10510
+ v0: GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
10511
+ };
10512
+ break;
10513
+ default:
10514
+ let u = options.readUnknownField;
10515
+ if (u === "throw")
10516
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10517
+ let d = reader.skip(wireType);
10518
+ if (u !== false)
10519
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10520
+ }
10521
+ }
10522
+ return message;
10523
+ }
10524
+ internalBinaryWrite(message, writer, options) {
10525
+ /* org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0 v0 = 1; */
10526
+ if (message.version.oneofKind === "v0")
10527
+ GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
10528
+ let u = options.writeUnknownFields;
10529
+ if (u !== false)
10530
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10531
+ return writer;
10532
+ }
10533
+ }
10534
+ /**
10535
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse
10536
+ */
10537
+ export const GetShieldedEncryptedNotesResponse = new GetShieldedEncryptedNotesResponse$Type();
10538
+ // @generated message type with reflection information, may provide speed optimized methods
10539
+ class GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0$Type extends MessageType {
10540
+ constructor() {
10541
+ super("org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0", [
10542
+ { no: 1, name: "encrypted_notes", kind: "message", oneof: "result", T: () => GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNotes },
10543
+ { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
10544
+ { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
10545
+ ]);
10546
+ }
10547
+ create(value) {
10548
+ const message = globalThis.Object.create((this.messagePrototype));
10549
+ message.result = { oneofKind: undefined };
10550
+ if (value !== undefined)
10551
+ reflectionMergePartial(this, message, value);
10552
+ return message;
10553
+ }
10554
+ internalBinaryRead(reader, length, options, target) {
10555
+ let message = target ?? this.create(), end = reader.pos + length;
10556
+ while (reader.pos < end) {
10557
+ let [fieldNo, wireType] = reader.tag();
10558
+ switch (fieldNo) {
10559
+ case /* org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNotes encrypted_notes */ 1:
10560
+ message.result = {
10561
+ oneofKind: "encryptedNotes",
10562
+ encryptedNotes: GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNotes.internalBinaryRead(reader, reader.uint32(), options, message.result.encryptedNotes)
10563
+ };
10564
+ break;
10565
+ case /* org.dash.platform.dapi.v0.Proof proof */ 2:
10566
+ message.result = {
10567
+ oneofKind: "proof",
10568
+ proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
10569
+ };
10570
+ break;
10571
+ case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
10572
+ message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
10573
+ break;
10574
+ default:
10575
+ let u = options.readUnknownField;
10576
+ if (u === "throw")
10577
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10578
+ let d = reader.skip(wireType);
10579
+ if (u !== false)
10580
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10581
+ }
10582
+ }
10583
+ return message;
10584
+ }
10585
+ internalBinaryWrite(message, writer, options) {
10586
+ /* org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNotes encrypted_notes = 1; */
10587
+ if (message.result.oneofKind === "encryptedNotes")
10588
+ GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNotes.internalBinaryWrite(message.result.encryptedNotes, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
10589
+ /* org.dash.platform.dapi.v0.Proof proof = 2; */
10590
+ if (message.result.oneofKind === "proof")
10591
+ Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
10592
+ /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
10593
+ if (message.metadata)
10594
+ ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
10595
+ let u = options.writeUnknownFields;
10596
+ if (u !== false)
10597
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10598
+ return writer;
10599
+ }
10600
+ }
10601
+ /**
10602
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0
10603
+ */
10604
+ export const GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0 = new GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0$Type();
10605
+ // @generated message type with reflection information, may provide speed optimized methods
10606
+ class GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNote$Type extends MessageType {
10607
+ constructor() {
10608
+ super("org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNote", [
10609
+ { no: 1, name: "nullifier", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
10610
+ { no: 2, name: "cmx", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
10611
+ { no: 3, name: "encrypted_note", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
10612
+ { no: 4, name: "cv_net", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
10613
+ ]);
10614
+ }
10615
+ create(value) {
10616
+ const message = globalThis.Object.create((this.messagePrototype));
10617
+ message.nullifier = new Uint8Array(0);
10618
+ message.cmx = new Uint8Array(0);
10619
+ message.encryptedNote = new Uint8Array(0);
10620
+ message.cvNet = new Uint8Array(0);
10621
+ if (value !== undefined)
10622
+ reflectionMergePartial(this, message, value);
10623
+ return message;
10624
+ }
10625
+ internalBinaryRead(reader, length, options, target) {
10626
+ let message = target ?? this.create(), end = reader.pos + length;
10627
+ while (reader.pos < end) {
10628
+ let [fieldNo, wireType] = reader.tag();
10629
+ switch (fieldNo) {
10630
+ case /* bytes nullifier */ 1:
10631
+ message.nullifier = reader.bytes();
10632
+ break;
10633
+ case /* bytes cmx */ 2:
10634
+ message.cmx = reader.bytes();
10635
+ break;
10636
+ case /* bytes encrypted_note */ 3:
10637
+ message.encryptedNote = reader.bytes();
10638
+ break;
10639
+ case /* bytes cv_net */ 4:
10640
+ message.cvNet = reader.bytes();
10641
+ break;
10642
+ default:
10643
+ let u = options.readUnknownField;
10644
+ if (u === "throw")
10645
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10646
+ let d = reader.skip(wireType);
10647
+ if (u !== false)
10648
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10649
+ }
10650
+ }
10651
+ return message;
10652
+ }
10653
+ internalBinaryWrite(message, writer, options) {
10654
+ /* bytes nullifier = 1; */
10655
+ if (message.nullifier.length)
10656
+ writer.tag(1, WireType.LengthDelimited).bytes(message.nullifier);
10657
+ /* bytes cmx = 2; */
10658
+ if (message.cmx.length)
10659
+ writer.tag(2, WireType.LengthDelimited).bytes(message.cmx);
10660
+ /* bytes encrypted_note = 3; */
10661
+ if (message.encryptedNote.length)
10662
+ writer.tag(3, WireType.LengthDelimited).bytes(message.encryptedNote);
10663
+ /* bytes cv_net = 4; */
10664
+ if (message.cvNet.length)
10665
+ writer.tag(4, WireType.LengthDelimited).bytes(message.cvNet);
10666
+ let u = options.writeUnknownFields;
10667
+ if (u !== false)
10668
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10669
+ return writer;
10670
+ }
10671
+ }
10672
+ /**
10673
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNote
10674
+ */
10675
+ export const GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNote = new GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNote$Type();
10676
+ // @generated message type with reflection information, may provide speed optimized methods
10677
+ class GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNotes$Type extends MessageType {
10678
+ constructor() {
10679
+ super("org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNotes", [
10680
+ { no: 1, name: "entries", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNote }
10681
+ ]);
10682
+ }
10683
+ create(value) {
10684
+ const message = globalThis.Object.create((this.messagePrototype));
10685
+ message.entries = [];
10686
+ if (value !== undefined)
10687
+ reflectionMergePartial(this, message, value);
10688
+ return message;
10689
+ }
10690
+ internalBinaryRead(reader, length, options, target) {
10691
+ let message = target ?? this.create(), end = reader.pos + length;
10692
+ while (reader.pos < end) {
10693
+ let [fieldNo, wireType] = reader.tag();
10694
+ switch (fieldNo) {
10695
+ case /* repeated org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNote entries */ 1:
10696
+ message.entries.push(GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNote.internalBinaryRead(reader, reader.uint32(), options));
10697
+ break;
10698
+ default:
10699
+ let u = options.readUnknownField;
10700
+ if (u === "throw")
10701
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10702
+ let d = reader.skip(wireType);
10703
+ if (u !== false)
10704
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10705
+ }
10706
+ }
10707
+ return message;
10708
+ }
10709
+ internalBinaryWrite(message, writer, options) {
10710
+ /* repeated org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNote entries = 1; */
10711
+ for (let i = 0; i < message.entries.length; i++)
10712
+ GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNote.internalBinaryWrite(message.entries[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
10713
+ let u = options.writeUnknownFields;
10714
+ if (u !== false)
10715
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10716
+ return writer;
10717
+ }
10718
+ }
10719
+ /**
10720
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNotes
10721
+ */
10722
+ export const GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNotes = new GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNotes$Type();
10723
+ // @generated message type with reflection information, may provide speed optimized methods
10724
+ class GetShieldedAnchorsRequest$Type extends MessageType {
10725
+ constructor() {
10726
+ super("org.dash.platform.dapi.v0.GetShieldedAnchorsRequest", [
10727
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedAnchorsRequest_GetShieldedAnchorsRequestV0 }
10728
+ ]);
10729
+ }
10730
+ create(value) {
10731
+ const message = globalThis.Object.create((this.messagePrototype));
10732
+ message.version = { oneofKind: undefined };
10733
+ if (value !== undefined)
10734
+ reflectionMergePartial(this, message, value);
10735
+ return message;
10736
+ }
10737
+ internalBinaryRead(reader, length, options, target) {
10738
+ let message = target ?? this.create(), end = reader.pos + length;
10739
+ while (reader.pos < end) {
10740
+ let [fieldNo, wireType] = reader.tag();
10741
+ switch (fieldNo) {
10742
+ case /* org.dash.platform.dapi.v0.GetShieldedAnchorsRequest.GetShieldedAnchorsRequestV0 v0 */ 1:
10743
+ message.version = {
10744
+ oneofKind: "v0",
10745
+ v0: GetShieldedAnchorsRequest_GetShieldedAnchorsRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
10746
+ };
10747
+ break;
10748
+ default:
10749
+ let u = options.readUnknownField;
10750
+ if (u === "throw")
10751
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10752
+ let d = reader.skip(wireType);
10753
+ if (u !== false)
10754
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10755
+ }
10756
+ }
10757
+ return message;
10758
+ }
10759
+ internalBinaryWrite(message, writer, options) {
10760
+ /* org.dash.platform.dapi.v0.GetShieldedAnchorsRequest.GetShieldedAnchorsRequestV0 v0 = 1; */
10761
+ if (message.version.oneofKind === "v0")
10762
+ GetShieldedAnchorsRequest_GetShieldedAnchorsRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
10763
+ let u = options.writeUnknownFields;
10764
+ if (u !== false)
10765
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10766
+ return writer;
10767
+ }
10768
+ }
10769
+ /**
10770
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedAnchorsRequest
10771
+ */
10772
+ export const GetShieldedAnchorsRequest = new GetShieldedAnchorsRequest$Type();
10773
+ // @generated message type with reflection information, may provide speed optimized methods
10774
+ class GetShieldedAnchorsRequest_GetShieldedAnchorsRequestV0$Type extends MessageType {
10775
+ constructor() {
10776
+ super("org.dash.platform.dapi.v0.GetShieldedAnchorsRequest.GetShieldedAnchorsRequestV0", [
10777
+ { no: 1, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
10778
+ ]);
10779
+ }
10780
+ create(value) {
10781
+ const message = globalThis.Object.create((this.messagePrototype));
10782
+ message.prove = false;
10783
+ if (value !== undefined)
10784
+ reflectionMergePartial(this, message, value);
10785
+ return message;
10786
+ }
10787
+ internalBinaryRead(reader, length, options, target) {
10788
+ let message = target ?? this.create(), end = reader.pos + length;
10789
+ while (reader.pos < end) {
10790
+ let [fieldNo, wireType] = reader.tag();
10791
+ switch (fieldNo) {
10792
+ case /* bool prove */ 1:
10793
+ message.prove = reader.bool();
10794
+ break;
10795
+ default:
10796
+ let u = options.readUnknownField;
10797
+ if (u === "throw")
10798
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10799
+ let d = reader.skip(wireType);
10800
+ if (u !== false)
10801
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10802
+ }
10803
+ }
10804
+ return message;
10805
+ }
10806
+ internalBinaryWrite(message, writer, options) {
10807
+ /* bool prove = 1; */
10808
+ if (message.prove !== false)
10809
+ writer.tag(1, WireType.Varint).bool(message.prove);
10810
+ let u = options.writeUnknownFields;
10811
+ if (u !== false)
10812
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10813
+ return writer;
10814
+ }
10815
+ }
10816
+ /**
10817
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedAnchorsRequest.GetShieldedAnchorsRequestV0
10818
+ */
10819
+ export const GetShieldedAnchorsRequest_GetShieldedAnchorsRequestV0 = new GetShieldedAnchorsRequest_GetShieldedAnchorsRequestV0$Type();
10820
+ // @generated message type with reflection information, may provide speed optimized methods
10821
+ class GetShieldedAnchorsResponse$Type extends MessageType {
10822
+ constructor() {
10823
+ super("org.dash.platform.dapi.v0.GetShieldedAnchorsResponse", [
10824
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0 }
10825
+ ]);
10826
+ }
10827
+ create(value) {
10828
+ const message = globalThis.Object.create((this.messagePrototype));
10829
+ message.version = { oneofKind: undefined };
10830
+ if (value !== undefined)
10831
+ reflectionMergePartial(this, message, value);
10832
+ return message;
10833
+ }
10834
+ internalBinaryRead(reader, length, options, target) {
10835
+ let message = target ?? this.create(), end = reader.pos + length;
10836
+ while (reader.pos < end) {
10837
+ let [fieldNo, wireType] = reader.tag();
10838
+ switch (fieldNo) {
10839
+ case /* org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0 v0 */ 1:
10840
+ message.version = {
10841
+ oneofKind: "v0",
10842
+ v0: GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
10843
+ };
10844
+ break;
10845
+ default:
10846
+ let u = options.readUnknownField;
10847
+ if (u === "throw")
10848
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10849
+ let d = reader.skip(wireType);
10850
+ if (u !== false)
10851
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10852
+ }
10853
+ }
10854
+ return message;
10855
+ }
10856
+ internalBinaryWrite(message, writer, options) {
10857
+ /* org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0 v0 = 1; */
10858
+ if (message.version.oneofKind === "v0")
10859
+ GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
10860
+ let u = options.writeUnknownFields;
10861
+ if (u !== false)
10862
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10863
+ return writer;
10864
+ }
10865
+ }
10866
+ /**
10867
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedAnchorsResponse
10868
+ */
10869
+ export const GetShieldedAnchorsResponse = new GetShieldedAnchorsResponse$Type();
10870
+ // @generated message type with reflection information, may provide speed optimized methods
10871
+ class GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0$Type extends MessageType {
10872
+ constructor() {
10873
+ super("org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0", [
10874
+ { no: 1, name: "anchors", kind: "message", oneof: "result", T: () => GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0_Anchors },
10875
+ { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
10876
+ { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
10877
+ ]);
10878
+ }
10879
+ create(value) {
10880
+ const message = globalThis.Object.create((this.messagePrototype));
10881
+ message.result = { oneofKind: undefined };
10882
+ if (value !== undefined)
10883
+ reflectionMergePartial(this, message, value);
10884
+ return message;
10885
+ }
10886
+ internalBinaryRead(reader, length, options, target) {
10887
+ let message = target ?? this.create(), end = reader.pos + length;
10888
+ while (reader.pos < end) {
10889
+ let [fieldNo, wireType] = reader.tag();
10890
+ switch (fieldNo) {
10891
+ case /* org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0.Anchors anchors */ 1:
10892
+ message.result = {
10893
+ oneofKind: "anchors",
10894
+ anchors: GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0_Anchors.internalBinaryRead(reader, reader.uint32(), options, message.result.anchors)
10895
+ };
10896
+ break;
10897
+ case /* org.dash.platform.dapi.v0.Proof proof */ 2:
10898
+ message.result = {
10899
+ oneofKind: "proof",
10900
+ proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
10901
+ };
10902
+ break;
10903
+ case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
10904
+ message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
10905
+ break;
10906
+ default:
10907
+ let u = options.readUnknownField;
10908
+ if (u === "throw")
10909
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10910
+ let d = reader.skip(wireType);
10911
+ if (u !== false)
10912
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10913
+ }
10914
+ }
10915
+ return message;
10916
+ }
10917
+ internalBinaryWrite(message, writer, options) {
10918
+ /* org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0.Anchors anchors = 1; */
10919
+ if (message.result.oneofKind === "anchors")
10920
+ GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0_Anchors.internalBinaryWrite(message.result.anchors, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
10921
+ /* org.dash.platform.dapi.v0.Proof proof = 2; */
10922
+ if (message.result.oneofKind === "proof")
10923
+ Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
10924
+ /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
10925
+ if (message.metadata)
10926
+ ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
10927
+ let u = options.writeUnknownFields;
10928
+ if (u !== false)
10929
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10930
+ return writer;
10931
+ }
10932
+ }
10933
+ /**
10934
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0
10935
+ */
10936
+ export const GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0 = new GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0$Type();
10937
+ // @generated message type with reflection information, may provide speed optimized methods
10938
+ class GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0_Anchors$Type extends MessageType {
10939
+ constructor() {
10940
+ super("org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0.Anchors", [
10941
+ { no: 1, name: "anchors", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 12 /*ScalarType.BYTES*/ }
10942
+ ]);
10943
+ }
10944
+ create(value) {
10945
+ const message = globalThis.Object.create((this.messagePrototype));
10946
+ message.anchors = [];
10947
+ if (value !== undefined)
10948
+ reflectionMergePartial(this, message, value);
10949
+ return message;
10950
+ }
10951
+ internalBinaryRead(reader, length, options, target) {
10952
+ let message = target ?? this.create(), end = reader.pos + length;
10953
+ while (reader.pos < end) {
10954
+ let [fieldNo, wireType] = reader.tag();
10955
+ switch (fieldNo) {
10956
+ case /* repeated bytes anchors */ 1:
10957
+ message.anchors.push(reader.bytes());
10958
+ break;
10959
+ default:
10960
+ let u = options.readUnknownField;
10961
+ if (u === "throw")
10962
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
10963
+ let d = reader.skip(wireType);
10964
+ if (u !== false)
10965
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
10966
+ }
10967
+ }
10968
+ return message;
10969
+ }
10970
+ internalBinaryWrite(message, writer, options) {
10971
+ /* repeated bytes anchors = 1; */
10972
+ for (let i = 0; i < message.anchors.length; i++)
10973
+ writer.tag(1, WireType.LengthDelimited).bytes(message.anchors[i]);
10974
+ let u = options.writeUnknownFields;
10975
+ if (u !== false)
10976
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
10977
+ return writer;
10978
+ }
10979
+ }
10980
+ /**
10981
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0.Anchors
10982
+ */
10983
+ export const GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0_Anchors = new GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0_Anchors$Type();
10984
+ // @generated message type with reflection information, may provide speed optimized methods
10985
+ class GetMostRecentShieldedAnchorRequest$Type extends MessageType {
10986
+ constructor() {
10987
+ super("org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorRequest", [
10988
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetMostRecentShieldedAnchorRequest_GetMostRecentShieldedAnchorRequestV0 }
10989
+ ]);
10990
+ }
10991
+ create(value) {
10992
+ const message = globalThis.Object.create((this.messagePrototype));
10993
+ message.version = { oneofKind: undefined };
10994
+ if (value !== undefined)
10995
+ reflectionMergePartial(this, message, value);
10996
+ return message;
10997
+ }
10998
+ internalBinaryRead(reader, length, options, target) {
10999
+ let message = target ?? this.create(), end = reader.pos + length;
11000
+ while (reader.pos < end) {
11001
+ let [fieldNo, wireType] = reader.tag();
11002
+ switch (fieldNo) {
11003
+ case /* org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorRequest.GetMostRecentShieldedAnchorRequestV0 v0 */ 1:
11004
+ message.version = {
11005
+ oneofKind: "v0",
11006
+ v0: GetMostRecentShieldedAnchorRequest_GetMostRecentShieldedAnchorRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
11007
+ };
11008
+ break;
11009
+ default:
11010
+ let u = options.readUnknownField;
11011
+ if (u === "throw")
11012
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11013
+ let d = reader.skip(wireType);
11014
+ if (u !== false)
11015
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11016
+ }
11017
+ }
11018
+ return message;
11019
+ }
11020
+ internalBinaryWrite(message, writer, options) {
11021
+ /* org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorRequest.GetMostRecentShieldedAnchorRequestV0 v0 = 1; */
11022
+ if (message.version.oneofKind === "v0")
11023
+ GetMostRecentShieldedAnchorRequest_GetMostRecentShieldedAnchorRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
11024
+ let u = options.writeUnknownFields;
11025
+ if (u !== false)
11026
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11027
+ return writer;
11028
+ }
11029
+ }
11030
+ /**
11031
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorRequest
11032
+ */
11033
+ export const GetMostRecentShieldedAnchorRequest = new GetMostRecentShieldedAnchorRequest$Type();
11034
+ // @generated message type with reflection information, may provide speed optimized methods
11035
+ class GetMostRecentShieldedAnchorRequest_GetMostRecentShieldedAnchorRequestV0$Type extends MessageType {
11036
+ constructor() {
11037
+ super("org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorRequest.GetMostRecentShieldedAnchorRequestV0", [
11038
+ { no: 1, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
11039
+ ]);
11040
+ }
11041
+ create(value) {
11042
+ const message = globalThis.Object.create((this.messagePrototype));
11043
+ message.prove = false;
11044
+ if (value !== undefined)
11045
+ reflectionMergePartial(this, message, value);
11046
+ return message;
11047
+ }
11048
+ internalBinaryRead(reader, length, options, target) {
11049
+ let message = target ?? this.create(), end = reader.pos + length;
11050
+ while (reader.pos < end) {
11051
+ let [fieldNo, wireType] = reader.tag();
11052
+ switch (fieldNo) {
11053
+ case /* bool prove */ 1:
11054
+ message.prove = reader.bool();
11055
+ break;
11056
+ default:
11057
+ let u = options.readUnknownField;
11058
+ if (u === "throw")
11059
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11060
+ let d = reader.skip(wireType);
11061
+ if (u !== false)
11062
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11063
+ }
11064
+ }
11065
+ return message;
11066
+ }
11067
+ internalBinaryWrite(message, writer, options) {
11068
+ /* bool prove = 1; */
11069
+ if (message.prove !== false)
11070
+ writer.tag(1, WireType.Varint).bool(message.prove);
11071
+ let u = options.writeUnknownFields;
11072
+ if (u !== false)
11073
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11074
+ return writer;
11075
+ }
11076
+ }
11077
+ /**
11078
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorRequest.GetMostRecentShieldedAnchorRequestV0
11079
+ */
11080
+ export const GetMostRecentShieldedAnchorRequest_GetMostRecentShieldedAnchorRequestV0 = new GetMostRecentShieldedAnchorRequest_GetMostRecentShieldedAnchorRequestV0$Type();
11081
+ // @generated message type with reflection information, may provide speed optimized methods
11082
+ class GetMostRecentShieldedAnchorResponse$Type extends MessageType {
11083
+ constructor() {
11084
+ super("org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorResponse", [
11085
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetMostRecentShieldedAnchorResponse_GetMostRecentShieldedAnchorResponseV0 }
11086
+ ]);
11087
+ }
11088
+ create(value) {
11089
+ const message = globalThis.Object.create((this.messagePrototype));
11090
+ message.version = { oneofKind: undefined };
11091
+ if (value !== undefined)
11092
+ reflectionMergePartial(this, message, value);
11093
+ return message;
11094
+ }
11095
+ internalBinaryRead(reader, length, options, target) {
11096
+ let message = target ?? this.create(), end = reader.pos + length;
11097
+ while (reader.pos < end) {
11098
+ let [fieldNo, wireType] = reader.tag();
11099
+ switch (fieldNo) {
11100
+ case /* org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorResponse.GetMostRecentShieldedAnchorResponseV0 v0 */ 1:
11101
+ message.version = {
11102
+ oneofKind: "v0",
11103
+ v0: GetMostRecentShieldedAnchorResponse_GetMostRecentShieldedAnchorResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
11104
+ };
11105
+ break;
11106
+ default:
11107
+ let u = options.readUnknownField;
11108
+ if (u === "throw")
11109
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11110
+ let d = reader.skip(wireType);
11111
+ if (u !== false)
11112
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11113
+ }
11114
+ }
11115
+ return message;
11116
+ }
11117
+ internalBinaryWrite(message, writer, options) {
11118
+ /* org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorResponse.GetMostRecentShieldedAnchorResponseV0 v0 = 1; */
11119
+ if (message.version.oneofKind === "v0")
11120
+ GetMostRecentShieldedAnchorResponse_GetMostRecentShieldedAnchorResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
11121
+ let u = options.writeUnknownFields;
11122
+ if (u !== false)
11123
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11124
+ return writer;
11125
+ }
11126
+ }
11127
+ /**
11128
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorResponse
11129
+ */
11130
+ export const GetMostRecentShieldedAnchorResponse = new GetMostRecentShieldedAnchorResponse$Type();
11131
+ // @generated message type with reflection information, may provide speed optimized methods
11132
+ class GetMostRecentShieldedAnchorResponse_GetMostRecentShieldedAnchorResponseV0$Type extends MessageType {
11133
+ constructor() {
11134
+ super("org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorResponse.GetMostRecentShieldedAnchorResponseV0", [
11135
+ { no: 1, name: "anchor", kind: "scalar", oneof: "result", T: 12 /*ScalarType.BYTES*/ },
11136
+ { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
11137
+ { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
11138
+ ]);
11139
+ }
11140
+ create(value) {
11141
+ const message = globalThis.Object.create((this.messagePrototype));
11142
+ message.result = { oneofKind: undefined };
11143
+ if (value !== undefined)
11144
+ reflectionMergePartial(this, message, value);
11145
+ return message;
11146
+ }
11147
+ internalBinaryRead(reader, length, options, target) {
11148
+ let message = target ?? this.create(), end = reader.pos + length;
11149
+ while (reader.pos < end) {
11150
+ let [fieldNo, wireType] = reader.tag();
11151
+ switch (fieldNo) {
11152
+ case /* bytes anchor */ 1:
11153
+ message.result = {
11154
+ oneofKind: "anchor",
11155
+ anchor: reader.bytes()
11156
+ };
11157
+ break;
11158
+ case /* org.dash.platform.dapi.v0.Proof proof */ 2:
11159
+ message.result = {
11160
+ oneofKind: "proof",
11161
+ proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
11162
+ };
11163
+ break;
11164
+ case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
11165
+ message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
11166
+ break;
11167
+ default:
11168
+ let u = options.readUnknownField;
11169
+ if (u === "throw")
11170
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11171
+ let d = reader.skip(wireType);
11172
+ if (u !== false)
11173
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11174
+ }
11175
+ }
11176
+ return message;
11177
+ }
11178
+ internalBinaryWrite(message, writer, options) {
11179
+ /* bytes anchor = 1; */
11180
+ if (message.result.oneofKind === "anchor")
11181
+ writer.tag(1, WireType.LengthDelimited).bytes(message.result.anchor);
11182
+ /* org.dash.platform.dapi.v0.Proof proof = 2; */
11183
+ if (message.result.oneofKind === "proof")
11184
+ Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
11185
+ /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
11186
+ if (message.metadata)
11187
+ ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
11188
+ let u = options.writeUnknownFields;
11189
+ if (u !== false)
11190
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11191
+ return writer;
11192
+ }
11193
+ }
11194
+ /**
11195
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorResponse.GetMostRecentShieldedAnchorResponseV0
11196
+ */
11197
+ export const GetMostRecentShieldedAnchorResponse_GetMostRecentShieldedAnchorResponseV0 = new GetMostRecentShieldedAnchorResponse_GetMostRecentShieldedAnchorResponseV0$Type();
11198
+ // @generated message type with reflection information, may provide speed optimized methods
11199
+ class GetShieldedPoolStateRequest$Type extends MessageType {
11200
+ constructor() {
11201
+ super("org.dash.platform.dapi.v0.GetShieldedPoolStateRequest", [
11202
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedPoolStateRequest_GetShieldedPoolStateRequestV0 }
11203
+ ]);
11204
+ }
11205
+ create(value) {
11206
+ const message = globalThis.Object.create((this.messagePrototype));
11207
+ message.version = { oneofKind: undefined };
11208
+ if (value !== undefined)
11209
+ reflectionMergePartial(this, message, value);
11210
+ return message;
11211
+ }
11212
+ internalBinaryRead(reader, length, options, target) {
11213
+ let message = target ?? this.create(), end = reader.pos + length;
11214
+ while (reader.pos < end) {
11215
+ let [fieldNo, wireType] = reader.tag();
11216
+ switch (fieldNo) {
11217
+ case /* org.dash.platform.dapi.v0.GetShieldedPoolStateRequest.GetShieldedPoolStateRequestV0 v0 */ 1:
11218
+ message.version = {
11219
+ oneofKind: "v0",
11220
+ v0: GetShieldedPoolStateRequest_GetShieldedPoolStateRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
11221
+ };
11222
+ break;
11223
+ default:
11224
+ let u = options.readUnknownField;
11225
+ if (u === "throw")
11226
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11227
+ let d = reader.skip(wireType);
11228
+ if (u !== false)
11229
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11230
+ }
11231
+ }
11232
+ return message;
11233
+ }
11234
+ internalBinaryWrite(message, writer, options) {
11235
+ /* org.dash.platform.dapi.v0.GetShieldedPoolStateRequest.GetShieldedPoolStateRequestV0 v0 = 1; */
11236
+ if (message.version.oneofKind === "v0")
11237
+ GetShieldedPoolStateRequest_GetShieldedPoolStateRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
11238
+ let u = options.writeUnknownFields;
11239
+ if (u !== false)
11240
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11241
+ return writer;
11242
+ }
11243
+ }
11244
+ /**
11245
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedPoolStateRequest
11246
+ */
11247
+ export const GetShieldedPoolStateRequest = new GetShieldedPoolStateRequest$Type();
11248
+ // @generated message type with reflection information, may provide speed optimized methods
11249
+ class GetShieldedPoolStateRequest_GetShieldedPoolStateRequestV0$Type extends MessageType {
11250
+ constructor() {
11251
+ super("org.dash.platform.dapi.v0.GetShieldedPoolStateRequest.GetShieldedPoolStateRequestV0", [
11252
+ { no: 1, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
11253
+ ]);
11254
+ }
11255
+ create(value) {
11256
+ const message = globalThis.Object.create((this.messagePrototype));
11257
+ message.prove = false;
11258
+ if (value !== undefined)
11259
+ reflectionMergePartial(this, message, value);
11260
+ return message;
11261
+ }
11262
+ internalBinaryRead(reader, length, options, target) {
11263
+ let message = target ?? this.create(), end = reader.pos + length;
11264
+ while (reader.pos < end) {
11265
+ let [fieldNo, wireType] = reader.tag();
11266
+ switch (fieldNo) {
11267
+ case /* bool prove */ 1:
11268
+ message.prove = reader.bool();
11269
+ break;
11270
+ default:
11271
+ let u = options.readUnknownField;
11272
+ if (u === "throw")
11273
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11274
+ let d = reader.skip(wireType);
11275
+ if (u !== false)
11276
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11277
+ }
11278
+ }
11279
+ return message;
11280
+ }
11281
+ internalBinaryWrite(message, writer, options) {
11282
+ /* bool prove = 1; */
11283
+ if (message.prove !== false)
11284
+ writer.tag(1, WireType.Varint).bool(message.prove);
11285
+ let u = options.writeUnknownFields;
11286
+ if (u !== false)
11287
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11288
+ return writer;
11289
+ }
11290
+ }
11291
+ /**
11292
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedPoolStateRequest.GetShieldedPoolStateRequestV0
11293
+ */
11294
+ export const GetShieldedPoolStateRequest_GetShieldedPoolStateRequestV0 = new GetShieldedPoolStateRequest_GetShieldedPoolStateRequestV0$Type();
11295
+ // @generated message type with reflection information, may provide speed optimized methods
11296
+ class GetShieldedPoolStateResponse$Type extends MessageType {
11297
+ constructor() {
11298
+ super("org.dash.platform.dapi.v0.GetShieldedPoolStateResponse", [
11299
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedPoolStateResponse_GetShieldedPoolStateResponseV0 }
11300
+ ]);
11301
+ }
11302
+ create(value) {
11303
+ const message = globalThis.Object.create((this.messagePrototype));
11304
+ message.version = { oneofKind: undefined };
11305
+ if (value !== undefined)
11306
+ reflectionMergePartial(this, message, value);
11307
+ return message;
11308
+ }
11309
+ internalBinaryRead(reader, length, options, target) {
11310
+ let message = target ?? this.create(), end = reader.pos + length;
11311
+ while (reader.pos < end) {
11312
+ let [fieldNo, wireType] = reader.tag();
11313
+ switch (fieldNo) {
11314
+ case /* org.dash.platform.dapi.v0.GetShieldedPoolStateResponse.GetShieldedPoolStateResponseV0 v0 */ 1:
11315
+ message.version = {
11316
+ oneofKind: "v0",
11317
+ v0: GetShieldedPoolStateResponse_GetShieldedPoolStateResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
11318
+ };
11319
+ break;
11320
+ default:
11321
+ let u = options.readUnknownField;
11322
+ if (u === "throw")
11323
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11324
+ let d = reader.skip(wireType);
11325
+ if (u !== false)
11326
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11327
+ }
11328
+ }
11329
+ return message;
11330
+ }
11331
+ internalBinaryWrite(message, writer, options) {
11332
+ /* org.dash.platform.dapi.v0.GetShieldedPoolStateResponse.GetShieldedPoolStateResponseV0 v0 = 1; */
11333
+ if (message.version.oneofKind === "v0")
11334
+ GetShieldedPoolStateResponse_GetShieldedPoolStateResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
11335
+ let u = options.writeUnknownFields;
11336
+ if (u !== false)
11337
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11338
+ return writer;
11339
+ }
11340
+ }
11341
+ /**
11342
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedPoolStateResponse
11343
+ */
11344
+ export const GetShieldedPoolStateResponse = new GetShieldedPoolStateResponse$Type();
11345
+ // @generated message type with reflection information, may provide speed optimized methods
11346
+ class GetShieldedPoolStateResponse_GetShieldedPoolStateResponseV0$Type extends MessageType {
11347
+ constructor() {
11348
+ super("org.dash.platform.dapi.v0.GetShieldedPoolStateResponse.GetShieldedPoolStateResponseV0", [
11349
+ { no: 1, name: "total_balance", kind: "scalar", oneof: "result", T: 4 /*ScalarType.UINT64*/ },
11350
+ { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
11351
+ { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
11352
+ ]);
11353
+ }
11354
+ create(value) {
11355
+ const message = globalThis.Object.create((this.messagePrototype));
11356
+ message.result = { oneofKind: undefined };
11357
+ if (value !== undefined)
11358
+ reflectionMergePartial(this, message, value);
11359
+ return message;
11360
+ }
11361
+ internalBinaryRead(reader, length, options, target) {
11362
+ let message = target ?? this.create(), end = reader.pos + length;
11363
+ while (reader.pos < end) {
11364
+ let [fieldNo, wireType] = reader.tag();
11365
+ switch (fieldNo) {
11366
+ case /* uint64 total_balance = 1 [jstype = JS_STRING] */ 1:
11367
+ message.result = {
11368
+ oneofKind: "totalBalance",
11369
+ totalBalance: reader.uint64().toString()
11370
+ };
11371
+ break;
11372
+ case /* org.dash.platform.dapi.v0.Proof proof */ 2:
11373
+ message.result = {
11374
+ oneofKind: "proof",
11375
+ proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
11376
+ };
11377
+ break;
11378
+ case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
11379
+ message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
11380
+ break;
11381
+ default:
11382
+ let u = options.readUnknownField;
11383
+ if (u === "throw")
11384
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11385
+ let d = reader.skip(wireType);
11386
+ if (u !== false)
11387
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11388
+ }
11389
+ }
11390
+ return message;
11391
+ }
11392
+ internalBinaryWrite(message, writer, options) {
11393
+ /* uint64 total_balance = 1 [jstype = JS_STRING]; */
11394
+ if (message.result.oneofKind === "totalBalance")
11395
+ writer.tag(1, WireType.Varint).uint64(message.result.totalBalance);
11396
+ /* org.dash.platform.dapi.v0.Proof proof = 2; */
11397
+ if (message.result.oneofKind === "proof")
11398
+ Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
11399
+ /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
11400
+ if (message.metadata)
11401
+ ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
11402
+ let u = options.writeUnknownFields;
11403
+ if (u !== false)
11404
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11405
+ return writer;
11406
+ }
11407
+ }
11408
+ /**
11409
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedPoolStateResponse.GetShieldedPoolStateResponseV0
11410
+ */
11411
+ export const GetShieldedPoolStateResponse_GetShieldedPoolStateResponseV0 = new GetShieldedPoolStateResponse_GetShieldedPoolStateResponseV0$Type();
11412
+ // @generated message type with reflection information, may provide speed optimized methods
11413
+ class GetShieldedNotesCountRequest$Type extends MessageType {
11414
+ constructor() {
11415
+ super("org.dash.platform.dapi.v0.GetShieldedNotesCountRequest", [
11416
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedNotesCountRequest_GetShieldedNotesCountRequestV0 }
11417
+ ]);
11418
+ }
11419
+ create(value) {
11420
+ const message = globalThis.Object.create((this.messagePrototype));
11421
+ message.version = { oneofKind: undefined };
11422
+ if (value !== undefined)
11423
+ reflectionMergePartial(this, message, value);
11424
+ return message;
11425
+ }
11426
+ internalBinaryRead(reader, length, options, target) {
11427
+ let message = target ?? this.create(), end = reader.pos + length;
11428
+ while (reader.pos < end) {
11429
+ let [fieldNo, wireType] = reader.tag();
11430
+ switch (fieldNo) {
11431
+ case /* org.dash.platform.dapi.v0.GetShieldedNotesCountRequest.GetShieldedNotesCountRequestV0 v0 */ 1:
11432
+ message.version = {
11433
+ oneofKind: "v0",
11434
+ v0: GetShieldedNotesCountRequest_GetShieldedNotesCountRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
11435
+ };
11436
+ break;
11437
+ default:
11438
+ let u = options.readUnknownField;
11439
+ if (u === "throw")
11440
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11441
+ let d = reader.skip(wireType);
11442
+ if (u !== false)
11443
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11444
+ }
11445
+ }
11446
+ return message;
11447
+ }
11448
+ internalBinaryWrite(message, writer, options) {
11449
+ /* org.dash.platform.dapi.v0.GetShieldedNotesCountRequest.GetShieldedNotesCountRequestV0 v0 = 1; */
11450
+ if (message.version.oneofKind === "v0")
11451
+ GetShieldedNotesCountRequest_GetShieldedNotesCountRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
11452
+ let u = options.writeUnknownFields;
11453
+ if (u !== false)
11454
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11455
+ return writer;
11456
+ }
11457
+ }
11458
+ /**
11459
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNotesCountRequest
11460
+ */
11461
+ export const GetShieldedNotesCountRequest = new GetShieldedNotesCountRequest$Type();
11462
+ // @generated message type with reflection information, may provide speed optimized methods
11463
+ class GetShieldedNotesCountRequest_GetShieldedNotesCountRequestV0$Type extends MessageType {
11464
+ constructor() {
11465
+ super("org.dash.platform.dapi.v0.GetShieldedNotesCountRequest.GetShieldedNotesCountRequestV0", [
11466
+ { no: 1, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
11467
+ ]);
11468
+ }
11469
+ create(value) {
11470
+ const message = globalThis.Object.create((this.messagePrototype));
11471
+ message.prove = false;
11472
+ if (value !== undefined)
11473
+ reflectionMergePartial(this, message, value);
11474
+ return message;
11475
+ }
11476
+ internalBinaryRead(reader, length, options, target) {
11477
+ let message = target ?? this.create(), end = reader.pos + length;
11478
+ while (reader.pos < end) {
11479
+ let [fieldNo, wireType] = reader.tag();
11480
+ switch (fieldNo) {
11481
+ case /* bool prove */ 1:
11482
+ message.prove = reader.bool();
11483
+ break;
11484
+ default:
11485
+ let u = options.readUnknownField;
11486
+ if (u === "throw")
11487
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11488
+ let d = reader.skip(wireType);
11489
+ if (u !== false)
11490
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11491
+ }
11492
+ }
11493
+ return message;
11494
+ }
11495
+ internalBinaryWrite(message, writer, options) {
11496
+ /* bool prove = 1; */
11497
+ if (message.prove !== false)
11498
+ writer.tag(1, WireType.Varint).bool(message.prove);
11499
+ let u = options.writeUnknownFields;
11500
+ if (u !== false)
11501
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11502
+ return writer;
11503
+ }
11504
+ }
11505
+ /**
11506
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNotesCountRequest.GetShieldedNotesCountRequestV0
11507
+ */
11508
+ export const GetShieldedNotesCountRequest_GetShieldedNotesCountRequestV0 = new GetShieldedNotesCountRequest_GetShieldedNotesCountRequestV0$Type();
11509
+ // @generated message type with reflection information, may provide speed optimized methods
11510
+ class GetShieldedNotesCountResponse$Type extends MessageType {
11511
+ constructor() {
11512
+ super("org.dash.platform.dapi.v0.GetShieldedNotesCountResponse", [
11513
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedNotesCountResponse_GetShieldedNotesCountResponseV0 }
11514
+ ]);
11515
+ }
11516
+ create(value) {
11517
+ const message = globalThis.Object.create((this.messagePrototype));
11518
+ message.version = { oneofKind: undefined };
11519
+ if (value !== undefined)
11520
+ reflectionMergePartial(this, message, value);
11521
+ return message;
11522
+ }
11523
+ internalBinaryRead(reader, length, options, target) {
11524
+ let message = target ?? this.create(), end = reader.pos + length;
11525
+ while (reader.pos < end) {
11526
+ let [fieldNo, wireType] = reader.tag();
11527
+ switch (fieldNo) {
11528
+ case /* org.dash.platform.dapi.v0.GetShieldedNotesCountResponse.GetShieldedNotesCountResponseV0 v0 */ 1:
11529
+ message.version = {
11530
+ oneofKind: "v0",
11531
+ v0: GetShieldedNotesCountResponse_GetShieldedNotesCountResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
11532
+ };
11533
+ break;
11534
+ default:
11535
+ let u = options.readUnknownField;
11536
+ if (u === "throw")
11537
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11538
+ let d = reader.skip(wireType);
11539
+ if (u !== false)
11540
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11541
+ }
11542
+ }
11543
+ return message;
11544
+ }
11545
+ internalBinaryWrite(message, writer, options) {
11546
+ /* org.dash.platform.dapi.v0.GetShieldedNotesCountResponse.GetShieldedNotesCountResponseV0 v0 = 1; */
11547
+ if (message.version.oneofKind === "v0")
11548
+ GetShieldedNotesCountResponse_GetShieldedNotesCountResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
11549
+ let u = options.writeUnknownFields;
11550
+ if (u !== false)
11551
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11552
+ return writer;
11553
+ }
11554
+ }
11555
+ /**
11556
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNotesCountResponse
11557
+ */
11558
+ export const GetShieldedNotesCountResponse = new GetShieldedNotesCountResponse$Type();
11559
+ // @generated message type with reflection information, may provide speed optimized methods
11560
+ class GetShieldedNotesCountResponse_GetShieldedNotesCountResponseV0$Type extends MessageType {
11561
+ constructor() {
11562
+ super("org.dash.platform.dapi.v0.GetShieldedNotesCountResponse.GetShieldedNotesCountResponseV0", [
11563
+ { no: 1, name: "total_notes_count", kind: "scalar", oneof: "result", T: 4 /*ScalarType.UINT64*/ },
11564
+ { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
11565
+ { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
11566
+ ]);
11567
+ }
11568
+ create(value) {
11569
+ const message = globalThis.Object.create((this.messagePrototype));
11570
+ message.result = { oneofKind: undefined };
11571
+ if (value !== undefined)
11572
+ reflectionMergePartial(this, message, value);
11573
+ return message;
11574
+ }
11575
+ internalBinaryRead(reader, length, options, target) {
11576
+ let message = target ?? this.create(), end = reader.pos + length;
11577
+ while (reader.pos < end) {
11578
+ let [fieldNo, wireType] = reader.tag();
11579
+ switch (fieldNo) {
11580
+ case /* uint64 total_notes_count = 1 [jstype = JS_STRING] */ 1:
11581
+ message.result = {
11582
+ oneofKind: "totalNotesCount",
11583
+ totalNotesCount: reader.uint64().toString()
11584
+ };
11585
+ break;
11586
+ case /* org.dash.platform.dapi.v0.Proof proof */ 2:
11587
+ message.result = {
11588
+ oneofKind: "proof",
11589
+ proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
11590
+ };
11591
+ break;
11592
+ case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
11593
+ message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
11594
+ break;
11595
+ default:
11596
+ let u = options.readUnknownField;
11597
+ if (u === "throw")
11598
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11599
+ let d = reader.skip(wireType);
11600
+ if (u !== false)
11601
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11602
+ }
11603
+ }
11604
+ return message;
11605
+ }
11606
+ internalBinaryWrite(message, writer, options) {
11607
+ /* uint64 total_notes_count = 1 [jstype = JS_STRING]; */
11608
+ if (message.result.oneofKind === "totalNotesCount")
11609
+ writer.tag(1, WireType.Varint).uint64(message.result.totalNotesCount);
11610
+ /* org.dash.platform.dapi.v0.Proof proof = 2; */
11611
+ if (message.result.oneofKind === "proof")
11612
+ Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
11613
+ /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
11614
+ if (message.metadata)
11615
+ ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
11616
+ let u = options.writeUnknownFields;
11617
+ if (u !== false)
11618
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11619
+ return writer;
11620
+ }
11621
+ }
11622
+ /**
11623
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNotesCountResponse.GetShieldedNotesCountResponseV0
11624
+ */
11625
+ export const GetShieldedNotesCountResponse_GetShieldedNotesCountResponseV0 = new GetShieldedNotesCountResponse_GetShieldedNotesCountResponseV0$Type();
11626
+ // @generated message type with reflection information, may provide speed optimized methods
11627
+ class GetShieldedNullifiersRequest$Type extends MessageType {
11628
+ constructor() {
11629
+ super("org.dash.platform.dapi.v0.GetShieldedNullifiersRequest", [
11630
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedNullifiersRequest_GetShieldedNullifiersRequestV0 }
11631
+ ]);
11632
+ }
11633
+ create(value) {
11634
+ const message = globalThis.Object.create((this.messagePrototype));
11635
+ message.version = { oneofKind: undefined };
11636
+ if (value !== undefined)
11637
+ reflectionMergePartial(this, message, value);
11638
+ return message;
11639
+ }
11640
+ internalBinaryRead(reader, length, options, target) {
11641
+ let message = target ?? this.create(), end = reader.pos + length;
11642
+ while (reader.pos < end) {
11643
+ let [fieldNo, wireType] = reader.tag();
11644
+ switch (fieldNo) {
11645
+ case /* org.dash.platform.dapi.v0.GetShieldedNullifiersRequest.GetShieldedNullifiersRequestV0 v0 */ 1:
11646
+ message.version = {
11647
+ oneofKind: "v0",
11648
+ v0: GetShieldedNullifiersRequest_GetShieldedNullifiersRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
11649
+ };
11650
+ break;
11651
+ default:
11652
+ let u = options.readUnknownField;
11653
+ if (u === "throw")
11654
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11655
+ let d = reader.skip(wireType);
11656
+ if (u !== false)
11657
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11658
+ }
11659
+ }
11660
+ return message;
11661
+ }
11662
+ internalBinaryWrite(message, writer, options) {
11663
+ /* org.dash.platform.dapi.v0.GetShieldedNullifiersRequest.GetShieldedNullifiersRequestV0 v0 = 1; */
11664
+ if (message.version.oneofKind === "v0")
11665
+ GetShieldedNullifiersRequest_GetShieldedNullifiersRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
11666
+ let u = options.writeUnknownFields;
11667
+ if (u !== false)
11668
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11669
+ return writer;
11670
+ }
11671
+ }
11672
+ /**
11673
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNullifiersRequest
11674
+ */
11675
+ export const GetShieldedNullifiersRequest = new GetShieldedNullifiersRequest$Type();
11676
+ // @generated message type with reflection information, may provide speed optimized methods
11677
+ class GetShieldedNullifiersRequest_GetShieldedNullifiersRequestV0$Type extends MessageType {
11678
+ constructor() {
11679
+ super("org.dash.platform.dapi.v0.GetShieldedNullifiersRequest.GetShieldedNullifiersRequestV0", [
11680
+ { no: 1, name: "nullifiers", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 12 /*ScalarType.BYTES*/ },
11681
+ { no: 2, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
11682
+ ]);
11683
+ }
11684
+ create(value) {
11685
+ const message = globalThis.Object.create((this.messagePrototype));
11686
+ message.nullifiers = [];
11687
+ message.prove = false;
11688
+ if (value !== undefined)
11689
+ reflectionMergePartial(this, message, value);
11690
+ return message;
11691
+ }
11692
+ internalBinaryRead(reader, length, options, target) {
11693
+ let message = target ?? this.create(), end = reader.pos + length;
11694
+ while (reader.pos < end) {
11695
+ let [fieldNo, wireType] = reader.tag();
11696
+ switch (fieldNo) {
11697
+ case /* repeated bytes nullifiers */ 1:
11698
+ message.nullifiers.push(reader.bytes());
11699
+ break;
11700
+ case /* bool prove */ 2:
11701
+ message.prove = reader.bool();
11702
+ break;
11703
+ default:
11704
+ let u = options.readUnknownField;
11705
+ if (u === "throw")
11706
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11707
+ let d = reader.skip(wireType);
11708
+ if (u !== false)
11709
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11710
+ }
11711
+ }
11712
+ return message;
11713
+ }
11714
+ internalBinaryWrite(message, writer, options) {
11715
+ /* repeated bytes nullifiers = 1; */
11716
+ for (let i = 0; i < message.nullifiers.length; i++)
11717
+ writer.tag(1, WireType.LengthDelimited).bytes(message.nullifiers[i]);
11718
+ /* bool prove = 2; */
11719
+ if (message.prove !== false)
11720
+ writer.tag(2, WireType.Varint).bool(message.prove);
11721
+ let u = options.writeUnknownFields;
11722
+ if (u !== false)
11723
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11724
+ return writer;
11725
+ }
11726
+ }
11727
+ /**
11728
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNullifiersRequest.GetShieldedNullifiersRequestV0
11729
+ */
11730
+ export const GetShieldedNullifiersRequest_GetShieldedNullifiersRequestV0 = new GetShieldedNullifiersRequest_GetShieldedNullifiersRequestV0$Type();
11731
+ // @generated message type with reflection information, may provide speed optimized methods
11732
+ class GetShieldedNullifiersResponse$Type extends MessageType {
11733
+ constructor() {
11734
+ super("org.dash.platform.dapi.v0.GetShieldedNullifiersResponse", [
11735
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0 }
11736
+ ]);
11737
+ }
11738
+ create(value) {
11739
+ const message = globalThis.Object.create((this.messagePrototype));
11740
+ message.version = { oneofKind: undefined };
11741
+ if (value !== undefined)
11742
+ reflectionMergePartial(this, message, value);
11743
+ return message;
11744
+ }
11745
+ internalBinaryRead(reader, length, options, target) {
11746
+ let message = target ?? this.create(), end = reader.pos + length;
11747
+ while (reader.pos < end) {
11748
+ let [fieldNo, wireType] = reader.tag();
11749
+ switch (fieldNo) {
11750
+ case /* org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0 v0 */ 1:
11751
+ message.version = {
11752
+ oneofKind: "v0",
11753
+ v0: GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
11754
+ };
11755
+ break;
11756
+ default:
11757
+ let u = options.readUnknownField;
11758
+ if (u === "throw")
11759
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11760
+ let d = reader.skip(wireType);
11761
+ if (u !== false)
11762
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11763
+ }
11764
+ }
11765
+ return message;
11766
+ }
11767
+ internalBinaryWrite(message, writer, options) {
11768
+ /* org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0 v0 = 1; */
11769
+ if (message.version.oneofKind === "v0")
11770
+ GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
11771
+ let u = options.writeUnknownFields;
11772
+ if (u !== false)
11773
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11774
+ return writer;
11775
+ }
11776
+ }
11777
+ /**
11778
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNullifiersResponse
11779
+ */
11780
+ export const GetShieldedNullifiersResponse = new GetShieldedNullifiersResponse$Type();
11781
+ // @generated message type with reflection information, may provide speed optimized methods
11782
+ class GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0$Type extends MessageType {
11783
+ constructor() {
11784
+ super("org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0", [
11785
+ { no: 1, name: "nullifier_statuses", kind: "message", oneof: "result", T: () => GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatuses },
11786
+ { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
11787
+ { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
11788
+ ]);
11789
+ }
11790
+ create(value) {
11791
+ const message = globalThis.Object.create((this.messagePrototype));
11792
+ message.result = { oneofKind: undefined };
11793
+ if (value !== undefined)
11794
+ reflectionMergePartial(this, message, value);
11795
+ return message;
11796
+ }
11797
+ internalBinaryRead(reader, length, options, target) {
11798
+ let message = target ?? this.create(), end = reader.pos + length;
11799
+ while (reader.pos < end) {
11800
+ let [fieldNo, wireType] = reader.tag();
11801
+ switch (fieldNo) {
11802
+ case /* org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatuses nullifier_statuses */ 1:
11803
+ message.result = {
11804
+ oneofKind: "nullifierStatuses",
11805
+ nullifierStatuses: GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatuses.internalBinaryRead(reader, reader.uint32(), options, message.result.nullifierStatuses)
11806
+ };
11807
+ break;
11808
+ case /* org.dash.platform.dapi.v0.Proof proof */ 2:
11809
+ message.result = {
11810
+ oneofKind: "proof",
11811
+ proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
11812
+ };
11813
+ break;
11814
+ case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
11815
+ message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
11816
+ break;
11817
+ default:
11818
+ let u = options.readUnknownField;
11819
+ if (u === "throw")
11820
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11821
+ let d = reader.skip(wireType);
11822
+ if (u !== false)
11823
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11824
+ }
11825
+ }
11826
+ return message;
11827
+ }
11828
+ internalBinaryWrite(message, writer, options) {
11829
+ /* org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatuses nullifier_statuses = 1; */
11830
+ if (message.result.oneofKind === "nullifierStatuses")
11831
+ GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatuses.internalBinaryWrite(message.result.nullifierStatuses, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
11832
+ /* org.dash.platform.dapi.v0.Proof proof = 2; */
11833
+ if (message.result.oneofKind === "proof")
11834
+ Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
11835
+ /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
11836
+ if (message.metadata)
11837
+ ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
11838
+ let u = options.writeUnknownFields;
11839
+ if (u !== false)
11840
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11841
+ return writer;
11842
+ }
11843
+ }
11844
+ /**
11845
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0
11846
+ */
11847
+ export const GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0 = new GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0$Type();
11848
+ // @generated message type with reflection information, may provide speed optimized methods
11849
+ class GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatus$Type extends MessageType {
11850
+ constructor() {
11851
+ super("org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatus", [
11852
+ { no: 1, name: "nullifier", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
11853
+ { no: 2, name: "is_spent", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
11854
+ ]);
11855
+ }
11856
+ create(value) {
11857
+ const message = globalThis.Object.create((this.messagePrototype));
11858
+ message.nullifier = new Uint8Array(0);
11859
+ message.isSpent = false;
11860
+ if (value !== undefined)
11861
+ reflectionMergePartial(this, message, value);
11862
+ return message;
11863
+ }
11864
+ internalBinaryRead(reader, length, options, target) {
11865
+ let message = target ?? this.create(), end = reader.pos + length;
11866
+ while (reader.pos < end) {
11867
+ let [fieldNo, wireType] = reader.tag();
11868
+ switch (fieldNo) {
11869
+ case /* bytes nullifier */ 1:
11870
+ message.nullifier = reader.bytes();
11871
+ break;
11872
+ case /* bool is_spent */ 2:
11873
+ message.isSpent = reader.bool();
11874
+ break;
11875
+ default:
11876
+ let u = options.readUnknownField;
11877
+ if (u === "throw")
11878
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11879
+ let d = reader.skip(wireType);
11880
+ if (u !== false)
11881
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11882
+ }
11883
+ }
11884
+ return message;
11885
+ }
11886
+ internalBinaryWrite(message, writer, options) {
11887
+ /* bytes nullifier = 1; */
11888
+ if (message.nullifier.length)
11889
+ writer.tag(1, WireType.LengthDelimited).bytes(message.nullifier);
11890
+ /* bool is_spent = 2; */
11891
+ if (message.isSpent !== false)
11892
+ writer.tag(2, WireType.Varint).bool(message.isSpent);
11893
+ let u = options.writeUnknownFields;
11894
+ if (u !== false)
11895
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11896
+ return writer;
11897
+ }
11898
+ }
11899
+ /**
11900
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatus
11901
+ */
11902
+ export const GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatus = new GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatus$Type();
11903
+ // @generated message type with reflection information, may provide speed optimized methods
11904
+ class GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatuses$Type extends MessageType {
11905
+ constructor() {
11906
+ super("org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatuses", [
11907
+ { no: 1, name: "entries", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatus }
11908
+ ]);
11909
+ }
11910
+ create(value) {
11911
+ const message = globalThis.Object.create((this.messagePrototype));
11912
+ message.entries = [];
11913
+ if (value !== undefined)
11914
+ reflectionMergePartial(this, message, value);
11915
+ return message;
11916
+ }
11917
+ internalBinaryRead(reader, length, options, target) {
11918
+ let message = target ?? this.create(), end = reader.pos + length;
11919
+ while (reader.pos < end) {
11920
+ let [fieldNo, wireType] = reader.tag();
11921
+ switch (fieldNo) {
11922
+ case /* repeated org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatus entries */ 1:
11923
+ message.entries.push(GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatus.internalBinaryRead(reader, reader.uint32(), options));
11924
+ break;
11925
+ default:
11926
+ let u = options.readUnknownField;
11927
+ if (u === "throw")
11928
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11929
+ let d = reader.skip(wireType);
11930
+ if (u !== false)
11931
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11932
+ }
11933
+ }
11934
+ return message;
11935
+ }
11936
+ internalBinaryWrite(message, writer, options) {
11937
+ /* repeated org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatus entries = 1; */
11938
+ for (let i = 0; i < message.entries.length; i++)
11939
+ GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatus.internalBinaryWrite(message.entries[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
11940
+ let u = options.writeUnknownFields;
11941
+ if (u !== false)
11942
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11943
+ return writer;
11944
+ }
11945
+ }
11946
+ /**
11947
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatuses
11948
+ */
11949
+ export const GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatuses = new GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatuses$Type();
11950
+ // @generated message type with reflection information, may provide speed optimized methods
11951
+ class GetFinalizedEpochInfosRequest$Type extends MessageType {
11952
+ constructor() {
11953
+ super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosRequest", [
11954
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetFinalizedEpochInfosRequest_GetFinalizedEpochInfosRequestV0 }
11955
+ ]);
11956
+ }
11957
+ create(value) {
11958
+ const message = globalThis.Object.create((this.messagePrototype));
11959
+ message.version = { oneofKind: undefined };
11960
+ if (value !== undefined)
11961
+ reflectionMergePartial(this, message, value);
11962
+ return message;
11963
+ }
11964
+ internalBinaryRead(reader, length, options, target) {
11965
+ let message = target ?? this.create(), end = reader.pos + length;
11966
+ while (reader.pos < end) {
11967
+ let [fieldNo, wireType] = reader.tag();
11968
+ switch (fieldNo) {
11969
+ case /* org.dash.platform.dapi.v0.GetFinalizedEpochInfosRequest.GetFinalizedEpochInfosRequestV0 v0 */ 1:
11970
+ message.version = {
11971
+ oneofKind: "v0",
11972
+ v0: GetFinalizedEpochInfosRequest_GetFinalizedEpochInfosRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
11973
+ };
11974
+ break;
11975
+ default:
11976
+ let u = options.readUnknownField;
11977
+ if (u === "throw")
11978
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
11979
+ let d = reader.skip(wireType);
11980
+ if (u !== false)
11981
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
11982
+ }
11983
+ }
11984
+ return message;
11985
+ }
11986
+ internalBinaryWrite(message, writer, options) {
11987
+ /* org.dash.platform.dapi.v0.GetFinalizedEpochInfosRequest.GetFinalizedEpochInfosRequestV0 v0 = 1; */
11988
+ if (message.version.oneofKind === "v0")
11989
+ GetFinalizedEpochInfosRequest_GetFinalizedEpochInfosRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
11990
+ let u = options.writeUnknownFields;
11991
+ if (u !== false)
11992
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
11993
+ return writer;
11994
+ }
11995
+ }
11996
+ /**
11997
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetFinalizedEpochInfosRequest
11998
+ */
11999
+ export const GetFinalizedEpochInfosRequest = new GetFinalizedEpochInfosRequest$Type();
12000
+ // @generated message type with reflection information, may provide speed optimized methods
12001
+ class GetFinalizedEpochInfosRequest_GetFinalizedEpochInfosRequestV0$Type extends MessageType {
12002
+ constructor() {
12003
+ super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosRequest.GetFinalizedEpochInfosRequestV0", [
12004
+ { no: 1, name: "start_epoch_index", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
12005
+ { no: 2, name: "start_epoch_index_included", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
12006
+ { no: 3, name: "end_epoch_index", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
12007
+ { no: 4, name: "end_epoch_index_included", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
12008
+ { no: 5, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
12009
+ ]);
12010
+ }
12011
+ create(value) {
12012
+ const message = globalThis.Object.create((this.messagePrototype));
12013
+ message.startEpochIndex = 0;
12014
+ message.startEpochIndexIncluded = false;
12015
+ message.endEpochIndex = 0;
12016
+ message.endEpochIndexIncluded = false;
12017
+ message.prove = false;
12018
+ if (value !== undefined)
12019
+ reflectionMergePartial(this, message, value);
12020
+ return message;
12021
+ }
12022
+ internalBinaryRead(reader, length, options, target) {
12023
+ let message = target ?? this.create(), end = reader.pos + length;
12024
+ while (reader.pos < end) {
12025
+ let [fieldNo, wireType] = reader.tag();
12026
+ switch (fieldNo) {
12027
+ case /* uint32 start_epoch_index */ 1:
12028
+ message.startEpochIndex = reader.uint32();
12029
+ break;
12030
+ case /* bool start_epoch_index_included */ 2:
12031
+ message.startEpochIndexIncluded = reader.bool();
12032
+ break;
12033
+ case /* uint32 end_epoch_index */ 3:
12034
+ message.endEpochIndex = reader.uint32();
12035
+ break;
12036
+ case /* bool end_epoch_index_included */ 4:
12037
+ message.endEpochIndexIncluded = reader.bool();
12038
+ break;
12039
+ case /* bool prove */ 5:
12040
+ message.prove = reader.bool();
12041
+ break;
12042
+ default:
12043
+ let u = options.readUnknownField;
12044
+ if (u === "throw")
12045
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
12046
+ let d = reader.skip(wireType);
12047
+ if (u !== false)
12048
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
12049
+ }
12050
+ }
12051
+ return message;
12052
+ }
12053
+ internalBinaryWrite(message, writer, options) {
12054
+ /* uint32 start_epoch_index = 1; */
12055
+ if (message.startEpochIndex !== 0)
12056
+ writer.tag(1, WireType.Varint).uint32(message.startEpochIndex);
12057
+ /* bool start_epoch_index_included = 2; */
12058
+ if (message.startEpochIndexIncluded !== false)
12059
+ writer.tag(2, WireType.Varint).bool(message.startEpochIndexIncluded);
12060
+ /* uint32 end_epoch_index = 3; */
12061
+ if (message.endEpochIndex !== 0)
12062
+ writer.tag(3, WireType.Varint).uint32(message.endEpochIndex);
12063
+ /* bool end_epoch_index_included = 4; */
12064
+ if (message.endEpochIndexIncluded !== false)
12065
+ writer.tag(4, WireType.Varint).bool(message.endEpochIndexIncluded);
12066
+ /* bool prove = 5; */
12067
+ if (message.prove !== false)
12068
+ writer.tag(5, WireType.Varint).bool(message.prove);
12069
+ let u = options.writeUnknownFields;
12070
+ if (u !== false)
12071
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
12072
+ return writer;
12073
+ }
12074
+ }
12075
+ /**
12076
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetFinalizedEpochInfosRequest.GetFinalizedEpochInfosRequestV0
12077
+ */
12078
+ export const GetFinalizedEpochInfosRequest_GetFinalizedEpochInfosRequestV0 = new GetFinalizedEpochInfosRequest_GetFinalizedEpochInfosRequestV0$Type();
12079
+ // @generated message type with reflection information, may provide speed optimized methods
12080
+ class GetFinalizedEpochInfosResponse$Type extends MessageType {
12081
+ constructor() {
12082
+ super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse", [
12083
+ { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0 }
12084
+ ]);
12085
+ }
12086
+ create(value) {
12087
+ const message = globalThis.Object.create((this.messagePrototype));
12088
+ message.version = { oneofKind: undefined };
12089
+ if (value !== undefined)
12090
+ reflectionMergePartial(this, message, value);
12091
+ return message;
12092
+ }
12093
+ internalBinaryRead(reader, length, options, target) {
12094
+ let message = target ?? this.create(), end = reader.pos + length;
12095
+ while (reader.pos < end) {
12096
+ let [fieldNo, wireType] = reader.tag();
12097
+ switch (fieldNo) {
12098
+ case /* org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0 v0 */ 1:
12099
+ message.version = {
12100
+ oneofKind: "v0",
12101
+ v0: GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
12102
+ };
12103
+ break;
12104
+ default:
12105
+ let u = options.readUnknownField;
12106
+ if (u === "throw")
12107
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
12108
+ let d = reader.skip(wireType);
12109
+ if (u !== false)
12110
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
12111
+ }
12112
+ }
12113
+ return message;
12114
+ }
12115
+ internalBinaryWrite(message, writer, options) {
12116
+ /* org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0 v0 = 1; */
12117
+ if (message.version.oneofKind === "v0")
12118
+ GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
12119
+ let u = options.writeUnknownFields;
12120
+ if (u !== false)
12121
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
12122
+ return writer;
12123
+ }
12124
+ }
12125
+ /**
12126
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse
12127
+ */
12128
+ export const GetFinalizedEpochInfosResponse = new GetFinalizedEpochInfosResponse$Type();
12129
+ // @generated message type with reflection information, may provide speed optimized methods
12130
+ class GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0$Type extends MessageType {
12131
+ constructor() {
12132
+ super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0", [
12133
+ { no: 1, name: "epochs", kind: "message", oneof: "result", T: () => GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfos },
12134
+ { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
12135
+ { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
12136
+ ]);
12137
+ }
12138
+ create(value) {
12139
+ const message = globalThis.Object.create((this.messagePrototype));
12140
+ message.result = { oneofKind: undefined };
12141
+ if (value !== undefined)
12142
+ reflectionMergePartial(this, message, value);
12143
+ return message;
12144
+ }
12145
+ internalBinaryRead(reader, length, options, target) {
12146
+ let message = target ?? this.create(), end = reader.pos + length;
12147
+ while (reader.pos < end) {
12148
+ let [fieldNo, wireType] = reader.tag();
12149
+ switch (fieldNo) {
12150
+ case /* org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfos epochs */ 1:
12151
+ message.result = {
12152
+ oneofKind: "epochs",
12153
+ epochs: GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfos.internalBinaryRead(reader, reader.uint32(), options, message.result.epochs)
12154
+ };
12155
+ break;
12156
+ case /* org.dash.platform.dapi.v0.Proof proof */ 2:
12157
+ message.result = {
12158
+ oneofKind: "proof",
12159
+ proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
12160
+ };
12161
+ break;
12162
+ case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
12163
+ message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
12164
+ break;
12165
+ default:
12166
+ let u = options.readUnknownField;
12167
+ if (u === "throw")
12168
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
12169
+ let d = reader.skip(wireType);
12170
+ if (u !== false)
12171
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
12172
+ }
12173
+ }
12174
+ return message;
12175
+ }
12176
+ internalBinaryWrite(message, writer, options) {
12177
+ /* org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfos epochs = 1; */
12178
+ if (message.result.oneofKind === "epochs")
12179
+ GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfos.internalBinaryWrite(message.result.epochs, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
12180
+ /* org.dash.platform.dapi.v0.Proof proof = 2; */
12181
+ if (message.result.oneofKind === "proof")
12182
+ Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
12183
+ /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
12184
+ if (message.metadata)
12185
+ ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
12186
+ let u = options.writeUnknownFields;
12187
+ if (u !== false)
12188
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
12189
+ return writer;
12190
+ }
12191
+ }
12192
+ /**
12193
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0
12194
+ */
12195
+ export const GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0 = new GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0$Type();
12196
+ // @generated message type with reflection information, may provide speed optimized methods
12197
+ class GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfos$Type extends MessageType {
12198
+ constructor() {
12199
+ super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfos", [
12200
+ { no: 1, name: "finalized_epoch_infos", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfo }
12201
+ ]);
12202
+ }
12203
+ create(value) {
12204
+ const message = globalThis.Object.create((this.messagePrototype));
12205
+ message.finalizedEpochInfos = [];
12206
+ if (value !== undefined)
12207
+ reflectionMergePartial(this, message, value);
12208
+ return message;
12209
+ }
12210
+ internalBinaryRead(reader, length, options, target) {
12211
+ let message = target ?? this.create(), end = reader.pos + length;
12212
+ while (reader.pos < end) {
12213
+ let [fieldNo, wireType] = reader.tag();
12214
+ switch (fieldNo) {
12215
+ case /* repeated org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfo finalized_epoch_infos */ 1:
12216
+ message.finalizedEpochInfos.push(GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfo.internalBinaryRead(reader, reader.uint32(), options));
12217
+ break;
12218
+ default:
12219
+ let u = options.readUnknownField;
12220
+ if (u === "throw")
12221
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
12222
+ let d = reader.skip(wireType);
12223
+ if (u !== false)
12224
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
12225
+ }
12226
+ }
12227
+ return message;
12228
+ }
12229
+ internalBinaryWrite(message, writer, options) {
12230
+ /* repeated org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfo finalized_epoch_infos = 1; */
12231
+ for (let i = 0; i < message.finalizedEpochInfos.length; i++)
12232
+ GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfo.internalBinaryWrite(message.finalizedEpochInfos[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
12233
+ let u = options.writeUnknownFields;
12234
+ if (u !== false)
12235
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
12236
+ return writer;
12237
+ }
12238
+ }
12239
+ /**
12240
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfos
12241
+ */
12242
+ export const GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfos = new GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfos$Type();
12243
+ // @generated message type with reflection information, may provide speed optimized methods
12244
+ class GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfo$Type extends MessageType {
12245
+ constructor() {
12246
+ super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfo", [
12247
+ { no: 1, name: "number", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
12248
+ { no: 2, name: "first_block_height", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
12249
+ { no: 3, name: "first_core_block_height", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
12250
+ { no: 4, name: "first_block_time", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
12251
+ { no: 5, name: "fee_multiplier", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
12252
+ { no: 6, name: "protocol_version", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
12253
+ { no: 7, name: "total_blocks_in_epoch", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
12254
+ { no: 8, name: "next_epoch_start_core_block_height", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
12255
+ { no: 9, name: "total_processing_fees", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
12256
+ { no: 10, name: "total_distributed_storage_fees", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
12257
+ { no: 11, name: "total_created_storage_fees", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
12258
+ { no: 12, name: "core_block_rewards", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
12259
+ { no: 13, name: "block_proposers", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_BlockProposer }
12260
+ ]);
12261
+ }
12262
+ create(value) {
12263
+ const message = globalThis.Object.create((this.messagePrototype));
12264
+ message.number = 0;
12265
+ message.firstBlockHeight = "0";
12266
+ message.firstCoreBlockHeight = 0;
12267
+ message.firstBlockTime = "0";
12268
+ message.feeMultiplier = 0;
12269
+ message.protocolVersion = 0;
12270
+ message.totalBlocksInEpoch = "0";
12271
+ message.nextEpochStartCoreBlockHeight = 0;
12272
+ message.totalProcessingFees = "0";
12273
+ message.totalDistributedStorageFees = "0";
12274
+ message.totalCreatedStorageFees = "0";
12275
+ message.coreBlockRewards = "0";
12276
+ message.blockProposers = [];
12277
+ if (value !== undefined)
12278
+ reflectionMergePartial(this, message, value);
12279
+ return message;
12280
+ }
12281
+ internalBinaryRead(reader, length, options, target) {
12282
+ let message = target ?? this.create(), end = reader.pos + length;
12283
+ while (reader.pos < end) {
12284
+ let [fieldNo, wireType] = reader.tag();
12285
+ switch (fieldNo) {
12286
+ case /* uint32 number */ 1:
12287
+ message.number = reader.uint32();
12288
+ break;
12289
+ case /* uint64 first_block_height = 2 [jstype = JS_STRING] */ 2:
12290
+ message.firstBlockHeight = reader.uint64().toString();
12291
+ break;
12292
+ case /* uint32 first_core_block_height */ 3:
12293
+ message.firstCoreBlockHeight = reader.uint32();
12294
+ break;
12295
+ case /* uint64 first_block_time = 4 [jstype = JS_STRING] */ 4:
12296
+ message.firstBlockTime = reader.uint64().toString();
12297
+ break;
12298
+ case /* double fee_multiplier */ 5:
12299
+ message.feeMultiplier = reader.double();
12300
+ break;
12301
+ case /* uint32 protocol_version */ 6:
12302
+ message.protocolVersion = reader.uint32();
12303
+ break;
12304
+ case /* uint64 total_blocks_in_epoch = 7 [jstype = JS_STRING] */ 7:
12305
+ message.totalBlocksInEpoch = reader.uint64().toString();
12306
+ break;
12307
+ case /* uint32 next_epoch_start_core_block_height */ 8:
12308
+ message.nextEpochStartCoreBlockHeight = reader.uint32();
12309
+ break;
12310
+ case /* uint64 total_processing_fees = 9 [jstype = JS_STRING] */ 9:
12311
+ message.totalProcessingFees = reader.uint64().toString();
12312
+ break;
12313
+ case /* uint64 total_distributed_storage_fees = 10 [jstype = JS_STRING] */ 10:
12314
+ message.totalDistributedStorageFees = reader.uint64().toString();
12315
+ break;
12316
+ case /* uint64 total_created_storage_fees = 11 [jstype = JS_STRING] */ 11:
12317
+ message.totalCreatedStorageFees = reader.uint64().toString();
12318
+ break;
12319
+ case /* uint64 core_block_rewards = 12 [jstype = JS_STRING] */ 12:
12320
+ message.coreBlockRewards = reader.uint64().toString();
12321
+ break;
12322
+ case /* repeated org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.BlockProposer block_proposers */ 13:
12323
+ message.blockProposers.push(GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_BlockProposer.internalBinaryRead(reader, reader.uint32(), options));
12324
+ break;
12325
+ default:
12326
+ let u = options.readUnknownField;
12327
+ if (u === "throw")
12328
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
12329
+ let d = reader.skip(wireType);
12330
+ if (u !== false)
12331
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
12332
+ }
12333
+ }
12334
+ return message;
12335
+ }
12336
+ internalBinaryWrite(message, writer, options) {
12337
+ /* uint32 number = 1; */
12338
+ if (message.number !== 0)
12339
+ writer.tag(1, WireType.Varint).uint32(message.number);
12340
+ /* uint64 first_block_height = 2 [jstype = JS_STRING]; */
12341
+ if (message.firstBlockHeight !== "0")
12342
+ writer.tag(2, WireType.Varint).uint64(message.firstBlockHeight);
12343
+ /* uint32 first_core_block_height = 3; */
12344
+ if (message.firstCoreBlockHeight !== 0)
12345
+ writer.tag(3, WireType.Varint).uint32(message.firstCoreBlockHeight);
12346
+ /* uint64 first_block_time = 4 [jstype = JS_STRING]; */
12347
+ if (message.firstBlockTime !== "0")
12348
+ writer.tag(4, WireType.Varint).uint64(message.firstBlockTime);
12349
+ /* double fee_multiplier = 5; */
12350
+ if (message.feeMultiplier !== 0)
12351
+ writer.tag(5, WireType.Bit64).double(message.feeMultiplier);
12352
+ /* uint32 protocol_version = 6; */
12353
+ if (message.protocolVersion !== 0)
12354
+ writer.tag(6, WireType.Varint).uint32(message.protocolVersion);
12355
+ /* uint64 total_blocks_in_epoch = 7 [jstype = JS_STRING]; */
12356
+ if (message.totalBlocksInEpoch !== "0")
12357
+ writer.tag(7, WireType.Varint).uint64(message.totalBlocksInEpoch);
12358
+ /* uint32 next_epoch_start_core_block_height = 8; */
12359
+ if (message.nextEpochStartCoreBlockHeight !== 0)
12360
+ writer.tag(8, WireType.Varint).uint32(message.nextEpochStartCoreBlockHeight);
12361
+ /* uint64 total_processing_fees = 9 [jstype = JS_STRING]; */
12362
+ if (message.totalProcessingFees !== "0")
12363
+ writer.tag(9, WireType.Varint).uint64(message.totalProcessingFees);
12364
+ /* uint64 total_distributed_storage_fees = 10 [jstype = JS_STRING]; */
12365
+ if (message.totalDistributedStorageFees !== "0")
12366
+ writer.tag(10, WireType.Varint).uint64(message.totalDistributedStorageFees);
12367
+ /* uint64 total_created_storage_fees = 11 [jstype = JS_STRING]; */
12368
+ if (message.totalCreatedStorageFees !== "0")
12369
+ writer.tag(11, WireType.Varint).uint64(message.totalCreatedStorageFees);
12370
+ /* uint64 core_block_rewards = 12 [jstype = JS_STRING]; */
12371
+ if (message.coreBlockRewards !== "0")
12372
+ writer.tag(12, WireType.Varint).uint64(message.coreBlockRewards);
12373
+ /* repeated org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.BlockProposer block_proposers = 13; */
12374
+ for (let i = 0; i < message.blockProposers.length; i++)
12375
+ GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_BlockProposer.internalBinaryWrite(message.blockProposers[i], writer.tag(13, WireType.LengthDelimited).fork(), options).join();
12376
+ let u = options.writeUnknownFields;
12377
+ if (u !== false)
12378
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
12379
+ return writer;
12380
+ }
12381
+ }
12382
+ /**
12383
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfo
12384
+ */
12385
+ export const GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfo = new GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfo$Type();
12386
+ // @generated message type with reflection information, may provide speed optimized methods
12387
+ class GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_BlockProposer$Type extends MessageType {
12388
+ constructor() {
12389
+ super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.BlockProposer", [
12390
+ { no: 1, name: "proposer_id", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
12391
+ { no: 2, name: "block_count", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
12392
+ ]);
12393
+ }
12394
+ create(value) {
12395
+ const message = globalThis.Object.create((this.messagePrototype));
12396
+ message.proposerId = new Uint8Array(0);
12397
+ message.blockCount = 0;
12398
+ if (value !== undefined)
12399
+ reflectionMergePartial(this, message, value);
12400
+ return message;
12401
+ }
12402
+ internalBinaryRead(reader, length, options, target) {
12403
+ let message = target ?? this.create(), end = reader.pos + length;
12404
+ while (reader.pos < end) {
12405
+ let [fieldNo, wireType] = reader.tag();
12406
+ switch (fieldNo) {
12407
+ case /* bytes proposer_id */ 1:
12408
+ message.proposerId = reader.bytes();
12409
+ break;
12410
+ case /* uint32 block_count */ 2:
12411
+ message.blockCount = reader.uint32();
12412
+ break;
12413
+ default:
12414
+ let u = options.readUnknownField;
12415
+ if (u === "throw")
12416
+ throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
12417
+ let d = reader.skip(wireType);
12418
+ if (u !== false)
12419
+ (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
12420
+ }
12421
+ }
12422
+ return message;
12423
+ }
12424
+ internalBinaryWrite(message, writer, options) {
12425
+ /* bytes proposer_id = 1; */
12426
+ if (message.proposerId.length)
12427
+ writer.tag(1, WireType.LengthDelimited).bytes(message.proposerId);
12428
+ /* uint32 block_count = 2; */
12429
+ if (message.blockCount !== 0)
12430
+ writer.tag(2, WireType.Varint).uint32(message.blockCount);
12431
+ let u = options.writeUnknownFields;
12432
+ if (u !== false)
12433
+ (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
12434
+ return writer;
12435
+ }
12436
+ }
12437
+ /**
12438
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.BlockProposer
12439
+ */
12440
+ export const GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_BlockProposer = new GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_BlockProposer$Type();
9072
12441
  /**
9073
12442
  * @generated ServiceType for protobuf service org.dash.platform.dapi.v0.Platform
9074
12443
  */
@@ -9087,6 +12456,7 @@ export const Platform = new ServiceType("org.dash.platform.dapi.v0.Platform", [
9087
12456
  { name: "getIdentityByPublicKeyHash", options: {}, I: GetIdentityByPublicKeyHashRequest, O: GetIdentityByPublicKeyHashResponse },
9088
12457
  { name: "getIdentityByNonUniquePublicKeyHash", options: {}, I: GetIdentityByNonUniquePublicKeyHashRequest, O: GetIdentityByNonUniquePublicKeyHashResponse },
9089
12458
  { name: "getEpochsInfo", options: {}, I: GetEpochsInfoRequest, O: GetEpochsInfoResponse },
12459
+ { name: "getFinalizedEpochInfos", options: {}, I: GetFinalizedEpochInfosRequest, O: GetFinalizedEpochInfosResponse },
9090
12460
  { name: "getContestedResources", options: {}, I: GetContestedResourcesRequest, O: GetContestedResourcesResponse },
9091
12461
  { name: "getContestedResourceVoteState", options: {}, I: GetContestedResourceVoteStateRequest, O: GetContestedResourceVoteStateResponse },
9092
12462
  { name: "getTotalCreditsInPlatform", options: {}, I: GetTotalCreditsInPlatformRequest, O: GetTotalCreditsInPlatformResponse },
@@ -9098,5 +12468,15 @@ export const Platform = new ServiceType("org.dash.platform.dapi.v0.Platform", [
9098
12468
  { name: "getTokenTotalSupply", options: {}, I: GetTokenTotalSupplyRequest, O: GetTokenTotalSupplyResponse },
9099
12469
  { name: "waitForStateTransitionResult", options: {}, I: WaitForStateTransitionResultRequest, O: WaitForStateTransitionResultResponse },
9100
12470
  { name: "getAddressInfo", options: {}, I: GetAddressInfoRequest, O: GetAddressInfoResponse },
9101
- { name: "getAddressesInfos", options: {}, I: GetAddressesInfosRequest, O: GetAddressesInfosResponse }
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 },
12476
+ { name: "getShieldedEncryptedNotes", options: {}, I: GetShieldedEncryptedNotesRequest, O: GetShieldedEncryptedNotesResponse },
12477
+ { name: "getShieldedAnchors", options: {}, I: GetShieldedAnchorsRequest, O: GetShieldedAnchorsResponse },
12478
+ { name: "getMostRecentShieldedAnchor", options: {}, I: GetMostRecentShieldedAnchorRequest, O: GetMostRecentShieldedAnchorResponse },
12479
+ { name: "getShieldedPoolState", options: {}, I: GetShieldedPoolStateRequest, O: GetShieldedPoolStateResponse },
12480
+ { name: "getShieldedNotesCount", options: {}, I: GetShieldedNotesCountRequest, O: GetShieldedNotesCountResponse },
12481
+ { name: "getShieldedNullifiers", options: {}, I: GetShieldedNullifiersRequest, O: GetShieldedNullifiersResponse }
9102
12482
  ]);