dash-platform-sdk 1.3.0-dev.10 → 1.3.0-dev.11

package/package.json

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

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

package/proto/generated/platform.client.js

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

package/proto/generated/platform.d.ts

@@ -2709,6 +2709,80 @@ export interface CanonicalVote {
      */
     chainId: string;
 }
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.WaitForStateTransitionResultRequest
+ */
+export interface WaitForStateTransitionResultRequest {
+    /**
+     * @generated from protobuf oneof: version
+     */
+    version: {
+        oneofKind: "v0";
+        /**
+         * @generated from protobuf field: org.dash.platform.dapi.v0.WaitForStateTransitionResultRequest.WaitForStateTransitionResultRequestV0 v0 = 1
+         */
+        v0: WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.WaitForStateTransitionResultRequest.WaitForStateTransitionResultRequestV0
+ */
+export interface WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0 {
+    /**
+     * @generated from protobuf field: bytes state_transition_hash = 1
+     */
+    stateTransitionHash: Uint8Array;
+    /**
+     * @generated from protobuf field: bool prove = 2
+     */
+    prove: boolean;
+}
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.WaitForStateTransitionResultResponse
+ */
+export interface WaitForStateTransitionResultResponse {
+    /**
+     * @generated from protobuf oneof: version
+     */
+    version: {
+        oneofKind: "v0";
+        /**
+         * @generated from protobuf field: org.dash.platform.dapi.v0.WaitForStateTransitionResultResponse.WaitForStateTransitionResultResponseV0 v0 = 1
+         */
+        v0: WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message org.dash.platform.dapi.v0.WaitForStateTransitionResultResponse.WaitForStateTransitionResultResponseV0
+ */
+export interface WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0 {
+    /**
+     * @generated from protobuf oneof: result
+     */
+    result: {
+        oneofKind: "error";
+        /**
+         * @generated from protobuf field: org.dash.platform.dapi.v0.StateTransitionBroadcastError error = 1
+         */
+        error: StateTransitionBroadcastError;
+    } | {
+        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
  */
@@ -4137,6 +4211,46 @@ declare class CanonicalVote$Type extends MessageType<CanonicalVote> {
  * @generated MessageType for protobuf message org.dash.platform.dapi.v0.CanonicalVote
  */
 export declare const CanonicalVote: CanonicalVote$Type;
+declare class WaitForStateTransitionResultRequest$Type extends MessageType<WaitForStateTransitionResultRequest> {
+    constructor();
+    create(value?: PartialMessage<WaitForStateTransitionResultRequest>): WaitForStateTransitionResultRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WaitForStateTransitionResultRequest): WaitForStateTransitionResultRequest;
+    internalBinaryWrite(message: WaitForStateTransitionResultRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.WaitForStateTransitionResultRequest
+ */
+export declare const WaitForStateTransitionResultRequest: WaitForStateTransitionResultRequest$Type;
+declare class WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0$Type extends MessageType<WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0> {
+    constructor();
+    create(value?: PartialMessage<WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0>): WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0): WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0;
+    internalBinaryWrite(message: WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.WaitForStateTransitionResultRequest.WaitForStateTransitionResultRequestV0
+ */
+export declare const WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0: WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0$Type;
+declare class WaitForStateTransitionResultResponse$Type extends MessageType<WaitForStateTransitionResultResponse> {
+    constructor();
+    create(value?: PartialMessage<WaitForStateTransitionResultResponse>): WaitForStateTransitionResultResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WaitForStateTransitionResultResponse): WaitForStateTransitionResultResponse;
+    internalBinaryWrite(message: WaitForStateTransitionResultResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.WaitForStateTransitionResultResponse
+ */
+export declare const WaitForStateTransitionResultResponse: WaitForStateTransitionResultResponse$Type;
+declare class WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0$Type extends MessageType<WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0> {
+    constructor();
+    create(value?: PartialMessage<WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0>): WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0): WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0;
+    internalBinaryWrite(message: WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.WaitForStateTransitionResultResponse.WaitForStateTransitionResultResponseV0
+ */
+export declare const WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0: WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0$Type;
 /**
  * @generated ServiceType for protobuf service org.dash.platform.dapi.v0.Platform
  */

package/proto/generated/platform.js

@@ -8247,6 +8247,228 @@ class CanonicalVote$Type extends MessageType {
  * @generated MessageType for protobuf message org.dash.platform.dapi.v0.CanonicalVote
  */
 export const CanonicalVote = new CanonicalVote$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class WaitForStateTransitionResultRequest$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.WaitForStateTransitionResultRequest", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0 }
+        ]);
+    }
+    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.WaitForStateTransitionResultRequest.WaitForStateTransitionResultRequestV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0.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.WaitForStateTransitionResultRequest.WaitForStateTransitionResultRequestV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0.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.WaitForStateTransitionResultRequest
+ */
+export const WaitForStateTransitionResultRequest = new WaitForStateTransitionResultRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.WaitForStateTransitionResultRequest.WaitForStateTransitionResultRequestV0", [
+            { no: 1, name: "state_transition_hash", 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.stateTransitionHash = 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 state_transition_hash */ 1:
+                    message.stateTransitionHash = 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 state_transition_hash = 1; */
+        if (message.stateTransitionHash.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.stateTransitionHash);
+        /* 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.WaitForStateTransitionResultRequest.WaitForStateTransitionResultRequestV0
+ */
+export const WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0 = new WaitForStateTransitionResultRequest_WaitForStateTransitionResultRequestV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class WaitForStateTransitionResultResponse$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.WaitForStateTransitionResultResponse", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0 }
+        ]);
+    }
+    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.WaitForStateTransitionResultResponse.WaitForStateTransitionResultResponseV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0.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.WaitForStateTransitionResultResponse.WaitForStateTransitionResultResponseV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0.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.WaitForStateTransitionResultResponse
+ */
+export const WaitForStateTransitionResultResponse = new WaitForStateTransitionResultResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.WaitForStateTransitionResultResponse.WaitForStateTransitionResultResponseV0", [
+            { no: 1, name: "error", kind: "message", oneof: "result", T: () => StateTransitionBroadcastError },
+            { 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.StateTransitionBroadcastError error */ 1:
+                    message.result = {
+                        oneofKind: "error",
+                        error: StateTransitionBroadcastError.internalBinaryRead(reader, reader.uint32(), options, message.result.error)
+                    };
+                    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.StateTransitionBroadcastError error = 1; */
+        if (message.result.oneofKind === "error")
+            StateTransitionBroadcastError.internalBinaryWrite(message.result.error, 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.WaitForStateTransitionResultResponse.WaitForStateTransitionResultResponseV0
+ */
+export const WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0 = new WaitForStateTransitionResultResponse_WaitForStateTransitionResultResponseV0$Type();
 /**
  * @generated ServiceType for protobuf service org.dash.platform.dapi.v0.Platform
  */
@@ -8273,5 +8495,6 @@ export const Platform = new ServiceType("org.dash.platform.dapi.v0.Platform", [
     { name: "getIdentitiesTokenBalances", options: {}, I: GetIdentitiesTokenBalancesRequest, O: GetIdentitiesTokenBalancesResponse },
     { name: "getTokenContractInfo", options: {}, I: GetTokenContractInfoRequest, O: GetTokenContractInfoResponse },
     { name: "getTokenDirectPurchasePrices", options: {}, I: GetTokenDirectPurchasePricesRequest, O: GetTokenDirectPurchasePricesResponse },
-    { name: "getTokenTotalSupply", options: {}, I: GetTokenTotalSupplyRequest, O: GetTokenTotalSupplyResponse }
+    { name: "getTokenTotalSupply", options: {}, I: GetTokenTotalSupplyRequest, O: GetTokenTotalSupplyResponse },
+    { name: "waitForStateTransitionResult", options: {}, I: WaitForStateTransitionResultRequest, O: WaitForStateTransitionResultResponse }
 ]);

package/src/documents/create.js

@@ -1,4 +1,4 @@
 import { DocumentWASM } from 'pshenmic-dpp';
 export default function createDocument(dataContractId, documentType, data, owner, revision, documentId) {
-    return new DocumentWASM(data, documentType, revision ?? BigInt(1), dataContractId, owner, documentId);
+    return new DocumentWASM(data, documentType, revision ?? BigInt(1), dataContractId, owner, documentId, owner);
 }

package/src/identities/getIdentityPublicKeys.d.ts

@@ -1,4 +1,4 @@
 import { IdentityPublicKeyWASM } from 'pshenmic-dpp';
 import { IdentifierLike } from '../types.js';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-export default function getIdentityPublicKeys(grpcPool: GRPCConnectionPool, identifier: IdentifierLike): Promise<IdentityPublicKeyWASM[]>;
+export default function getIdentityPublicKeys(grpcPool: GRPCConnectionPool, identifier: IdentifierLike, keyIds?: number[]): Promise<IdentityPublicKeyWASM[]>;

package/src/identities/getIdentityPublicKeys.js

@@ -3,19 +3,28 @@ import { IdentifierWASM, PlatformVersionWASM, verifyIdentityKeysByIdentifierProo
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
-export default async function getIdentityPublicKeys(grpcPool, identifier) {
+export default async function getIdentityPublicKeys(grpcPool, identifier, keyIds) {
     const id = new IdentifierWASM(identifier);
+    let requestType = {
+        request: {
+            oneofKind: 'allKeys',
+            allKeys: {}
+        }
+    };
+    if (keyIds != null) {
+        requestType = {
+            request: {
+                oneofKind: 'specificKeys',
+                specificKeys: { keyIds }
+            }
+        };
+    }
     const getIdentityKeysRequest = GetIdentityKeysRequest.create({
         version: {
             oneofKind: 'v0',
             v0: {
                 identityId: id.bytes(),
-                requestType: KeyRequestType.create({
-                    request: {
-                        oneofKind: 'allKeys',
-                        allKeys: {}
-                    }
-                }),
+                requestType: KeyRequestType.create(requestType),
                 prove: true
             }
         }
@@ -33,7 +42,7 @@ export default async function getIdentityPublicKeys(grpcPool, identifier) {
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, identity } = verifyIdentityKeysByIdentifierProof(proof.grovedbProof, id.bytes(), null, false, false, true, null, null, PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, identity } = verifyIdentityKeysByIdentifierProof(proof.grovedbProof, id.bytes(), keyIds != null ? keyIds : null, false, false, true, null, null, PlatformVersionWASM.PLATFORM_V9);
     if (identity == null) {
         throw new Error(`Identity with identifier ${id.base58()} not found`);
     }

package/src/identities/index.d.ts

@@ -56,11 +56,12 @@ export declare class IdentitiesController {
     getIdentityContractNonce(identifier: IdentifierLike, dataContract: IdentifierLike): Promise<bigint>;
     /**
      * Retrieve given Identity's public keys
-     * @param identifier
+     * @param identifier {IdentifierLike}
+     * @param keyIds {=number[]} optional, specific keyIds to request
      *
      * @return {Promise<IdentityPublicKeyWASM[]>}
      */
-    getIdentityPublicKeys(identifier: IdentifierLike): Promise<IdentityPublicKeyWASM[]>;
+    getIdentityPublicKeys(identifier: IdentifierLike, keyIds?: number[]): Promise<IdentityPublicKeyWASM[]>;
     /**
      * Helper function for creating {StateTransitionWASM} for Identity transitions
      *

package/src/identities/index.js

@@ -84,12 +84,13 @@ export class IdentitiesController {
     }
     /**
      * Retrieve given Identity's public keys
-     * @param identifier
+     * @param identifier {IdentifierLike}
+     * @param keyIds {=number[]} optional, specific keyIds to request
      *
      * @return {Promise<IdentityPublicKeyWASM[]>}
      */
-    async getIdentityPublicKeys(identifier) {
-        return await getIdentityPublicKeys(this.grpcPool, identifier);
+    async getIdentityPublicKeys(identifier, keyIds) {
+        return await getIdentityPublicKeys(this.grpcPool, identifier, keyIds);
     }
     /**
      * Helper function for creating {StateTransitionWASM} for Identity transitions

package/src/stateTransitions/waitForStateTransitionResult.js

@@ -1,8 +1,51 @@
+import { BlockInfoWASM, PlatformVersionWASM, verifyStateTransitionResult } from 'pshenmic-dpp';
+import hexToBytes from '../utils/hexToBytes.js';
+import { WaitForStateTransitionResultRequest } from '../../proto/generated/platform.js';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
+import bytesToHex from '../utils/bytesToHex.js';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import { base64 } from '@scure/base';
 export default async function waitForStateTransitionResult(grpcPool, stateTransition) {
-    const url = `https://${grpcPool.network === 'mainnet' ? '' : 'testnet.'}platform-explorer.pshenmic.dev/waitForStateTransitionResult/${stateTransition.hash(false)}`;
-    const resp = await fetch(url);
-    if (resp.status !== 200) {
-        console.log(await resp.json());
-        throw new Error('Internal server error while waiting for state transition result');
+    const txHash = stateTransition.hash(false);
+    const waitForStateTransitionResultRequest = WaitForStateTransitionResultRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                stateTransitionHash: hexToBytes(txHash),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().waitForStateTransitionResult(waitForStateTransitionResultRequest);
+    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' && v0.result.oneofKind !== 'error') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be proof)');
+    }
+    if (v0.result.oneofKind === 'proof') {
+        const { result: { proof }, metadata } = v0;
+        if (metadata == null) {
+            throw new Error('Metadata not found');
+        }
+        const { timeMs, height, coreChainLockedHeight, epoch } = metadata;
+        const { rootHash, result } = verifyStateTransitionResult(proof.grovedbProof, stateTransition, new BlockInfoWASM(BigInt(timeMs), BigInt(height), coreChainLockedHeight, epoch), true, PlatformVersionWASM.PLATFORM_V9);
+        if (result == null) {
+            throw new Error('State transition result was null');
+        }
+        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 wait for state transition result query');
+        }
+    }
+    else if (v0.result.oneofKind === 'error') {
+        const { code, message, data } = v0.result.error;
+        throw new Error(`State transition ${txHash} failed to execute with code ${code}, message: ${message}, data: ${base64.encode(data)}`);
+    }
+    else {
+        throw new Error('Unexpected oneOfKind returned for waitForStateTransitionResult');
     }
 }

package/test/unit/Names.spec.js

@@ -2,6 +2,7 @@ import broadcast from '../../src/stateTransitions/broadcast.js';
 import { DocumentWASM, PrivateKeyWASM } from 'pshenmic-dpp';
 import { DashPlatformSDK } from '../../src/DashPlatformSDK.js';
 import sleep from '../../src/utils/sleep.js';
+jest.mock('../../src/stateTransitions/waitForStateTransitionResult');
 jest.mock('../../src/stateTransitions/broadcast');
 jest.mock('../../src/utils/sleep');
 let sdk;
@@ -11,13 +12,14 @@ describe('DPNS names', () => {
         // @ts-expect-error
         sleep.mockReturnValue(Promise.resolve());
         sdk.stateTransitions.broadcast = jest.fn();
+        sdk.stateTransitions.waitForStateTransitionResult = jest.fn();
     });
-    test('should be able to search names by DPNS name', async () => {
+    xtest('should be able to search names by DPNS name', async () => {
         const documents = await sdk.names.searchByName('xyz.dash');
         expect(documents?.length).toEqual(1);
         expect(documents[0]).toEqual(expect.any(DocumentWASM));
     });
-    test('should be able to search names by identity', async () => {
+    xtest('should be able to search names by identity', async () => {
         const documents = await sdk.names.searchByIdentity('36LGwPSXef8q8wpdnx4EdDeVNuqCYNAE9boDu5bxytsm');
         expect(documents?.length).toEqual(3);
         const [xyzDocument] = documents;