dash-platform-sdk 1.4.0-dev.5 → 1.4.0-dev.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dash-platform-sdk",
-  "version": "1.4.0-dev.5",
+  "version": "1.4.0-dev.6",
   "main": "index.js",
   "description": "Lightweight SDK for accessing Dash Platform blockchain",
   "ts-standard": {
@@ -55,6 +55,6 @@
     "@scure/bip39": "^2.0.0",
     "@scure/btc-signer": "^2.0.1",
     "cbor-x": "^1.6.0",
-    "pshenmic-dpp": "2.0.0-dev.7"
+    "pshenmic-dpp": "2.0.0-dev.9"
   }
 }

package/proto/generated/platform.client.d.ts

@@ -1,5 +1,7 @@
 import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
 import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import type { GetAddressesInfosResponse } from "./platform.js";
+import type { GetAddressesInfosRequest } from "./platform.js";
 import type { GetAddressInfoResponse } from "./platform.js";
 import type { GetAddressInfoRequest } from "./platform.js";
 import type { WaitForStateTransitionResultResponse } from "./platform.js";
@@ -156,6 +158,10 @@ export interface IPlatformClient {
      * @generated from protobuf rpc: getAddressInfo
      */
     getAddressInfo(input: GetAddressInfoRequest, options?: RpcOptions): UnaryCall<GetAddressInfoRequest, GetAddressInfoResponse>;
+    /**
+     * @generated from protobuf rpc: getAddressesInfos
+     */
+    getAddressesInfos(input: GetAddressesInfosRequest, options?: RpcOptions): UnaryCall<GetAddressesInfosRequest, GetAddressesInfosResponse>;
 }
 /**
  * @generated from protobuf service org.dash.platform.dapi.v0.Platform
@@ -268,4 +274,8 @@ export declare class PlatformClient implements IPlatformClient, ServiceInfo {
      * @generated from protobuf rpc: getAddressInfo
      */
     getAddressInfo(input: GetAddressInfoRequest, options?: RpcOptions): UnaryCall<GetAddressInfoRequest, GetAddressInfoResponse>;
+    /**
+     * @generated from protobuf rpc: getAddressesInfos
+     */
+    getAddressesInfos(input: GetAddressesInfosRequest, options?: RpcOptions): UnaryCall<GetAddressesInfosRequest, GetAddressesInfosResponse>;
 }

package/proto/generated/platform.client.js

@@ -186,4 +186,11 @@ export class PlatformClient {
         const method = this.methods[24], opt = this._transport.mergeOptions(options);
         return stackIntercept("unary", this._transport, method, opt, input);
     }
+    /**
+     * @generated from protobuf rpc: getAddressesInfos
+     */
+    getAddressesInfos(input, options) {
+        const method = this.methods[25], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
 }

package/proto/generated/platform.d.ts

@@ -2883,6 +2883,89 @@ export interface GetAddressInfoResponse_GetAddressInfoResponseV0 {
      */
     metadata?: ResponseMetadata;
 }
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.GetAddressesInfosRequest
+ */
+export interface GetAddressesInfosRequest {
+    /**
+     * @generated from protobuf oneof: version
+     */
+    version: {
+        oneofKind: "v0";
+        /**
+         * @generated from protobuf field: org.dash.platform.dapi.v0.GetAddressesInfosRequest.GetAddressesInfosRequestV0 v0 = 1
+         */
+        v0: GetAddressesInfosRequest_GetAddressesInfosRequestV0;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.GetAddressesInfosRequest.GetAddressesInfosRequestV0
+ */
+export interface GetAddressesInfosRequest_GetAddressesInfosRequestV0 {
+    /**
+     * @generated from protobuf field: repeated bytes addresses = 1
+     */
+    addresses: Uint8Array[];
+    /**
+     * @generated from protobuf field: bool prove = 2
+     */
+    prove: boolean;
+}
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.AddressInfoEntries
+ */
+export interface AddressInfoEntries {
+    /**
+     * @generated from protobuf field: repeated org.dash.platform.dapi.v0.AddressInfoEntry address_info_entries = 1
+     */
+    addressInfoEntries: AddressInfoEntry[];
+}
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.GetAddressesInfosResponse
+ */
+export interface GetAddressesInfosResponse {
+    /**
+     * @generated from protobuf oneof: version
+     */
+    version: {
+        oneofKind: "v0";
+        /**
+         * @generated from protobuf field: org.dash.platform.dapi.v0.GetAddressesInfosResponse.GetAddressesInfosResponseV0 v0 = 1
+         */
+        v0: GetAddressesInfosResponse_GetAddressesInfosResponseV0;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.GetAddressesInfosResponse.GetAddressesInfosResponseV0
+ */
+export interface GetAddressesInfosResponse_GetAddressesInfosResponseV0 {
+    /**
+     * @generated from protobuf oneof: result
+     */
+    result: {
+        oneofKind: "addressInfoEntries";
+        /**
+         * @generated from protobuf field: org.dash.platform.dapi.v0.AddressInfoEntries address_info_entries = 1
+         */
+        addressInfoEntries: AddressInfoEntries;
+    } | {
+        oneofKind: "proof";
+        /**
+         * @generated from protobuf field: org.dash.platform.dapi.v0.Proof proof = 2
+         */
+        proof: Proof;
+    } | {
+        oneofKind: undefined;
+    };
+    /**
+     * @generated from protobuf field: org.dash.platform.dapi.v0.ResponseMetadata metadata = 3
+     */
+    metadata?: ResponseMetadata;
+}
 /**
  * @generated from protobuf enum org.dash.platform.dapi.v0.KeyPurpose
  */
@@ -4411,6 +4494,56 @@ declare class GetAddressInfoResponse_GetAddressInfoResponseV0$Type extends Messa
  * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressInfoResponse.GetAddressInfoResponseV0
  */
 export declare const GetAddressInfoResponse_GetAddressInfoResponseV0: GetAddressInfoResponse_GetAddressInfoResponseV0$Type;
+declare class GetAddressesInfosRequest$Type extends MessageType<GetAddressesInfosRequest> {
+    constructor();
+    create(value?: PartialMessage<GetAddressesInfosRequest>): GetAddressesInfosRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetAddressesInfosRequest): GetAddressesInfosRequest;
+    internalBinaryWrite(message: GetAddressesInfosRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesInfosRequest
+ */
+export declare const GetAddressesInfosRequest: GetAddressesInfosRequest$Type;
+declare class GetAddressesInfosRequest_GetAddressesInfosRequestV0$Type extends MessageType<GetAddressesInfosRequest_GetAddressesInfosRequestV0> {
+    constructor();
+    create(value?: PartialMessage<GetAddressesInfosRequest_GetAddressesInfosRequestV0>): GetAddressesInfosRequest_GetAddressesInfosRequestV0;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetAddressesInfosRequest_GetAddressesInfosRequestV0): GetAddressesInfosRequest_GetAddressesInfosRequestV0;
+    internalBinaryWrite(message: GetAddressesInfosRequest_GetAddressesInfosRequestV0, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesInfosRequest.GetAddressesInfosRequestV0
+ */
+export declare const GetAddressesInfosRequest_GetAddressesInfosRequestV0: GetAddressesInfosRequest_GetAddressesInfosRequestV0$Type;
+declare class AddressInfoEntries$Type extends MessageType<AddressInfoEntries> {
+    constructor();
+    create(value?: PartialMessage<AddressInfoEntries>): AddressInfoEntries;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AddressInfoEntries): AddressInfoEntries;
+    internalBinaryWrite(message: AddressInfoEntries, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.AddressInfoEntries
+ */
+export declare const AddressInfoEntries: AddressInfoEntries$Type;
+declare class GetAddressesInfosResponse$Type extends MessageType<GetAddressesInfosResponse> {
+    constructor();
+    create(value?: PartialMessage<GetAddressesInfosResponse>): GetAddressesInfosResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetAddressesInfosResponse): GetAddressesInfosResponse;
+    internalBinaryWrite(message: GetAddressesInfosResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesInfosResponse
+ */
+export declare const GetAddressesInfosResponse: GetAddressesInfosResponse$Type;
+declare class GetAddressesInfosResponse_GetAddressesInfosResponseV0$Type extends MessageType<GetAddressesInfosResponse_GetAddressesInfosResponseV0> {
+    constructor();
+    create(value?: PartialMessage<GetAddressesInfosResponse_GetAddressesInfosResponseV0>): GetAddressesInfosResponse_GetAddressesInfosResponseV0;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetAddressesInfosResponse_GetAddressesInfosResponseV0): GetAddressesInfosResponse_GetAddressesInfosResponseV0;
+    internalBinaryWrite(message: GetAddressesInfosResponse_GetAddressesInfosResponseV0, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesInfosResponse.GetAddressesInfosResponseV0
+ */
+export declare const GetAddressesInfosResponse_GetAddressesInfosResponseV0: GetAddressesInfosResponse_GetAddressesInfosResponseV0$Type;
 /**
  * @generated ServiceType for protobuf service org.dash.platform.dapi.v0.Platform
  */

package/proto/generated/platform.js

@@ -8800,6 +8800,275 @@ class GetAddressInfoResponse_GetAddressInfoResponseV0$Type extends MessageType {
  * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressInfoResponse.GetAddressInfoResponseV0
  */
 export const GetAddressInfoResponse_GetAddressInfoResponseV0 = new GetAddressInfoResponse_GetAddressInfoResponseV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetAddressesInfosRequest$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetAddressesInfosRequest", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetAddressesInfosRequest_GetAddressesInfosRequestV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetAddressesInfosRequest.GetAddressesInfosRequestV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetAddressesInfosRequest_GetAddressesInfosRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetAddressesInfosRequest.GetAddressesInfosRequestV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetAddressesInfosRequest_GetAddressesInfosRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesInfosRequest
+ */
+export const GetAddressesInfosRequest = new GetAddressesInfosRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetAddressesInfosRequest_GetAddressesInfosRequestV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetAddressesInfosRequest.GetAddressesInfosRequestV0", [
+            { no: 1, name: "addresses", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.addresses = [];
+        message.prove = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated bytes addresses */ 1:
+                    message.addresses.push(reader.bytes());
+                    break;
+                case /* bool prove */ 2:
+                    message.prove = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated bytes addresses = 1; */
+        for (let i = 0; i < message.addresses.length; i++)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.addresses[i]);
+        /* bool prove = 2; */
+        if (message.prove !== false)
+            writer.tag(2, WireType.Varint).bool(message.prove);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesInfosRequest.GetAddressesInfosRequestV0
+ */
+export const GetAddressesInfosRequest_GetAddressesInfosRequestV0 = new GetAddressesInfosRequest_GetAddressesInfosRequestV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AddressInfoEntries$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.AddressInfoEntries", [
+            { no: 1, name: "address_info_entries", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => AddressInfoEntry }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.addressInfoEntries = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated org.dash.platform.dapi.v0.AddressInfoEntry address_info_entries */ 1:
+                    message.addressInfoEntries.push(AddressInfoEntry.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated org.dash.platform.dapi.v0.AddressInfoEntry address_info_entries = 1; */
+        for (let i = 0; i < message.addressInfoEntries.length; i++)
+            AddressInfoEntry.internalBinaryWrite(message.addressInfoEntries[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.AddressInfoEntries
+ */
+export const AddressInfoEntries = new AddressInfoEntries$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetAddressesInfosResponse$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetAddressesInfosResponse", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetAddressesInfosResponse_GetAddressesInfosResponseV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetAddressesInfosResponse.GetAddressesInfosResponseV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetAddressesInfosResponse_GetAddressesInfosResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetAddressesInfosResponse.GetAddressesInfosResponseV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetAddressesInfosResponse_GetAddressesInfosResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesInfosResponse
+ */
+export const GetAddressesInfosResponse = new GetAddressesInfosResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetAddressesInfosResponse_GetAddressesInfosResponseV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetAddressesInfosResponse.GetAddressesInfosResponseV0", [
+            { no: 1, name: "address_info_entries", kind: "message", oneof: "result", T: () => AddressInfoEntries },
+            { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
+            { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.result = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.AddressInfoEntries address_info_entries */ 1:
+                    message.result = {
+                        oneofKind: "addressInfoEntries",
+                        addressInfoEntries: AddressInfoEntries.internalBinaryRead(reader, reader.uint32(), options, message.result.addressInfoEntries)
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.Proof proof */ 2:
+                    message.result = {
+                        oneofKind: "proof",
+                        proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
+                    message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.AddressInfoEntries address_info_entries = 1; */
+        if (message.result.oneofKind === "addressInfoEntries")
+            AddressInfoEntries.internalBinaryWrite(message.result.addressInfoEntries, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* org.dash.platform.dapi.v0.Proof proof = 2; */
+        if (message.result.oneofKind === "proof")
+            Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
+        if (message.metadata)
+            ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesInfosResponse.GetAddressesInfosResponseV0
+ */
+export const GetAddressesInfosResponse_GetAddressesInfosResponseV0 = new GetAddressesInfosResponse_GetAddressesInfosResponseV0$Type();
 /**
  * @generated ServiceType for protobuf service org.dash.platform.dapi.v0.Platform
  */
@@ -8828,5 +9097,6 @@ export const Platform = new ServiceType("org.dash.platform.dapi.v0.Platform", [
     { name: "getTokenDirectPurchasePrices", options: {}, I: GetTokenDirectPurchasePricesRequest, O: GetTokenDirectPurchasePricesResponse },
     { name: "getTokenTotalSupply", options: {}, I: GetTokenTotalSupplyRequest, O: GetTokenTotalSupplyResponse },
     { name: "waitForStateTransitionResult", options: {}, I: WaitForStateTransitionResultRequest, O: WaitForStateTransitionResultResponse },
-    { name: "getAddressInfo", options: {}, I: GetAddressInfoRequest, O: GetAddressInfoResponse }
+    { name: "getAddressInfo", options: {}, I: GetAddressInfoRequest, O: GetAddressInfoResponse },
+    { name: "getAddressesInfos", options: {}, I: GetAddressesInfosRequest, O: GetAddressesInfosResponse }
 ]);

package/src/platformAddresses/getAddressInfo.js

@@ -28,7 +28,7 @@ export async function getAddressInfo(grpcPool, platformAddress) {
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, address, nonce, balance } = await verifyPlatformAddressInfo(proof.grovedbProof, platformAddressWASM, true, LATEST_PLATFORM_VERSION);
+    const { rootHash, address, nonce, balance } = verifyPlatformAddressInfo(proof.grovedbProof, platformAddressWASM, true, LATEST_PLATFORM_VERSION);
     if (address == null || nonce == null || balance == null) {
         throw new Error(`Failed to fetch info for address ${platformAddressWASM.toBech32m(grpcPool.network)}`);
     }

package/src/platformAddresses/getAddressesInfos.d.ts

@@ -0,0 +1,4 @@
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { PlatformAddressLike } from 'pshenmic-dpp';
+import { PlatformAddressInfo } from '../../types.js';
+export declare function getAddressesInfos(grpcPool: GRPCConnectionPool, platformAddresses: PlatformAddressLike[]): Promise<PlatformAddressInfo[]>;

package/src/platformAddresses/getAddressesInfos.js

@@ -0,0 +1,43 @@
+import { PlatformAddressWASM, verifyPlatformAddressesInfos } from 'pshenmic-dpp';
+import { GetAddressesInfosRequest } from '../../proto/generated/platform.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
+import bytesToHex from '../utils/bytesToHex.js';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+export async function getAddressesInfos(grpcPool, platformAddresses) {
+    const platformAddressesWASM = platformAddresses.map(addr => new PlatformAddressWASM(addr));
+    const getAddressInfoRequest = GetAddressesInfosRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                addresses: platformAddressesWASM.map(addr => addr.bytes()),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getAddressesInfos(getAddressInfoRequest);
+    const { version } = response;
+    if (version.oneofKind !== 'v0') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be v0)');
+    }
+    const { v0 } = version;
+    if (v0.result.oneofKind !== 'proof') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be proof)');
+    }
+    const { result: { proof }, metadata } = v0;
+    if (metadata == null) {
+        throw new Error('Metadata not found');
+    }
+    const { rootHash, infos } = verifyPlatformAddressesInfos(proof.grovedbProof, platformAddressesWASM, true, LATEST_PLATFORM_VERSION);
+    const quorumPublicKey = await getQuorumPublicKey(grpcPool.network, proof.quorumType, bytesToHex(proof.quorumHash));
+    const verify = await verifyTenderdashProof(proof, metadata, rootHash, quorumPublicKey);
+    if (!verify) {
+        throw new Error('Failed to verify query');
+    }
+    return infos
+        .map(info => ({
+        address: info.address,
+        nonce: info.nonce ?? 0,
+        balance: BigInt(info.balance ?? 0)
+    }));
+}

package/src/platformAddresses/index.d.ts

@@ -12,4 +12,11 @@ export declare class PlatformAddressesController {
      * @return {Promise<PlatformAddressInfo>}
      */
     getAddressInfo(address: PlatformAddressLike): Promise<PlatformAddressInfo>;
+    /**
+     * Makes a query for platform addresses infos, returns array with an object with address, balance and nonce
+     *
+     * @param addresses {PlatformAddressLike[]}
+     * @return {Promise<PlatformAddressInfo[]>}
+     */
+    getAddressesInfos(addresses: PlatformAddressLike[]): Promise<PlatformAddressInfo[]>;
 }

package/src/platformAddresses/index.js

@@ -1,4 +1,5 @@
 import { getAddressInfo } from './getAddressInfo.js';
+import { getAddressesInfos } from './getAddressesInfos.js';
 export class PlatformAddressesController {
     /** @ignore **/
     grpcPool;
@@ -14,4 +15,13 @@ export class PlatformAddressesController {
     async getAddressInfo(address) {
         return await getAddressInfo(this.grpcPool, address);
     }
+    /**
+     * Makes a query for platform addresses infos, returns array with an object with address, balance and nonce
+     *
+     * @param addresses {PlatformAddressLike[]}
+     * @return {Promise<PlatformAddressInfo[]>}
+     */
+    async getAddressesInfos(addresses) {
+        return await getAddressesInfos(this.grpcPool, addresses);
+    }
 }

package/src/stateTransitions/broadcast.js

@@ -1,10 +1,21 @@
 import { BroadcastStateTransitionRequest } from '../../proto/generated/platform.js';
+import { deserializeConsensusError } from '../utils/deserializeConsensusError.js';
 export default async function broadcast(grpcPool, stateTransition) {
-    if (stateTransition.signature?.length === 0) {
-        throw new Error('State Transition is not signed');
+    try {
+        if (stateTransition.signature?.length === 0) {
+            throw new Error('State Transition is not signed');
+        }
+        const broadcastStateTransitionRequest = BroadcastStateTransitionRequest.create({
+            stateTransition: stateTransition.bytes()
+        });
+        await grpcPool.getClient().broadcastStateTransition(broadcastStateTransitionRequest);
+    }
+    catch (err) {
+        if (err.meta?.['dash-serialized-consensus-error-bin']?.length !== 0) {
+            throw new Error(deserializeConsensusError(err.meta['dash-serialized-consensus-error-bin']));
+        }
+        else {
+            throw err;
+        }
     }
-    const broadcastStateTransitionRequest = BroadcastStateTransitionRequest.create({
-        stateTransition: stateTransition.bytes()
-    });
-    await grpcPool.getClient().broadcastStateTransition(broadcastStateTransitionRequest);
 }

package/src/utils/deserializeConsensusError.d.ts

@@ -0,0 +1 @@
+export declare function deserializeConsensusError(error: string | Uint8Array): string;

package/src/utils/deserializeConsensusError.js

@@ -0,0 +1,17 @@
+import { base64 } from '@scure/base';
+import { ConsensusErrorWASM } from 'pshenmic-dpp';
+export function deserializeConsensusError(error) {
+    let normError;
+    if (typeof error === 'string') {
+        // @scure/base64 works only with padded base64, but cbor can return unpadded base64
+        const padding = error.length % 4;
+        if (padding !== 0) {
+            error += '='.repeat(4 - padding);
+        }
+        normError = base64.decode(error);
+    }
+    else {
+        normError = error;
+    }
+    return ConsensusErrorWASM.deserialize(normError).message;
+}

package/src/utils/index.d.ts

@@ -69,4 +69,11 @@ export declare class UtilsController {
      * @return {boolean}
      * */
     validateIdentifier(identifier: IdentifierLike): boolean;
+    /**
+     * Allows to deserialize consensus error
+     *
+     * @param error {string | Uint8Array} error in base64 or bytes
+     * @return {string}
+     */
+    deserializeConsensusError(error: string | Uint8Array): string;
 }

package/src/utils/index.js

@@ -5,6 +5,7 @@ import bytesToHex from './bytesToHex.js';
 import { createVoterIdentityId } from './createVoterIdentityId.js';
 import { IdentifierWASM } from 'pshenmic-dpp';
 import { createMasternodeIdentityId } from './createMasternodeIdentityId.js';
+import { deserializeConsensusError } from './deserializeConsensusError.js';
 /**
  * Collection of conversion functions
  *
@@ -98,4 +99,13 @@ export class UtilsController {
             return false;
         }
     }
+    /**
+     * Allows to deserialize consensus error
+     *
+     * @param error {string | Uint8Array} error in base64 or bytes
+     * @return {string}
+     */
+    deserializeConsensusError(error) {
+        return deserializeConsensusError(error);
+    }
 }