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

package/src/DashPlatformSDK.js

@@ -0,0 +1,101 @@
+import GRPCConnectionPool from './grpcConnectionPool';
+import { IdentitiesController } from './identities';
+import { StateTransitionsController } from './stateTransitions';
+import { DocumentsController } from './documents';
+import { UtilsController } from './utils';
+import { KeyPairController } from './keyPair';
+import { NodeController } from './node';
+import { NamesController } from './names';
+import { DataContractsController } from './dataContracts';
+import { ContestedResourcesController } from './contestedResources';
+import { TokensController } from './tokens';
+import { VotingController } from './voting';
+/**
+ * Javascript SDK for that let you interact with a Dash Platform blockchain
+ */
+export class DashPlatformSDK {
+    network;
+    /** @ignore **/
+    grpcPool;
+    /** @ignore **/
+    options;
+    contestedResources;
+    stateTransitions;
+    dataContracts;
+    identities;
+    documents;
+    keyPair;
+    voting;
+    tokens;
+    utils;
+    names;
+    signer;
+    node;
+    /**
+     * Constructs a new DashPlatformSDK instance, optionally pass options
+     * if you want to configure the SDK instance (network, dapiUrl, signer)
+      *
+     * @param options {SDKOptions=}
+     */
+    constructor(options) {
+        if (options != null && (options.network == null || !['testnet', 'mainnet'].includes(options.network))) {
+            throw new Error('If options is passed, network must be set (either mainnet or testnet)');
+        }
+        this.network = options?.network ?? 'mainnet';
+        this.signer = options?.signer;
+        this.options = options;
+        this.utils = new UtilsController();
+        // Compatibility
+        if (options?.dapiUrl != null && ((options?.grpc) == null)) {
+            // @ts-expect-error
+            this.options.grpc = { dapiUrl: options.dapiUrl };
+        }
+        this.grpcPool = new GRPCConnectionPool(this.network, this.options?.grpc);
+        this._initialize(this.grpcPool, this.network);
+    }
+    /**
+     * @private
+     *
+     * Internal function to initialize SDK GRPC connection pool. Is not meant to be used outside the SDK
+     *
+     * @param grpcPool
+     * @param network
+     */
+    _initialize(grpcPool, network) {
+        this.grpcPool = grpcPool;
+        this.stateTransitions = new StateTransitionsController(grpcPool);
+        this.contestedResources = new ContestedResourcesController(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.tokens = new TokensController(grpcPool);
+        this.names = new NamesController(grpcPool);
+        this.keyPair = new KeyPairController();
+    }
+    setSigner(signer) {
+        this.signer = signer;
+    }
+    /**
+     * Get currently used network
+     *
+     * @return {string}
+     */
+    getNetwork() {
+        return this.network;
+    }
+    /**
+     * Switches a network that SDK is currently connected to
+     *
+     * @param network {string}
+     */
+    setNetwork(network) {
+        if (network !== 'testnet' && network !== 'mainnet') {
+            throw new Error('Unknown network, should be mainnet or testnet');
+        }
+        this.network = network;
+        const grpcPool = new GRPCConnectionPool(this.network, this.options?.grpc);
+        this._initialize(grpcPool, this.network);
+    }
+}

package/src/constants.js

@@ -0,0 +1,10 @@
+/**
+ * Default amount of documents to retrieve from DAPI
+ */
+export const DAPI_DEFAULT_LIMIT = 100;
+export const HALVING_INTERVAL = 210240;
+export const TESTNET_ACTIVATION_HEIGHT = 1066900;
+export const MAINNET_ACTIVATION_HEIGHT = 2128896;
+export const GRPC_DEFAULT_POOL_LIMIT = 5;
+export const DPNS_DATA_CONTRACT_ID = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
+export const DPNS_DATA_CONTRACT_BYTES = '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';

package/src/contestedResources/createStateTransition.js

@@ -0,0 +1,6 @@
+import { IdentifierWASM, MasternodeVoteTransitionWASM } from 'pshenmic-dpp';
+export default function createStateTransition(voteWASM, proTxHash, identityNonce) {
+    const voterIdentity = IdentifierWASM.fromHex(proTxHash);
+    const masternodeVoteTransition = new MasternodeVoteTransitionWASM(proTxHash, voterIdentity, voteWASM, identityNonce);
+    return masternodeVoteTransition.toStateTransition();
+}

package/src/contestedResources/getContestedResourceVoteState.js

@@ -0,0 +1,72 @@
+import { GetContestedResourceVoteStateRequest } from '../../proto/generated/platform';
+import { DocumentWASM, IdentifierWASM, PlatformVersionWASM, verifyVotePollVoteStateProof } from 'pshenmic-dpp';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+export default async function getContestedResourceVoteState(grpcPool, contract, documentTypeName, indexName, indexValues, resultType, allowIncludeLockedAndAbstainingVoteTally, startAtIdentifierInfo, count) {
+    if (startAtIdentifierInfo != null) {
+        startAtIdentifierInfo = {
+            startIdentifier: (new IdentifierWASM(startAtIdentifierInfo.startIdentifier)).bytes(),
+            startIdentifierIncluded: startAtIdentifierInfo.startIdentifierIncluded
+        };
+    }
+    const getContestedResourceVoteStateRequest = GetContestedResourceVoteStateRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                contractId: contract.id.bytes(),
+                documentTypeName,
+                indexName,
+                indexValues,
+                resultType: resultType,
+                allowIncludeLockedAndAbstainingVoteTally,
+                startAtIdentifierInfo,
+                count,
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getContestedResourceVoteState(getContestedResourceVoteStateRequest);
+    const { version } = response;
+    if (version.oneofKind !== 'v0') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be v0)');
+    }
+    const { v0 } = version;
+    if (v0.result.oneofKind !== 'proof') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be proof)');
+    }
+    const { result: { proof }, metadata } = v0;
+    if (metadata == null) {
+        throw new Error('Metadata not found');
+    }
+    const { rootHash, result } = verifyVotePollVoteStateProof(proof.grovedbProof, contract, documentTypeName, indexName, indexValues, resultType, allowIncludeLockedAndAbstainingVoteTally, count, startAtIdentifierInfo, PlatformVersionWASM.PLATFORM_V9);
+    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');
+    }
+    const { contenders } = result ?? { contenders: [] };
+    const { winner } = result ?? { winner: undefined };
+    if (contenders.length === 0) {
+        throw new Error('Vote state not found');
+    }
+    return {
+        contenders: contenders.map(contender => ({
+            ...contender,
+            identifier: contender.identityId,
+            document: contender.serializedDocument != null ? DocumentWASM.fromBytes(contender.serializedDocument, contract, documentTypeName, PlatformVersionWASM.PLATFORM_V9) : undefined
+        })),
+        abstainVoteTally: result?.abstainingVoteTally ?? 0,
+        lockVoteTally: result?.lockedVoteTally ?? 0,
+        finishedVoteInfo: (winner != null)
+            ? {
+                type: winner.type,
+                wonByIdentityId: winner.identityId != null ? new IdentifierWASM(winner.identityId) : undefined,
+                finishedAtBlockHeight: winner.blockInfo.height,
+                finishedAtCoreBlockHeight: winner.blockInfo.coreHeight,
+                finishedAtBlockTimeMs: winner.blockInfo.timeMs,
+                finishedAtEpoch: winner.blockInfo.epoch
+            }
+            : undefined
+    };
+}

package/src/contestedResources/index.js

@@ -0,0 +1,30 @@
+import getContestedResourceVoteState from './getContestedResourceVoteState';
+/**
+ * Contested Resources controller for requesting information about contested resources
+ *
+ * @hideconstructor
+ */
+export class ContestedResourcesController {
+    /** @ignore **/
+    grpcPool;
+    constructor(grpcPool) {
+        this.grpcPool = grpcPool;
+    }
+    /**
+     * Retrieves an info about vote state for contested resource
+     *
+     * @param contract {DataContractWASM} - instance of contract with contested resource
+     * @param documentTypeName {string} - document type name of contested resource
+     * @param indexName {string} - index name of contested resource
+     * @param indexValuesBytes {Uint8Array[]} - Array of contested values in bytes
+     * @param resultType {ContestedResourceVoteState} - enum for result info
+     * @param allowIncludeLockedAndAbstainingVoteTally {boolean}
+     * @param startAtIdentifierInfo {StartAtIdentifierInfo=}
+     * @param count {number=}
+     *
+     * @return {Promise<ContestedResourceVoteState>}
+     */
+    async getContestedResourceVoteState(contract, documentTypeName, indexName, indexValuesBytes, resultType, allowIncludeLockedAndAbstainingVoteTally, startAtIdentifierInfo, count) {
+        return await getContestedResourceVoteState(this.grpcPool, contract, documentTypeName, indexName, indexValuesBytes, resultType, allowIncludeLockedAndAbstainingVoteTally, startAtIdentifierInfo, count);
+    }
+}

package/src/dataContracts/create.js

@@ -0,0 +1,11 @@
+import { DataContractWASM, IdentifierWASM, PlatformVersionWASM } from 'pshenmic-dpp';
+export default function createDataContract(ownerId, identityNonce, schema, tokenConfiguration, config, fullValidation, platformVersion) {
+    const id = new IdentifierWASM(ownerId);
+    const dataContract = new DataContractWASM(id, identityNonce, schema, 
+    // we don't know what that param means yet
+    null, tokenConfiguration, fullValidation ?? true, platformVersion ?? PlatformVersionWASM.PLATFORM_V9);
+    if (config != null) {
+        dataContract.setConfig(config, platformVersion);
+    }
+    return dataContract;
+}

package/src/dataContracts/createStateTransition.js

@@ -0,0 +1,19 @@
+import { DataContractCreateTransitionWASM, DataContractUpdateTransitionWASM } from 'pshenmic-dpp';
+export var DataContractTransitionType;
+(function (DataContractTransitionType) {
+    DataContractTransitionType[DataContractTransitionType["Create"] = 0] = "Create";
+    DataContractTransitionType[DataContractTransitionType["Update"] = 1] = "Update";
+})(DataContractTransitionType || (DataContractTransitionType = {}));
+const dataContractTransitionsMap = {
+    create: DataContractCreateTransitionWASM,
+    update: DataContractUpdateTransitionWASM
+};
+export default function createStateTransition(dataContract, type, identityNonce) {
+    const TransitionClass = dataContractTransitionsMap[type];
+    if (TransitionClass == null) {
+        throw new Error(`Unknown DataContract transition type: ${type}. Should be 'create' or 'update'.`);
+    }
+    // @ts-expect-error
+    const dataContractTransition = new TransitionClass(dataContract, identityNonce);
+    return dataContractTransition.toStateTransition();
+}

package/src/dataContracts/getDataContractByIdentifier.js

@@ -0,0 +1,44 @@
+import { DataContractWASM, IdentifierWASM, PlatformVersionWASM, verifyContractProof } from 'pshenmic-dpp';
+import { GetDataContractRequest } from '../../proto/generated/platform';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+import { DPNS_DATA_CONTRACT_BYTES, DPNS_DATA_CONTRACT_ID } from '../constants';
+export default async function getByIdentifier(grpcPool, identifier) {
+    const id = new IdentifierWASM(identifier);
+    if (id.base58() === DPNS_DATA_CONTRACT_ID) {
+        return DataContractWASM.fromBase64(DPNS_DATA_CONTRACT_BYTES, true, 9);
+    }
+    const getDataContractRequest = GetDataContractRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                id: id.bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getDataContract(getDataContractRequest);
+    const { version } = response;
+    if (version.oneofKind !== 'v0') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be v0)');
+    }
+    const { v0 } = version;
+    if (v0.result.oneofKind !== 'proof') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be proof)');
+    }
+    const { result: { proof }, metadata } = v0;
+    if (metadata == null) {
+        throw new Error('Metadata not found');
+    }
+    const { rootHash, dataContract } = verifyContractProof(proof.grovedbProof, undefined, false, false, id.bytes(), PlatformVersionWASM.PLATFORM_V9);
+    if (dataContract == null) {
+        throw new Error(`Data Contract with identifier ${id.base58()} not found`);
+    }
+    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 dataContract;
+}

package/src/dataContracts/index.js

@@ -0,0 +1,57 @@
+import getDataContractByIdentifier from './getDataContractByIdentifier';
+import createDataContract from './create';
+import createStateTransition from './createStateTransition';
+/**
+ * Collection of methods necessary to work with Data Contracts in the network,
+ * such as data contract creation or retrieval
+ *
+ * @hideconstructor
+ */
+export class DataContractsController {
+    /** @ignore */
+    grpcPool;
+    constructor(grpcPool) {
+        this.grpcPool = grpcPool;
+    }
+    /**
+     * Creates an instance of {DataContractWASM} that can be used to
+     * register a data contract in the network.
+     *
+     * @param ownerId {IdentifierLike} Identifier of the Data Contract's owner
+     * @param identityNonce {bigint} Identity nonce
+     * @param schema {object} Data Contract schema in json
+     * @param tokenConfiguration {object=} Token configuration
+     * @param config {DataContractConfig=} Data Contract config
+     * @param fullValidation {true=} Full validation (omit it)
+     * @param platformVersion {PlatformVersionWASM=} version of the platform
+     *
+     * @return {DataContractWASM}
+     */
+    create(ownerId, identityNonce, schema, fullValidation, tokenConfiguration, config, platformVersion) {
+        return createDataContract(ownerId, identityNonce, schema, tokenConfiguration, config, fullValidation, platformVersion);
+    }
+    /**
+     * Retrieves a Data Contract by an identifier from the network
+     *
+     * @param identifier {IdentifierLike} Identifier of the Data Contract
+     *
+     * @return {Promise<DataContractWASM>}
+     */
+    async getDataContractByIdentifier(identifier) {
+        return await getDataContractByIdentifier(this.grpcPool, identifier);
+    }
+    /**
+     * Helper function to create a state transition from a {DataContractWASM} instance
+     * Pass {DataContractTransitionType} in type param to specify which type of operation you want
+     * to make: create or update.
+     *
+     * @param dataContract {DataContractWASM} An instance of DataContractWASM to create or update
+     * @param type {string} type of identity state transition to do, must be 'create' or 'update'
+     * @param identityNonce {bigint} identity contract nonce
+     *
+     * @return {StateTransitionWASM}
+     */
+    createStateTransition(dataContract, type, identityNonce) {
+        return createStateTransition(dataContract, type, identityNonce);
+    }
+}

package/src/documents/create.js

@@ -0,0 +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);
+}

package/src/documents/createStateTransition.js

@@ -0,0 +1,52 @@
+import { BatchedTransitionWASM, BatchTransitionWASM, DocumentCreateTransitionWASM, DocumentDeleteTransitionWASM, DocumentPurchaseTransitionWASM, DocumentReplaceTransitionWASM, DocumentTransferTransitionWASM, DocumentUpdatePriceTransitionWASM } from 'pshenmic-dpp';
+const documentTransitionsMap = {
+    create: {
+        class: DocumentCreateTransitionWASM,
+        arguments: ['identityContractNonce'],
+        optionalArguments: ['prefundedVotingBalance', 'tokenPaymentInfo']
+    },
+    replace: {
+        class: DocumentReplaceTransitionWASM,
+        arguments: ['identityContractNonce'],
+        optionalArguments: ['tokenPaymentInfo']
+    },
+    delete: {
+        class: DocumentDeleteTransitionWASM,
+        arguments: ['identityContractNonce'],
+        optionalArguments: ['tokenPaymentInfo']
+    },
+    updatePrice: {
+        class: DocumentUpdatePriceTransitionWASM,
+        arguments: ['identityContractNonce', 'price'],
+        optionalArguments: ['tokenPaymentInfo']
+    },
+    transfer: {
+        class: DocumentTransferTransitionWASM,
+        arguments: ['identityContractNonce', 'recipientId'],
+        optionalArguments: ['tokenPaymentInfo']
+    },
+    purchase: {
+        class: DocumentPurchaseTransitionWASM,
+        arguments: ['identityContractNonce', 'amount'],
+        optionalArguments: ['tokenPaymentInfo']
+    }
+};
+export default function createStateTransition(document, type, params) {
+    const { class: TransitionClass, arguments: classArguments, optionalArguments } = documentTransitionsMap[type];
+    if (TransitionClass == null) {
+        throw new Error(`Unimplemented transition type: ${type}`);
+    }
+    // check if all required params for document transition exists
+    const [missingArgument] = classArguments
+        .filter((classArgument) => params[classArgument] == null &&
+        !(optionalArguments).includes(classArgument));
+    if (missingArgument != null) {
+        throw new Error(`Document transition param "${missingArgument}" is missing`);
+    }
+    const transitionParams = classArguments.concat(optionalArguments).map((classArgument) => params[classArgument]);
+    // @ts-expect-error
+    const documentTransition = new TransitionClass(document, ...transitionParams).toDocumentTransition();
+    const batchedTransition = new BatchedTransitionWASM(documentTransition);
+    const batch = BatchTransitionWASM.fromV1BatchedTransitions([batchedTransition], document.ownerId, 1);
+    return batch.toStateTransition();
+}

package/src/documents/index.js

@@ -0,0 +1,83 @@
+import createDocument from './create';
+import { IdentifierWASM, PrefundedVotingBalanceWASM, TokenPaymentInfoWASM } from 'pshenmic-dpp';
+import createStateTransition from './createStateTransition';
+import query from './query';
+/**
+ * Collection of methods to work with documents like creation, querying or preparing a transition action
+ *
+ * @hideconstructor
+ */
+export class DocumentsController {
+    /** @ignore **/
+    grpcPool;
+    constructor(grpcPool) {
+        this.grpcPool = grpcPool;
+    }
+    /**
+     * Creates a {DocumentWASM} instance that can be used to submit a document in the network.
+     *
+     * @param dataContractId {IdentifierLike} Identifier of the Data Contract
+     * @param documentType {string}  Document type as string
+     * @param data {object} Data as JSON object
+     * @param owner {IdentifierLike} Identifier of the document's owner
+     * @param revision {bigint=} revision (optional)
+     *
+     * @return {DataContractWASM}
+     */
+    create(dataContractId, documentType, data, owner, revision) {
+        return createDocument(new IdentifierWASM(dataContractId), documentType, data, new IdentifierWASM(owner), revision);
+    }
+    /**
+     * Make a query for documents retrieval from the network.
+     *
+     * @param dataContractId {IdentifierLike} Identifier of the Data Contract where fetch documents from
+     * @param documentType {string} Document type of the data contract
+     * @param where {object=} Where query clauses according syntax https://docs.dash.org/projects/platform/en/stable/docs/reference/query-syntax.html
+     * @param orderBy {object=} Order by clauses according syntax https://docs.dash.org/projects/platform/en/stable/docs/reference/query-syntax.html
+     * @param limit {number=} Limit amount of documents per request
+     * @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
+     */
+    async query(dataContractId, documentType, where, orderBy, limit, startAt, startAfter) {
+        if (startAfter != null && startAt !== null) {
+            throw new Error('You may only set either startAfter or startAt at once');
+        }
+        return await query(this.grpcPool, new IdentifierWASM(dataContractId), documentType, where, orderBy, limit ?? 100, startAt, startAfter);
+    }
+    /**
+     * Helper function for creating {StateTransitionWASM} from documents. It may be used to create any of 6 Document Transition actions:
+     *
+     * 1) Create - creates a document
+     * 2) Replace - replaces a document
+     * 3) Delete - deletes a document
+     * 4) Transfer - transfer a document from one identity to another
+     * 5) SetPrice - set a price for a document in credits
+     * 6) Purchase - purchase a document from identity (if price was set)
+     *
+     * @param document {DocumentWASM} Instance of the document to make transition with
+     * @param type {string} Type of the document transition, must be a one of ('create' | 'replace' | 'delete' | 'updatePrice' |'transfer' | 'purchase')
+     * @param params {DocumentTransitionParams} params
+     */
+    createStateTransition(document, type, params) {
+        if (type === 'transfer' && params.recipientId == null) {
+            throw new Error('Recipient is required for transfer transition');
+        }
+        if (type === 'updatePrice' && params.price == null) {
+            throw new Error('Price is required for updatePrice transition');
+        }
+        if (type === 'purchase' && params.amount == null) {
+            throw new Error('Amount is required for updatePrice transition');
+        }
+        if (params.prefundedVotingBalance != null) {
+            const { indexName, amount } = params.prefundedVotingBalance;
+            // @ts-expect-error
+            params.prefundedVotingBalance = new PrefundedVotingBalanceWASM(indexName, amount);
+        }
+        if (params.tokenPaymentInfo != null) {
+            const { tokenContractId, tokenContractPosition, minimumTokenCost, maximumTokenCost, gasFeesPaidBy } = params.tokenPaymentInfo;
+            // @ts-expect-error
+            params.tokenPaymentInfo = new TokenPaymentInfoWASM(new IdentifierWASM(tokenContractId), tokenContractPosition, minimumTokenCost, maximumTokenCost, gasFeesPaidBy);
+        }
+        return createStateTransition(document, type, params);
+    }
+}

package/src/documents/query.js

@@ -0,0 +1,62 @@
+import { GetDocumentsRequest } from '../../proto/generated/platform';
+import { IdentifierWASM, PlatformVersionWASM, verifyDocumentsProof } from 'pshenmic-dpp';
+import { DAPI_DEFAULT_LIMIT } from '../constants';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+import { encode } from 'cbor-x';
+import getDataContractByIdentifier from '../dataContracts/getDataContractByIdentifier';
+export default async function query(grpcPool, dataContractId, documentTypeName, where, orderBy, limit = 100, startAt, startAfter) {
+    if ([startAt, startAfter].filter(e => e != null).length === 2) {
+        throw new Error('Only startAt or startAfter could be specified at one time');
+    }
+    let start;
+    if (startAt != null) {
+        start = {
+            oneofKind: 'startAt',
+            startAt: startAt.base58()
+        };
+    }
+    if (startAfter != null) {
+        start = {
+            oneofKind: 'startAfter',
+            startAt: startAfter.base58()
+        };
+    }
+    const getDocumentsRequest = GetDocumentsRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                dataContractId: (new IdentifierWASM(dataContractId)).bytes(),
+                documentType: documentTypeName,
+                where: encode(where),
+                orderBy: encode(orderBy),
+                limit: limit ?? DAPI_DEFAULT_LIMIT,
+                start,
+                prove: true
+            }
+        }
+    });
+    const dataContract = await getDataContractByIdentifier(grpcPool, dataContractId);
+    const { response } = await grpcPool.getClient().getDocuments(getDocumentsRequest);
+    const { version } = response;
+    if (version.oneofKind !== 'v0') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be v0)');
+    }
+    const { v0 } = version;
+    if (v0.result.oneofKind !== 'proof') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be proof)');
+    }
+    const { result: { proof }, metadata } = v0;
+    if (metadata == null) {
+        throw new Error('Metadata not found');
+    }
+    const startAtIncluded = startAt != null;
+    const { rootHash, documents } = verifyDocumentsProof(proof.grovedbProof, dataContract, documentTypeName, where, orderBy, limit, startAt?.bytes(), startAtIncluded, BigInt(metadata?.timeMs), PlatformVersionWASM.PLATFORM_V9);
+    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 documents ?? [];
+}

package/src/grpcConnectionPool.js

@@ -0,0 +1,79 @@
+import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import { PlatformClient } from '../proto/generated/platform.client';
+import getEvonodeList from './utils/getEvonodeList';
+import { GetStatusRequest } from '../proto/generated/platform';
+import getRandomArrayItem from './utils/getRandomArrayItem';
+const GRPC_DEFAULT_POOL_LIMIT = 5;
+const seedNodes = {
+    testnet: [
+        // seed-1.pshenmic.dev
+        'https://158.160.14.115:1443'
+    ],
+    mainnet: [
+        // seed-1.pshenmic.dev
+        'https://158.160.14.115:443'
+        // mainnet dcg seeds
+        // 'https://158.160.14.115',
+        // 'https://3.0.60.103',
+        // 'https://34.211.174.194'
+    ]
+};
+const createClient = (url, abortController) => {
+    return new PlatformClient(new GrpcWebFetchTransport({
+        baseUrl: url,
+        abort: abortController?.signal
+    }));
+};
+export default class GRPCConnectionPool {
+    dapiUrls;
+    network;
+    constructor(network, grpcOptions) {
+        const grpcPoolLimit = grpcOptions?.poolLimit ?? GRPC_DEFAULT_POOL_LIMIT;
+        this.network = network;
+        this._initialize(network, grpcPoolLimit, grpcOptions?.dapiUrl).catch(console.error);
+    }
+    async _initialize(network, poolLimit, dapiUrl) {
+        if (typeof dapiUrl === 'string') {
+            this.dapiUrls = [dapiUrl];
+            return;
+        }
+        if (Array.isArray(dapiUrl)) {
+            this.dapiUrls = dapiUrl;
+            return;
+        }
+        if (dapiUrl != null) {
+            throw new Error('Unrecognized DAPI URL');
+        }
+        // Add default seed nodes
+        this.dapiUrls = seedNodes[network];
+        // retrieve last evonodes list
+        const evonodeList = await getEvonodeList(network);
+        // map it to array of dapiUrls
+        const networkDAPIUrls = Object.entries(evonodeList)
+            .map(([, info]) => info)
+            .filter((info) => info.status === 'ENABLED')
+            .map((info) => {
+            const [host] = info.address.split(':');
+            return `https://${host}:${info.platformHTTPPort}`;
+        });
+        // healthcheck nodes
+        for (const url of networkDAPIUrls) {
+            if (this.dapiUrls.length > poolLimit) {
+                break;
+            }
+            try {
+                const client = createClient(url);
+                const { response } = await client.getStatus(GetStatusRequest.create({}));
+                if (response.version.oneofKind === 'v0' && response.version.v0.chain != null) {
+                    this.dapiUrls.push(url);
+                }
+            }
+            catch (e) {
+            }
+        }
+    }
+    getClient(abortController) {
+        const dapiUrl = getRandomArrayItem(this.dapiUrls);
+        return createClient(dapiUrl, abortController);
+    }
+}