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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dash-platform-sdk",
-  "version": "1.4.0-dev.4",
+  "version": "1.4.0-dev.5",
   "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.6"
+    "pshenmic-dpp": "2.0.0-dev.7"
   }
 }

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 { GetAddressInfoResponse } from "./platform.js";
+import type { GetAddressInfoRequest } from "./platform.js";
 import type { WaitForStateTransitionResultResponse } from "./platform.js";
 import type { WaitForStateTransitionResultRequest } from "./platform.js";
 import type { GetTokenTotalSupplyResponse } from "./platform.js";
@@ -150,6 +152,10 @@ export interface IPlatformClient {
      * @generated from protobuf rpc: waitForStateTransitionResult
      */
     waitForStateTransitionResult(input: WaitForStateTransitionResultRequest, options?: RpcOptions): UnaryCall<WaitForStateTransitionResultRequest, WaitForStateTransitionResultResponse>;
+    /**
+     * @generated from protobuf rpc: getAddressInfo
+     */
+    getAddressInfo(input: GetAddressInfoRequest, options?: RpcOptions): UnaryCall<GetAddressInfoRequest, GetAddressInfoResponse>;
 }
 /**
  * @generated from protobuf service org.dash.platform.dapi.v0.Platform
@@ -258,4 +264,8 @@ export declare class PlatformClient implements IPlatformClient, ServiceInfo {
      * @generated from protobuf rpc: waitForStateTransitionResult
      */
     waitForStateTransitionResult(input: WaitForStateTransitionResultRequest, options?: RpcOptions): UnaryCall<WaitForStateTransitionResultRequest, WaitForStateTransitionResultResponse>;
+    /**
+     * @generated from protobuf rpc: getAddressInfo
+     */
+    getAddressInfo(input: GetAddressInfoRequest, options?: RpcOptions): UnaryCall<GetAddressInfoRequest, GetAddressInfoResponse>;
 }

package/proto/generated/platform.client.js

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

package/proto/generated/platform.d.ts

@@ -2783,6 +2783,106 @@ export interface WaitForStateTransitionResultResponse_WaitForStateTransitionResu
      */
     metadata?: ResponseMetadata;
 }
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.GetAddressInfoRequest
+ */
+export interface GetAddressInfoRequest {
+    /**
+     * @generated from protobuf oneof: version
+     */
+    version: {
+        oneofKind: "v0";
+        /**
+         * @generated from protobuf field: org.dash.platform.dapi.v0.GetAddressInfoRequest.GetAddressInfoRequestV0 v0 = 1
+         */
+        v0: GetAddressInfoRequest_GetAddressInfoRequestV0;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.GetAddressInfoRequest.GetAddressInfoRequestV0
+ */
+export interface GetAddressInfoRequest_GetAddressInfoRequestV0 {
+    /**
+     * @generated from protobuf field: bytes address = 1
+     */
+    address: Uint8Array;
+    /**
+     * @generated from protobuf field: bool prove = 2
+     */
+    prove: boolean;
+}
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.AddressInfoEntry
+ */
+export interface AddressInfoEntry {
+    /**
+     * @generated from protobuf field: bytes address = 1
+     */
+    address: Uint8Array;
+    /**
+     * @generated from protobuf field: optional org.dash.platform.dapi.v0.BalanceAndNonce balance_and_nonce = 2
+     */
+    balanceAndNonce?: BalanceAndNonce;
+}
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.BalanceAndNonce
+ */
+export interface BalanceAndNonce {
+    /**
+     * @generated from protobuf field: uint64 balance = 1
+     */
+    balance: string;
+    /**
+     * @generated from protobuf field: uint32 nonce = 2
+     */
+    nonce: number;
+}
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.GetAddressInfoResponse
+ */
+export interface GetAddressInfoResponse {
+    /**
+     * @generated from protobuf oneof: version
+     */
+    version: {
+        oneofKind: "v0";
+        /**
+         * @generated from protobuf field: org.dash.platform.dapi.v0.GetAddressInfoResponse.GetAddressInfoResponseV0 v0 = 1
+         */
+        v0: GetAddressInfoResponse_GetAddressInfoResponseV0;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.GetAddressInfoResponse.GetAddressInfoResponseV0
+ */
+export interface GetAddressInfoResponse_GetAddressInfoResponseV0 {
+    /**
+     * @generated from protobuf oneof: result
+     */
+    result: {
+        oneofKind: "addressInfoEntry";
+        /**
+         * @generated from protobuf field: org.dash.platform.dapi.v0.AddressInfoEntry address_info_entry = 1
+         */
+        addressInfoEntry: AddressInfoEntry;
+    } | {
+        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
  */
@@ -4251,6 +4351,66 @@ declare class WaitForStateTransitionResultResponse_WaitForStateTransitionResultR
  * @generated MessageType for protobuf message org.dash.platform.dapi.v0.WaitForStateTransitionResultResponse.WaitForStateTransitionResultResponseV0
  */
 export declare const WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0: WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0$Type;
+declare class GetAddressInfoRequest$Type extends MessageType<GetAddressInfoRequest> {
+    constructor();
+    create(value?: PartialMessage<GetAddressInfoRequest>): GetAddressInfoRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetAddressInfoRequest): GetAddressInfoRequest;
+    internalBinaryWrite(message: GetAddressInfoRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressInfoRequest
+ */
+export declare const GetAddressInfoRequest: GetAddressInfoRequest$Type;
+declare class GetAddressInfoRequest_GetAddressInfoRequestV0$Type extends MessageType<GetAddressInfoRequest_GetAddressInfoRequestV0> {
+    constructor();
+    create(value?: PartialMessage<GetAddressInfoRequest_GetAddressInfoRequestV0>): GetAddressInfoRequest_GetAddressInfoRequestV0;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetAddressInfoRequest_GetAddressInfoRequestV0): GetAddressInfoRequest_GetAddressInfoRequestV0;
+    internalBinaryWrite(message: GetAddressInfoRequest_GetAddressInfoRequestV0, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressInfoRequest.GetAddressInfoRequestV0
+ */
+export declare const GetAddressInfoRequest_GetAddressInfoRequestV0: GetAddressInfoRequest_GetAddressInfoRequestV0$Type;
+declare class AddressInfoEntry$Type extends MessageType<AddressInfoEntry> {
+    constructor();
+    create(value?: PartialMessage<AddressInfoEntry>): AddressInfoEntry;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AddressInfoEntry): AddressInfoEntry;
+    internalBinaryWrite(message: AddressInfoEntry, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.AddressInfoEntry
+ */
+export declare const AddressInfoEntry: AddressInfoEntry$Type;
+declare class BalanceAndNonce$Type extends MessageType<BalanceAndNonce> {
+    constructor();
+    create(value?: PartialMessage<BalanceAndNonce>): BalanceAndNonce;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BalanceAndNonce): BalanceAndNonce;
+    internalBinaryWrite(message: BalanceAndNonce, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.BalanceAndNonce
+ */
+export declare const BalanceAndNonce: BalanceAndNonce$Type;
+declare class GetAddressInfoResponse$Type extends MessageType<GetAddressInfoResponse> {
+    constructor();
+    create(value?: PartialMessage<GetAddressInfoResponse>): GetAddressInfoResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetAddressInfoResponse): GetAddressInfoResponse;
+    internalBinaryWrite(message: GetAddressInfoResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressInfoResponse
+ */
+export declare const GetAddressInfoResponse: GetAddressInfoResponse$Type;
+declare class GetAddressInfoResponse_GetAddressInfoResponseV0$Type extends MessageType<GetAddressInfoResponse_GetAddressInfoResponseV0> {
+    constructor();
+    create(value?: PartialMessage<GetAddressInfoResponse_GetAddressInfoResponseV0>): GetAddressInfoResponse_GetAddressInfoResponseV0;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetAddressInfoResponse_GetAddressInfoResponseV0): GetAddressInfoResponse_GetAddressInfoResponseV0;
+    internalBinaryWrite(message: GetAddressInfoResponse_GetAddressInfoResponseV0, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressInfoResponse.GetAddressInfoResponseV0
+ */
+export declare const GetAddressInfoResponse_GetAddressInfoResponseV0: GetAddressInfoResponse_GetAddressInfoResponseV0$Type;
 /**
  * @generated ServiceType for protobuf service org.dash.platform.dapi.v0.Platform
  */

package/proto/generated/platform.js

@@ -8469,6 +8469,337 @@ class WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV
  * @generated MessageType for protobuf message org.dash.platform.dapi.v0.WaitForStateTransitionResultResponse.WaitForStateTransitionResultResponseV0
  */
 export const WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0 = new WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetAddressInfoRequest$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetAddressInfoRequest", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetAddressInfoRequest_GetAddressInfoRequestV0 }
+        ]);
+    }
+    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.GetAddressInfoRequest.GetAddressInfoRequestV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetAddressInfoRequest_GetAddressInfoRequestV0.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.GetAddressInfoRequest.GetAddressInfoRequestV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetAddressInfoRequest_GetAddressInfoRequestV0.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.GetAddressInfoRequest
+ */
+export const GetAddressInfoRequest = new GetAddressInfoRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetAddressInfoRequest_GetAddressInfoRequestV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetAddressInfoRequest.GetAddressInfoRequestV0", [
+            { no: 1, name: "address", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.address = new Uint8Array(0);
+        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 /* bytes address */ 1:
+                    message.address = 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) {
+        /* bytes address = 1; */
+        if (message.address.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.address);
+        /* 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.GetAddressInfoRequest.GetAddressInfoRequestV0
+ */
+export const GetAddressInfoRequest_GetAddressInfoRequestV0 = new GetAddressInfoRequest_GetAddressInfoRequestV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AddressInfoEntry$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.AddressInfoEntry", [
+            { no: 1, name: "address", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "balance_and_nonce", kind: "message", T: () => BalanceAndNonce }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.address = new Uint8Array(0);
+        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 /* bytes address */ 1:
+                    message.address = reader.bytes();
+                    break;
+                case /* optional org.dash.platform.dapi.v0.BalanceAndNonce balance_and_nonce */ 2:
+                    message.balanceAndNonce = BalanceAndNonce.internalBinaryRead(reader, reader.uint32(), options, message.balanceAndNonce);
+                    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) {
+        /* bytes address = 1; */
+        if (message.address.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.address);
+        /* optional org.dash.platform.dapi.v0.BalanceAndNonce balance_and_nonce = 2; */
+        if (message.balanceAndNonce)
+            BalanceAndNonce.internalBinaryWrite(message.balanceAndNonce, writer.tag(2, 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.AddressInfoEntry
+ */
+export const AddressInfoEntry = new AddressInfoEntry$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class BalanceAndNonce$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.BalanceAndNonce", [
+            { no: 1, name: "balance", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
+            { no: 2, name: "nonce", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.balance = "0";
+        message.nonce = 0;
+        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 /* uint64 balance */ 1:
+                    message.balance = reader.uint64().toString();
+                    break;
+                case /* uint32 nonce */ 2:
+                    message.nonce = reader.uint32();
+                    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) {
+        /* uint64 balance = 1; */
+        if (message.balance !== "0")
+            writer.tag(1, WireType.Varint).uint64(message.balance);
+        /* uint32 nonce = 2; */
+        if (message.nonce !== 0)
+            writer.tag(2, WireType.Varint).uint32(message.nonce);
+        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.BalanceAndNonce
+ */
+export const BalanceAndNonce = new BalanceAndNonce$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetAddressInfoResponse$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetAddressInfoResponse", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetAddressInfoResponse_GetAddressInfoResponseV0 }
+        ]);
+    }
+    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.GetAddressInfoResponse.GetAddressInfoResponseV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetAddressInfoResponse_GetAddressInfoResponseV0.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.GetAddressInfoResponse.GetAddressInfoResponseV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetAddressInfoResponse_GetAddressInfoResponseV0.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.GetAddressInfoResponse
+ */
+export const GetAddressInfoResponse = new GetAddressInfoResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetAddressInfoResponse_GetAddressInfoResponseV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetAddressInfoResponse.GetAddressInfoResponseV0", [
+            { no: 1, name: "address_info_entry", kind: "message", oneof: "result", T: () => AddressInfoEntry },
+            { 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.AddressInfoEntry address_info_entry */ 1:
+                    message.result = {
+                        oneofKind: "addressInfoEntry",
+                        addressInfoEntry: AddressInfoEntry.internalBinaryRead(reader, reader.uint32(), options, message.result.addressInfoEntry)
+                    };
+                    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.AddressInfoEntry address_info_entry = 1; */
+        if (message.result.oneofKind === "addressInfoEntry")
+            AddressInfoEntry.internalBinaryWrite(message.result.addressInfoEntry, 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.GetAddressInfoResponse.GetAddressInfoResponseV0
+ */
+export const GetAddressInfoResponse_GetAddressInfoResponseV0 = new GetAddressInfoResponse_GetAddressInfoResponseV0$Type();
 /**
  * @generated ServiceType for protobuf service org.dash.platform.dapi.v0.Platform
  */
@@ -8496,5 +8827,6 @@ export const Platform = new ServiceType("org.dash.platform.dapi.v0.Platform", [
     { name: "getTokenContractInfo", options: {}, I: GetTokenContractInfoRequest, O: GetTokenContractInfoResponse },
     { name: "getTokenDirectPurchasePrices", options: {}, I: GetTokenDirectPurchasePricesRequest, O: GetTokenDirectPurchasePricesResponse },
     { name: "getTokenTotalSupply", options: {}, I: GetTokenTotalSupplyRequest, O: GetTokenTotalSupplyResponse },
-    { name: "waitForStateTransitionResult", options: {}, I: WaitForStateTransitionResultRequest, O: WaitForStateTransitionResultResponse }
+    { name: "waitForStateTransitionResult", options: {}, I: WaitForStateTransitionResultRequest, O: WaitForStateTransitionResultResponse },
+    { name: "getAddressInfo", options: {}, I: GetAddressInfoRequest, O: GetAddressInfoResponse }
 ]);

package/src/DashPlatformSDK.d.ts

@@ -11,6 +11,7 @@ import { ContestedResourcesController } from './contestedResources/index.js';
 import { TokensController } from './tokens/index.js';
 import { VotingController } from './voting/index.js';
 import { Network } from '../types.js';
+import { PlatformAddressesController } from './platformAddresses/index.js';
 export interface GRPCOptions {
     poolLimit: 5;
     dapiUrl?: string | string[];
@@ -31,6 +32,7 @@ export declare class DashPlatformSDK {
     /** @ignore **/
     options?: SDKOptions;
     contestedResources: ContestedResourcesController;
+    platformAddresses: PlatformAddressesController;
     stateTransitions: StateTransitionsController;
     dataContracts: DataContractsController;
     identities: IdentitiesController;
@@ -56,7 +58,7 @@ export declare class DashPlatformSDK {
      * @param grpcPool
      * @param network
      */
-    _initialize(grpcPool: GRPCConnectionPool, network: Network): void;
+    _initialize(grpcPool: GRPCConnectionPool): void;
     /**
      * Get currently used network
      *

package/src/DashPlatformSDK.js

@@ -10,6 +10,7 @@ import { DataContractsController } from './dataContracts/index.js';
 import { ContestedResourcesController } from './contestedResources/index.js';
 import { TokensController } from './tokens/index.js';
 import { VotingController } from './voting/index.js';
+import { PlatformAddressesController } from './platformAddresses/index.js';
 /**
  * Javascript SDK for that let you interact with a Dash Platform blockchain
  */
@@ -20,6 +21,7 @@ export class DashPlatformSDK {
     /** @ignore **/
     options;
     contestedResources;
+    platformAddresses;
     stateTransitions;
     dataContracts;
     identities;
@@ -49,7 +51,7 @@ export class DashPlatformSDK {
             this.options.grpc = { dapiUrl: options.dapiUrl };
         }
         this.grpcPool = new GRPCConnectionPool(this.network, this.options?.grpc);
-        this._initialize(this.grpcPool, this.network);
+        this._initialize(this.grpcPool);
     }
     /**
      * @private
@@ -59,15 +61,16 @@ export class DashPlatformSDK {
      * @param grpcPool
      * @param network
      */
-    _initialize(grpcPool, network) {
+    _initialize(grpcPool) {
         this.grpcPool = grpcPool;
-        this.stateTransitions = new StateTransitionsController(grpcPool);
         this.contestedResources = new ContestedResourcesController(grpcPool);
+        this.platformAddresses = new PlatformAddressesController(grpcPool);
+        this.stateTransitions = new StateTransitionsController(grpcPool);
         this.dataContracts = new DataContractsController(grpcPool);
         this.identities = new IdentitiesController(grpcPool);
         this.documents = new DocumentsController(grpcPool);
         this.voting = new VotingController();
-        this.node = new NodeController(grpcPool, network);
+        this.node = new NodeController(grpcPool);
         this.tokens = new TokensController(grpcPool);
         this.names = new NamesController(grpcPool);
         this.keyPair = new KeyPairController();
@@ -91,6 +94,6 @@ export class DashPlatformSDK {
         }
         this.network = network;
         const grpcPool = new GRPCConnectionPool(this.network, this.options?.grpc);
-        this._initialize(grpcPool, this.network);
+        this._initialize(grpcPool);
     }
 }

package/src/dataContracts/create.d.ts

@@ -1,3 +1,3 @@
-import { DataContractTokens, DataContractWASM, PlatformVersionWASM } from 'pshenmic-dpp';
-import { DataContractConfig, IdentifierLike } from '../../types.js';
+import { DataContractTokens, DataContractWASM, IdentifierLike, PlatformVersionWASM } from 'pshenmic-dpp';
+import { DataContractConfig } from '../../types.js';
 export default function createDataContract(ownerId: IdentifierLike, identityNonce: bigint, schema: object, tokenConfiguration?: DataContractTokens[], config?: DataContractConfig, fullValidation?: boolean | undefined, platformVersion?: PlatformVersionWASM | undefined): DataContractWASM;

package/src/dataContracts/getDataContractByIdentifier.d.ts

@@ -1,4 +1,3 @@
-import { DataContractWASM } from 'pshenmic-dpp';
-import { IdentifierLike } from '../../types.js';
+import { DataContractWASM, IdentifierLike } from 'pshenmic-dpp';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function getByIdentifier(grpcPool: GRPCConnectionPool, identifier: IdentifierLike): Promise<DataContractWASM>;