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

package/src/documents/query.js

@@ -0,0 +1,62 @@
+import { GetDocumentsRequest } from '../../proto/generated/platform.js';
+import { IdentifierWASM, PlatformVersionWASM, verifyDocumentsProof } from 'pshenmic-dpp';
+import { DAPI_DEFAULT_LIMIT } from '../constants.js';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
+import bytesToHex from '../utils/bytesToHex.js';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import { encode } from 'cbor-x';
+import getDataContractByIdentifier from '../dataContracts/getDataContractByIdentifier.js';
+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.d.ts

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

package/src/grpcConnectionPool.js

@@ -0,0 +1,79 @@
+import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import { PlatformClient } from '../proto/generated/platform.client.js';
+import getEvonodeList from './utils/getEvonodeList.js';
+import { GetStatusRequest } from '../proto/generated/platform.js';
+import getRandomArrayItem from './utils/getRandomArrayItem.js';
+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);
+    }
+}

package/src/identities/createStateTransition.d.ts

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

package/src/identities/createStateTransition.js

@@ -0,0 +1,34 @@
+import { IdentityCreateTransitionWASM, IdentityTopUpTransitionWASM, IdentityUpdateTransitionWASM } from 'pshenmic-dpp';
+const identityTransitionsMap = {
+    create: {
+        class: IdentityCreateTransitionWASM,
+        arguments: ['publicKeys', 'assetLockProof'],
+        optionalArguments: ['signature', 'userFeeIncrease']
+    },
+    topUp: {
+        class: IdentityTopUpTransitionWASM,
+        arguments: ['assetLockProof', 'identityId'],
+        optionalArguments: ['userFeeIncrease']
+    },
+    update: {
+        class: IdentityUpdateTransitionWASM,
+        arguments: ['identityId', 'revision', 'identityNonce', 'addPublicKeys', 'disablePublicKeyIds'],
+        optionalArguments: ['userFeeIncrease']
+    }
+};
+export default function createStateTransition(type, params) {
+    const { class: TransitionClass, arguments: classArguments, optionalArguments } = identityTransitionsMap[type];
+    if (TransitionClass == null) {
+        throw new Error(`Unimplemented transition type: ${type}`);
+    }
+    const [missingArgument] = classArguments
+        .filter((classArgument) => params[classArgument] == null &&
+        !(optionalArguments).includes(classArgument));
+    if (missingArgument != null) {
+        throw new Error(`Token transition param "${missingArgument}" is missing`);
+    }
+    const transitionParams = classArguments.map((classArgument) => params[classArgument]);
+    // @ts-expect-error
+    const identityTransition = new TransitionClass(...transitionParams);
+    return identityTransition.toStateTransition();
+}

package/src/identities/getIdentityBalance.d.ts

@@ -1,3 +1,3 @@
-import { IdentifierLike } from '../types';
-import GRPCConnectionPool from '../grpcConnectionPool';
+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

@@ -0,0 +1,40 @@
+import { GetIdentityBalanceRequest } from '../../proto/generated/platform.js';
+import { IdentifierWASM, PlatformVersionWASM, verifyIdentityBalanceProof } from 'pshenmic-dpp';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
+import bytesToHex from '../utils/bytesToHex.js';
+export default async function getIdentityBalance(grpcPool, identifier) {
+    const id = new IdentifierWASM(identifier);
+    const getIdentityBalanceRequest = GetIdentityBalanceRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                id: id.bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityBalance(getIdentityBalanceRequest);
+    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, balance } = verifyIdentityBalanceProof(proof.grovedbProof, id.bytes(), true, PlatformVersionWASM.PLATFORM_V9);
+    if (balance == null) {
+        throw new Error(`Failed to fetch balance for identifier ${id.base58()}`);
+    }
+    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 BigInt(balance);
+}

package/src/identities/getIdentityByIdentifier.d.ts

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

@@ -0,0 +1,40 @@
+import { GetIdentityRequest } from '../../proto/generated/platform.js';
+import { IdentifierWASM, PlatformVersionWASM, verifyIdentityByIdentifierProof } 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 getIdentityByIdentifier(grpcPool, identifier) {
+    const id = new IdentifierWASM(identifier);
+    const getIdentityRequest = GetIdentityRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                id: id.bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentity(getIdentityRequest);
+    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, identity } = verifyIdentityByIdentifierProof(proof.grovedbProof, id, true, PlatformVersionWASM.PLATFORM_V9);
+    if (identity == null) {
+        throw new Error(`Identity 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 identity;
+}

package/src/identities/getIdentityByNonUniquePublicKeyHash.d.ts

@@ -1,3 +1,3 @@
 import { IdentityWASM } from 'pshenmic-dpp';
-import GRPCConnectionPool from '../grpcConnectionPool';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function getIdentityByNonUniquePublicKeyHash(grpcPool: GRPCConnectionPool, hex: string): Promise<IdentityWASM>;

package/src/identities/getIdentityByNonUniquePublicKeyHash.js

@@ -0,0 +1,44 @@
+import { GetIdentityByNonUniquePublicKeyHashRequest } from '../../proto/generated/platform.js';
+import { PlatformVersionWASM, 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';
+export default async function getIdentityByNonUniquePublicKeyHash(grpcPool, hex) {
+    const getIdentityByNonUniquePublicKeyHashRequest = GetIdentityByNonUniquePublicKeyHashRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                publicKeyHash: hexToBytes(hex),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityByNonUniquePublicKeyHash(getIdentityByNonUniquePublicKeyHashRequest);
+    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');
+    }
+    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);
+    if (identifier == null) {
+        throw new Error(`Identity with non unique public key hash ${hex} not found`);
+    }
+    const quorumPublicKey = await getQuorumPublicKey(grpcPool.network, proof.grovedbIdentityPublicKeyHashProof.quorumType, bytesToHex(proof.grovedbIdentityPublicKeyHashProof.quorumHash));
+    const verify = await verifyTenderdashProof(proof.grovedbIdentityPublicKeyHashProof, metadata, rootHash, quorumPublicKey);
+    if (!verify) {
+        throw new Error('Failed to verify query');
+    }
+    return await getIdentityByIdentifier(grpcPool, identifier);
+}

package/src/identities/getIdentityByPublicKeyHash.d.ts

@@ -1,3 +1,3 @@
 import { IdentityWASM } from 'pshenmic-dpp';
-import GRPCConnectionPool from '../grpcConnectionPool';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function getIdentityByPublicKeyHash(grpcPool: GRPCConnectionPool, hex: string): Promise<IdentityWASM>;

package/src/identities/getIdentityByPublicKeyHash.js

@@ -0,0 +1,40 @@
+import { GetIdentityByPublicKeyHashRequest } from '../../proto/generated/platform.js';
+import { PlatformVersionWASM, 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';
+export default async function getIdentityByPublicKeyHash(grpcPool, hex) {
+    const getIdentityByPublicKeyHashRequest = GetIdentityByPublicKeyHashRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                publicKeyHash: hexToBytes(hex),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityByPublicKeyHash(getIdentityByPublicKeyHashRequest);
+    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, identity } = verifyIdentityByUniqueKeyHashProof(proof.grovedbProof, hexToBytes(hex), PlatformVersionWASM.PLATFORM_V9);
+    if (identity == null) {
+        throw new Error(`Identity with public key hash ${hex} 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 identity;
+}

package/src/identities/getIdentityContractNonce.d.ts

@@ -1,3 +1,3 @@
-import { IdentifierLike } from '../types';
-import GRPCConnectionPool from '../grpcConnectionPool';
+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

@@ -0,0 +1,43 @@
+import { GetIdentityContractNonceRequest } from '../../proto/generated/platform.js';
+import { IdentifierWASM, PlatformVersionWASM, verifyIdentityContractNonceProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
+import bytesToHex from '../utils/bytesToHex.js';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+const IDENTITY_CONTRACT_NONCE_VALUE_FILTER = BigInt(0xFFFFFFFFFF);
+export default async function getIdentityContractNonce(grpcPool, identity, dataContract) {
+    const identityIdentifier = new IdentifierWASM(identity);
+    const dataContractIdentifier = new IdentifierWASM(dataContract);
+    const getIdentityContractNonceRequest = GetIdentityContractNonceRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                identityId: identityIdentifier.bytes(),
+                contractId: dataContractIdentifier.bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityContractNonce(getIdentityContractNonceRequest);
+    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, contractNonce } = verifyIdentityContractNonceProof(proof.grovedbProof, identityIdentifier.bytes(), dataContractIdentifier.bytes(), true, PlatformVersionWASM.PLATFORM_V9);
+    if (contractNonce == null) {
+        return BigInt(0);
+    }
+    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 BigInt(contractNonce) & IDENTITY_CONTRACT_NONCE_VALUE_FILTER;
+}

package/src/identities/getIdentityNonce.d.ts

@@ -1,3 +1,3 @@
-import { IdentifierLike } from '../types';
-import GRPCConnectionPool from '../grpcConnectionPool';
+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

@@ -0,0 +1,41 @@
+import { GetIdentityNonceRequest } from '../../proto/generated/platform.js';
+import { IdentifierWASM, PlatformVersionWASM, verifyIdentityNonceProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
+import bytesToHex from '../utils/bytesToHex.js';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+const IDENTITY_NONCE_VALUE_FILTER = BigInt(0xFFFFFFFFFF);
+export default async function getIdentityNonce(grpcPool, identifier) {
+    const id = new IdentifierWASM(identifier);
+    const getIdentityNonceRequest = GetIdentityNonceRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                identityId: id.bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityNonce(getIdentityNonceRequest);
+    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, nonce } = verifyIdentityNonceProof(proof.grovedbProof, id.bytes(), true, PlatformVersionWASM.PLATFORM_V9);
+    if (nonce == null) {
+        return BigInt(0);
+    }
+    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 BigInt(nonce) & IDENTITY_NONCE_VALUE_FILTER;
+}

package/src/identities/getIdentityPublicKeys.d.ts

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

package/src/identities/getIdentityPublicKeys.js

@@ -0,0 +1,47 @@
+import { GetIdentityKeysRequest, KeyRequestType } from '../../proto/generated/platform.js';
+import { IdentifierWASM, PlatformVersionWASM, 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) {
+    const id = new IdentifierWASM(identifier);
+    const getIdentityKeysRequest = GetIdentityKeysRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                identityId: id.bytes(),
+                requestType: KeyRequestType.create({
+                    request: {
+                        oneofKind: 'allKeys',
+                        allKeys: {}
+                    }
+                }),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityKeys(getIdentityKeysRequest);
+    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, identity } = verifyIdentityKeysByIdentifierProof(proof.grovedbProof, id.bytes(), null, false, false, true, null, null, PlatformVersionWASM.PLATFORM_V9);
+    if (identity == null) {
+        throw new Error(`Identity 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');
+    }
+    const loadedKeysIds = Object.keys(identity.loadedPublicKeys);
+    return loadedKeysIds.map((id) => identity.loadedPublicKeys[id]);
+}

package/src/identities/index.d.ts

@@ -1,5 +1,5 @@
-import { IdentifierLike, IdentityTransitionParams } from '../types';
-import GRPCConnectionPool from '../grpcConnectionPool';
+import { IdentifierLike, IdentityTransitionParams } from '../types.js';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
 import { IdentityPublicKeyWASM, IdentityWASM, StateTransitionWASM } from 'pshenmic-dpp';
 /**
  * Collection of methods to query identities and its related data