dash-platform-sdk 1.3.0-dev.9 → 1.4.0-dev.2

package/src/dataContracts/getDataContractByIdentifier.js

@@ -1,9 +1,9 @@
-import { DataContractWASM, IdentifierWASM, PlatformVersionWASM, verifyContractProof } from 'pshenmic-dpp';
+import { DataContractWASM, IdentifierWASM, verifyContractProof } from 'pshenmic-dpp';
 import { GetDataContractRequest } from '../../proto/generated/platform.js';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
-import { DPNS_DATA_CONTRACT_BYTES, DPNS_DATA_CONTRACT_ID } from '../constants.js';
+import { DPNS_DATA_CONTRACT_BYTES, DPNS_DATA_CONTRACT_ID, LATEST_PLATFORM_VERSION } from '../constants.js';
 export default async function getByIdentifier(grpcPool, identifier) {
     const id = new IdentifierWASM(identifier);
     if (id.base58() === DPNS_DATA_CONTRACT_ID) {
@@ -31,7 +31,7 @@ export default async function getByIdentifier(grpcPool, identifier) {
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, dataContract } = verifyContractProof(proof.grovedbProof, undefined, false, false, id.bytes(), PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, dataContract } = verifyContractProof(proof.grovedbProof, undefined, false, false, id.bytes(), LATEST_PLATFORM_VERSION);
     if (dataContract == null) {
         throw new Error(`Data Contract with identifier ${id.base58()} not found`);
     }

package/src/dataContracts/index.d.ts

@@ -1,5 +1,5 @@
-import { DataContractConfig, IdentifierLike } from '../types.js';
-import { DataContractWASM, PlatformVersionWASM, StateTransitionWASM, TokenConfigurationWASM } from 'pshenmic-dpp';
+import { DataContractConfig, IdentifierLike } from '../../types.js';
+import { DataContractTokens, DataContractWASM, PlatformVersionWASM, StateTransitionWASM } from 'pshenmic-dpp';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 /**
  * Collection of methods necessary to work with Data Contracts in the network,
@@ -25,7 +25,7 @@ export declare class DataContractsController {
      *
      * @return {DataContractWASM}
      */
-    create(ownerId: IdentifierLike, identityNonce: bigint, schema: object, fullValidation?: boolean, tokenConfiguration?: TokenConfigurationWASM, config?: DataContractConfig, platformVersion?: PlatformVersionWASM): DataContractWASM;
+    create(ownerId: IdentifierLike, identityNonce: bigint, schema: object, fullValidation?: boolean, tokenConfiguration?: DataContractTokens[], config?: DataContractConfig, platformVersion?: PlatformVersionWASM): DataContractWASM;
     /**
      * Retrieves a Data Contract by an identifier from the network
      *

package/src/documents/create.d.ts

@@ -1,3 +1,3 @@
 import { DocumentWASM } from 'pshenmic-dpp';
-import { IdentifierLike } from '../types.js';
+import { IdentifierLike } from '../../types.js';
 export default function createDocument(dataContractId: IdentifierLike, documentType: string, data: object, owner: IdentifierLike, revision?: bigint, documentId?: IdentifierLike): DocumentWASM;

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/documents/createStateTransition.d.ts

@@ -1,3 +1,3 @@
 import { DocumentWASM, StateTransitionWASM } from 'pshenmic-dpp';
-import { DocumentTransitionParams } from '../types.js';
+import { DocumentTransitionParams } from '../../types.js';
 export default function createStateTransition(document: DocumentWASM, type: 'create' | 'replace' | 'delete' | 'updatePrice' | 'transfer' | 'purchase', params: DocumentTransitionParams): StateTransitionWASM;

package/src/documents/index.d.ts

@@ -1,5 +1,5 @@
-import { DocumentTransitionParams, IdentifierLike } from '../types.js';
-import { DocumentWASM, IdentifierWASM, StateTransitionWASM } from 'pshenmic-dpp';
+import { DocumentTransitionParams, IdentifierLike } from '../../types.js';
+import { DocumentWASM, IdentifierWASM, StateTransitionWASM, WhereClause } from 'pshenmic-dpp';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 /**
  * Collection of methods to work with documents like creation, querying or preparing a transition action
@@ -33,7 +33,7 @@ export declare class DocumentsController {
      * @param startAt {IdentifierLike=} Optional offset, where startAt is an identifier of the document. Use identifier of last item in previous response
      * @param startAfter {IdentifierLike=} Same as previous, but with exclusion. Cannot be set if startAt already provided
      */
-    query(dataContractId: IdentifierLike, documentType: string, where?: ArrayLike<any>, orderBy?: ArrayLike<any>, limit?: number, startAt?: IdentifierWASM, startAfter?: IdentifierWASM): Promise<DocumentWASM[]>;
+    query(dataContractId: IdentifierLike, documentType: string, where?: WhereClause[], orderBy?: string[][], limit?: number, startAt?: IdentifierWASM, startAfter?: IdentifierWASM): Promise<DocumentWASM[]>;
     /**
      * Helper function for creating {StateTransitionWASM} from documents. It may be used to create any of 6 Document Transition actions:
      *

package/src/documents/query.d.ts

@@ -1,4 +1,4 @@
-import { DocumentWASM, IdentifierWASM } from 'pshenmic-dpp';
-import { IdentifierLike } from '../types.js';
+import { DocumentWASM, IdentifierWASM, WhereClause } from 'pshenmic-dpp';
+import { IdentifierLike } from '../../types.js';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-export default function query(grpcPool: GRPCConnectionPool, dataContractId: IdentifierLike, documentTypeName: string, where?: ArrayLike<any>, orderBy?: ArrayLike<any>, limit?: number | undefined, startAt?: IdentifierWASM, startAfter?: IdentifierWASM): Promise<DocumentWASM[]>;
+export default function query(grpcPool: GRPCConnectionPool, dataContractId: IdentifierLike, documentTypeName: string, where?: WhereClause[], orderBy?: string[][], limit?: number | undefined, startAt?: IdentifierWASM, startAfter?: IdentifierWASM): Promise<DocumentWASM[]>;

package/src/documents/query.js

@@ -1,6 +1,6 @@
 import { GetDocumentsRequest } from '../../proto/generated/platform.js';
-import { IdentifierWASM, PlatformVersionWASM, verifyDocumentsProof } from 'pshenmic-dpp';
-import { DAPI_DEFAULT_LIMIT } from '../constants.js';
+import { IdentifierWASM, verifyDocumentsProof } from 'pshenmic-dpp';
+import { DAPI_DEFAULT_LIMIT, LATEST_PLATFORM_VERSION } from '../constants.js';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
@@ -52,7 +52,7 @@ export default async function query(grpcPool, dataContractId, documentTypeName,
         throw new Error('Metadata not found');
     }
     const startAtIncluded = startAt != null;
-    const { rootHash, documents } = verifyDocumentsProof(proof.grovedbProof, dataContract, documentTypeName, where, orderBy, limit, startAt?.bytes(), startAtIncluded, BigInt(metadata?.timeMs), PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, documents } = verifyDocumentsProof(proof.grovedbProof, dataContract, documentTypeName, where, orderBy, limit, startAt?.bytes(), startAtIncluded, BigInt(metadata?.timeMs), LATEST_PLATFORM_VERSION);
     const quorumPublicKey = await getQuorumPublicKey(grpcPool.network, proof.quorumType, bytesToHex(proof.quorumHash));
     const verify = await verifyTenderdashProof(proof, metadata, rootHash, quorumPublicKey);
     if (!verify) {

package/src/grpcConnectionPool.d.ts

@@ -1,5 +1,5 @@
 import { PlatformClient } from '../proto/generated/platform.client.js';
-import { Network } from './types.js';
+import { Network } from '../types.js';
 export type MasternodeList = Record<string, MasternodeInfo>;
 export interface GRPCOptions {
     poolLimit: 5;

package/src/identities/createStateTransition.d.ts

@@ -1,3 +1,3 @@
 import { StateTransitionWASM } from 'pshenmic-dpp';
-import { IdentityTransitionParams } from '../types.js';
+import { IdentityTransitionParams } from '../../types.js';
 export default function createStateTransition(type: 'create' | 'update' | 'topUp' | 'creditTransfer' | 'withdrawal', params: IdentityTransitionParams): StateTransitionWASM;

package/src/identities/getIdentityBalance.d.ts

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

package/src/identities/getIdentityBalance.js

@@ -1,8 +1,9 @@
 import { GetIdentityBalanceRequest } from '../../proto/generated/platform.js';
-import { IdentifierWASM, PlatformVersionWASM, verifyIdentityBalanceProof } from 'pshenmic-dpp';
+import { IdentifierWASM, verifyIdentityBalanceProof } from 'pshenmic-dpp';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
 export default async function getIdentityBalance(grpcPool, identifier) {
     const id = new IdentifierWASM(identifier);
     const getIdentityBalanceRequest = GetIdentityBalanceRequest.create({
@@ -27,7 +28,7 @@ export default async function getIdentityBalance(grpcPool, identifier) {
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, balance } = verifyIdentityBalanceProof(proof.grovedbProof, id.bytes(), true, PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, balance } = verifyIdentityBalanceProof(proof.grovedbProof, id.bytes(), true, LATEST_PLATFORM_VERSION);
     if (balance == null) {
         throw new Error(`Failed to fetch balance for identifier ${id.base58()}`);
     }

package/src/identities/getIdentityByIdentifier.d.ts

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

package/src/identities/getIdentityByIdentifier.js

@@ -1,8 +1,9 @@
 import { GetIdentityRequest } from '../../proto/generated/platform.js';
-import { IdentifierWASM, PlatformVersionWASM, verifyIdentityByIdentifierProof } from 'pshenmic-dpp';
+import { IdentifierWASM, verifyIdentityByIdentifierProof } from 'pshenmic-dpp';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
 export default async function getIdentityByIdentifier(grpcPool, identifier) {
     const id = new IdentifierWASM(identifier);
     const getIdentityRequest = GetIdentityRequest.create({
@@ -27,7 +28,7 @@ export default async function getIdentityByIdentifier(grpcPool, identifier) {
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, identity } = verifyIdentityByIdentifierProof(proof.grovedbProof, id, true, PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, identity } = verifyIdentityByIdentifierProof(proof.grovedbProof, id, true, LATEST_PLATFORM_VERSION);
     if (identity == null) {
         throw new Error(`Identity with identifier ${id.base58()} not found`);
     }

package/src/identities/getIdentityByNonUniquePublicKeyHash.js

@@ -1,10 +1,11 @@
 import { GetIdentityByNonUniquePublicKeyHashRequest } from '../../proto/generated/platform.js';
-import { PlatformVersionWASM, verifyIdentifierByNonUniquePublicKeyHashProof } from 'pshenmic-dpp';
+import { verifyIdentifierByNonUniquePublicKeyHashProof } from 'pshenmic-dpp';
 import hexToBytes from '../utils/hexToBytes.js';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
 import getIdentityByIdentifier from './getIdentityByIdentifier.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
 export default async function getIdentityByNonUniquePublicKeyHash(grpcPool, hex) {
     const getIdentityByNonUniquePublicKeyHashRequest = GetIdentityByNonUniquePublicKeyHashRequest.create({
         version: {
@@ -31,7 +32,7 @@ export default async function getIdentityByNonUniquePublicKeyHash(grpcPool, hex)
     if (proof.grovedbIdentityPublicKeyHashProof == null) {
         throw new Error('GroveDB proof not found for identity by non unique public key request');
     }
-    const { rootHash, identifier } = verifyIdentifierByNonUniquePublicKeyHashProof(proof.grovedbIdentityPublicKeyHashProof.grovedbProof, false, hexToBytes(hex), undefined, PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, identifier } = verifyIdentifierByNonUniquePublicKeyHashProof(proof.grovedbIdentityPublicKeyHashProof.grovedbProof, false, hexToBytes(hex), undefined, LATEST_PLATFORM_VERSION);
     if (identifier == null) {
         throw new Error(`Identity with non unique public key hash ${hex} not found`);
     }

package/src/identities/getIdentityByPublicKeyHash.js

@@ -1,9 +1,10 @@
 import { GetIdentityByPublicKeyHashRequest } from '../../proto/generated/platform.js';
-import { PlatformVersionWASM, verifyIdentityByUniqueKeyHashProof } from 'pshenmic-dpp';
+import { verifyIdentityByUniqueKeyHashProof } from 'pshenmic-dpp';
 import hexToBytes from '../utils/hexToBytes.js';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
 export default async function getIdentityByPublicKeyHash(grpcPool, hex) {
     const getIdentityByPublicKeyHashRequest = GetIdentityByPublicKeyHashRequest.create({
         version: {
@@ -27,7 +28,7 @@ export default async function getIdentityByPublicKeyHash(grpcPool, hex) {
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, identity } = verifyIdentityByUniqueKeyHashProof(proof.grovedbProof, hexToBytes(hex), PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, identity } = verifyIdentityByUniqueKeyHashProof(proof.grovedbProof, hexToBytes(hex), LATEST_PLATFORM_VERSION);
     if (identity == null) {
         throw new Error(`Identity with public key hash ${hex} not found`);
     }

package/src/identities/getIdentityContractNonce.d.ts

@@ -1,3 +1,3 @@
-import { IdentifierLike } from '../types.js';
+import { IdentifierLike } from '../../types.js';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function getIdentityContractNonce(grpcPool: GRPCConnectionPool, identity: IdentifierLike, dataContract: IdentifierLike): Promise<bigint>;

package/src/identities/getIdentityContractNonce.js

@@ -1,8 +1,9 @@
 import { GetIdentityContractNonceRequest } from '../../proto/generated/platform.js';
-import { IdentifierWASM, PlatformVersionWASM, verifyIdentityContractNonceProof } from 'pshenmic-dpp';
+import { IdentifierWASM, verifyIdentityContractNonceProof } from 'pshenmic-dpp';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
 const IDENTITY_CONTRACT_NONCE_VALUE_FILTER = BigInt(0xFFFFFFFFFF);
 export default async function getIdentityContractNonce(grpcPool, identity, dataContract) {
     const identityIdentifier = new IdentifierWASM(identity);
@@ -30,7 +31,7 @@ export default async function getIdentityContractNonce(grpcPool, identity, dataC
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, contractNonce } = verifyIdentityContractNonceProof(proof.grovedbProof, identityIdentifier.bytes(), dataContractIdentifier.bytes(), true, PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, contractNonce } = verifyIdentityContractNonceProof(proof.grovedbProof, identityIdentifier.bytes(), dataContractIdentifier.bytes(), true, LATEST_PLATFORM_VERSION);
     if (contractNonce == null) {
         return BigInt(0);
     }

package/src/identities/getIdentityNonce.d.ts

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

package/src/identities/getIdentityNonce.js

@@ -1,8 +1,9 @@
 import { GetIdentityNonceRequest } from '../../proto/generated/platform.js';
-import { IdentifierWASM, PlatformVersionWASM, verifyIdentityNonceProof } from 'pshenmic-dpp';
+import { IdentifierWASM, verifyIdentityNonceProof } from 'pshenmic-dpp';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
 const IDENTITY_NONCE_VALUE_FILTER = BigInt(0xFFFFFFFFFF);
 export default async function getIdentityNonce(grpcPool, identifier) {
     const id = new IdentifierWASM(identifier);
@@ -28,7 +29,7 @@ export default async function getIdentityNonce(grpcPool, identifier) {
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, nonce } = verifyIdentityNonceProof(proof.grovedbProof, id.bytes(), true, PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, nonce } = verifyIdentityNonceProof(proof.grovedbProof, id.bytes(), true, LATEST_PLATFORM_VERSION);
     if (nonce == null) {
         return BigInt(0);
     }

package/src/identities/getIdentityPublicKeys.d.ts

@@ -1,4 +1,4 @@
 import { IdentityPublicKeyWASM } from 'pshenmic-dpp';
-import { IdentifierLike } from '../types.js';
+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

@@ -1,21 +1,31 @@
 import { GetIdentityKeysRequest, KeyRequestType } from '../../proto/generated/platform.js';
-import { IdentifierWASM, PlatformVersionWASM, verifyIdentityKeysByIdentifierProof } from 'pshenmic-dpp';
+import { IdentifierWASM, verifyIdentityKeysByIdentifierProof } from 'pshenmic-dpp';
 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) {
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
+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 +43,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, LATEST_PLATFORM_VERSION);
     if (identity == null) {
         throw new Error(`Identity with identifier ${id.base58()} not found`);
     }

package/src/identities/index.d.ts

@@ -1,4 +1,4 @@
-import { IdentifierLike, IdentityTransitionParams } from '../types.js';
+import { IdentifierLike, IdentityTransitionParams } from '../../types.js';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 import { IdentityPublicKeyWASM, IdentityWASM, StateTransitionWASM } from 'pshenmic-dpp';
 /**
@@ -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

@@ -4,7 +4,7 @@ import getIdentityNonce from './getIdentityNonce.js';
 import getIdentityBalance from './getIdentityBalance.js';
 import getIdentityByPublicKeyHash from './getIdentityByPublicKeyHash.js';
 import getIdentityByIdentifier from './getIdentityByIdentifier.js';
-import { AssetLockProofWASM, ContractBoundsWASM, CoreScriptWASM, IdentifierWASM, IdentityPublicKeyInCreationWASM, OutPointWASM, PoolingWASM } from 'pshenmic-dpp';
+import { AssetLockProofWASM, ContractBoundsWASM, CoreScriptWASM, IdentifierWASM, IdentityPublicKeyInCreationWASM, OutPointWASM } from 'pshenmic-dpp';
 import createStateTransition from './createStateTransition.js';
 import getIdentityByNonUniquePublicKeyHash from './getIdentityByNonUniquePublicKeyHash.js';
 import hexToBytes from '../utils/hexToBytes.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
@@ -143,8 +144,7 @@ export class IdentitiesController {
             params.recipientId = new IdentifierWASM(params.recipientId);
         }
         if (type === 'withdrawal') {
-            // @ts-expect-error
-            params.pooling = params.pooling != null ? PoolingWASM[params.pooling] : PoolingWASM.Standard;
+            params.pooling = params.pooling ?? 'Standard';
             params.coreFeePerByte = params.coreFeePerByte ?? 1;
             params.outputScript = params.outputScript ?? (params.withdrawalAddress != null ? CoreScriptWASM.newP2PKH(base58.decode(params.withdrawalAddress).slice(1, 21)) : undefined);
         }

package/src/keyPair/index.d.ts

@@ -1,5 +1,5 @@
 import { HDKey } from '@scure/bip32';
-import { Network } from '../types.js';
+import { Network } from '../../types.js';
 /**
  * Collection of functions to work with private keys and seed phrases
  *

package/src/names/index.d.ts

@@ -1,6 +1,6 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 import { DocumentWASM, PrivateKeyWASM } from 'pshenmic-dpp';
-import { IdentifierLike } from '../types.js';
+import { IdentifierLike } from '../../types.js';
 /**
  * Functions related to DPNS names (usernames)
  *

package/src/node/epochs.js

@@ -1,9 +1,10 @@
 import { GetEpochsInfoRequest } from '../../proto/generated/platform.js';
-import { PlatformVersionWASM, verifyEpochsInfoProof } from 'pshenmic-dpp';
+import { verifyEpochsInfoProof } from 'pshenmic-dpp';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
 import { UInt32Value } from '../../proto/generated/google/protobuf/wrappers.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
 export default async function epochs(grpcPool, count, ascending, start) {
     const getEpochsInfoRequest = GetEpochsInfoRequest.create({
         version: {
@@ -29,7 +30,7 @@ export default async function epochs(grpcPool, count, ascending, start) {
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, epochsInfo } = verifyEpochsInfoProof(proof.grovedbProof, metadata.epoch, start, count, ascending, PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, epochsInfo } = verifyEpochsInfoProof(proof.grovedbProof, metadata.epoch, start, count, ascending, LATEST_PLATFORM_VERSION);
     const quorumPublicKey = await getQuorumPublicKey(grpcPool.network, proof.quorumType, bytesToHex(proof.quorumHash));
     const verify = await verifyTenderdashProof(proof, metadata, rootHash, quorumPublicKey);
     if (!verify) {

package/src/node/index.d.ts

@@ -1,5 +1,5 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-import { Network, NodeStatus } from '../types.js';
+import { Network, NodeStatus } from '../../types.js';
 import { EpochInfo } from './epochs.js';
 /**
  * Node controller for requesting information about DAPI node

package/src/node/status.d.ts

@@ -1,3 +1,3 @@
-import { NodeStatus } from '../types.js';
+import { NodeStatus } from '../../types.js';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function status(grpcPool: GRPCConnectionPool): Promise<NodeStatus>;

package/src/node/totalCredits.d.ts

@@ -1,3 +1,3 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-import { Network } from '../types.js';
+import { Network } from '../../types.js';
 export default function totalCredits(grpcPool: GRPCConnectionPool, network: Network): Promise<bigint>;

package/src/node/totalCredits.js

@@ -1,6 +1,6 @@
 import { GetTotalCreditsInPlatformRequest } from '../../proto/generated/platform.js';
-import { HALVING_INTERVAL, MAINNET_ACTIVATION_HEIGHT, TESTNET_ACTIVATION_HEIGHT } from '../constants.js';
-import { PlatformVersionWASM, verifyTotalCreditsProof } from 'pshenmic-dpp';
+import { HALVING_INTERVAL, LATEST_PLATFORM_VERSION, MAINNET_ACTIVATION_HEIGHT, TESTNET_ACTIVATION_HEIGHT } from '../constants.js';
+import { verifyTotalCreditsProof } from 'pshenmic-dpp';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
@@ -25,7 +25,7 @@ export default async function totalCredits(grpcPool, network) {
         throw new Error('Metadata not found');
     }
     const activationHeight = network === 'testnet' ? TESTNET_ACTIVATION_HEIGHT : MAINNET_ACTIVATION_HEIGHT;
-    const { rootHash, totalCredits } = verifyTotalCreditsProof(proof.grovedbProof, HALVING_INTERVAL, activationHeight, Number(metadata.height), PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, totalCredits } = verifyTotalCreditsProof(proof.grovedbProof, HALVING_INTERVAL, activationHeight, Number(metadata.height), LATEST_PLATFORM_VERSION);
     const quorumPublicKey = await getQuorumPublicKey(grpcPool.network, proof.quorumType, bytesToHex(proof.quorumHash));
     const verify = await verifyTenderdashProof(proof, metadata, rootHash, quorumPublicKey);
     if (!verify) {

package/src/stateTransitions/broadcast.js

@@ -1,6 +1,6 @@
 import { BroadcastStateTransitionRequest } from '../../proto/generated/platform.js';
 export default async function broadcast(grpcPool, stateTransition) {
-    if (stateTransition.signature.length === 0) {
+    if (stateTransition.signature?.length === 0) {
         throw new Error('State Transition is not signed');
     }
     const broadcastStateTransitionRequest = BroadcastStateTransitionRequest.create({

package/src/stateTransitions/waitForStateTransitionResult.js

@@ -1,8 +1,71 @@
+import { BatchTransitionWASM, MasternodeVoteTransitionWASM, 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';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
+import getDataContractByIdentifier from '../dataContracts/getDataContractByIdentifier.js';
 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 knownContracts = [];
+        if (stateTransition.getActionType() === 'BATCH') {
+            const batchTransition = BatchTransitionWASM.fromStateTransition(stateTransition);
+            const [transition] = batchTransition.transitions;
+            const dataContract = await getDataContractByIdentifier(grpcPool, transition.dataContractId);
+            knownContracts.push(dataContract);
+        }
+        if (stateTransition.getActionType() === 'MASTERNODE_VOTE') {
+            const masternodeVote = MasternodeVoteTransitionWASM.fromStateTransition(stateTransition);
+            const dataContract = await getDataContractByIdentifier(grpcPool, masternodeVote.vote.votePoll.contractId);
+            knownContracts.push(dataContract);
+        }
+        const blockInfo = {
+            timeMs: BigInt(timeMs),
+            height: BigInt(height),
+            coreHeight: coreChainLockedHeight,
+            epoch
+        };
+        const { rootHash, result } = verifyStateTransitionResult(proof.grovedbProof, stateTransition, blockInfo, knownContracts, LATEST_PLATFORM_VERSION);
+        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 ${String(code)}, message: ${String(message)}, data: ${base64.encode(data)}`);
+    }
+    else {
+        throw new Error('Unexpected oneOfKind returned for waitForStateTransitionResult');
     }
 }

package/src/tokens/createStateTransition.d.ts

@@ -1,3 +1,3 @@
 import { IdentifierWASM, StateTransitionWASM, TokenBaseTransitionWASM } from 'pshenmic-dpp';
-import { TokenTransitionParams, TokenTransitionType } from '../types.js';
+import { TokenTransitionParams, TokenTransitionType } from '../../types.js';
 export default function createStateTransition(base: TokenBaseTransitionWASM, ownerId: IdentifierWASM, type: TokenTransitionType, params: TokenTransitionParams): StateTransitionWASM;

package/src/tokens/getIdentitiesTokenBalances.d.ts

@@ -1,8 +1,8 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-import { IdentifierLike } from '../types.js';
+import { IdentifierLike } from '../../types.js';
 import { IdentifierWASM } from 'pshenmic-dpp';
 export interface IdentitiesTokenBalances {
     identityId: IdentifierWASM;
-    balance?: string | undefined;
+    balance?: bigint | undefined;
 }
 export default function getIdentitiesTokenBalances(grpcPool: GRPCConnectionPool, identifiers: IdentifierLike[], tokenIdentifier: IdentifierLike): Promise<IdentitiesTokenBalances[]>;

package/src/tokens/getIdentitiesTokenBalances.js

@@ -1,8 +1,9 @@
 import { GetIdentitiesTokenBalancesRequest } from '../../proto/generated/platform.js';
-import { IdentifierWASM, PlatformVersionWASM, verifyTokenBalancesForIdentitiesProof } from 'pshenmic-dpp';
+import { IdentifierWASM, verifyTokenBalancesForIdentitiesProof } from 'pshenmic-dpp';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
 export default async function getIdentitiesTokenBalances(grpcPool, identifiers, tokenIdentifier) {
     const ids = identifiers.map(identifier => new IdentifierWASM(identifier));
     const tokenId = new IdentifierWASM(tokenIdentifier);
@@ -29,15 +30,15 @@ export default async function getIdentitiesTokenBalances(grpcPool, identifiers,
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, balances } = verifyTokenBalancesForIdentitiesProof(proof.grovedbProof, tokenId, true, ids, PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, balances } = verifyTokenBalancesForIdentitiesProof(proof.grovedbProof, tokenId, true, ids, 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 balances
-        .map((identityTokenBalance) => ({
-        identityId: new IdentifierWASM(identityTokenBalance.identityId),
-        balance: identityTokenBalance.balance
+        .map(({ id, balance }) => ({
+        identityId: new IdentifierWASM(id),
+        balance
     }));
 }