dash-platform-sdk 1.4.0-dev.9 → 1.5.0-dev.1

package/src/DashPlatformSDK.d.ts

@@ -12,6 +12,7 @@ import { TokensController } from './tokens/index.js';
 import { VotingController } from './voting/index.js';
 import { Network } from '../types.js';
 import { PlatformAddressesController } from './platformAddresses/index.js';
+import { ShieldedController } from './shielded/index.js';
 export interface GRPCOptions {
     poolLimit: 5;
     dapiUrl?: string | string[];
@@ -33,6 +34,7 @@ export declare class DashPlatformSDK {
     options?: SDKOptions;
     contestedResources: ContestedResourcesController;
     platformAddresses: PlatformAddressesController;
+    shielded: ShieldedController;
     stateTransitions: StateTransitionsController;
     dataContracts: DataContractsController;
     identities: IdentitiesController;

package/src/DashPlatformSDK.js

@@ -11,6 +11,7 @@ import { ContestedResourcesController } from './contestedResources/index.js';
 import { TokensController } from './tokens/index.js';
 import { VotingController } from './voting/index.js';
 import { PlatformAddressesController } from './platformAddresses/index.js';
+import { ShieldedController } from './shielded/index.js';
 /**
  * Javascript SDK for that let you interact with a Dash Platform blockchain
  */
@@ -22,6 +23,7 @@ export class DashPlatformSDK {
     options;
     contestedResources;
     platformAddresses;
+    shielded;
     stateTransitions;
     dataContracts;
     identities;
@@ -65,6 +67,7 @@ export class DashPlatformSDK {
         this.grpcPool = grpcPool;
         this.contestedResources = new ContestedResourcesController(grpcPool);
         this.platformAddresses = new PlatformAddressesController(grpcPool);
+        this.shielded = new ShieldedController(grpcPool);
         this.stateTransitions = new StateTransitionsController(grpcPool);
         this.dataContracts = new DataContractsController(grpcPool);
         this.identities = new IdentitiesController(grpcPool);

package/src/constants.d.ts

@@ -3,10 +3,11 @@ import { PlatformVersionWASM } from 'pshenmic-dpp';
  * Default amount of documents to retrieve from DAPI
  */
 export declare const DAPI_DEFAULT_LIMIT = 100;
+export declare const SHIELDED_MAX_NOTES_PER_QUERY = 8192;
 export declare const HALVING_INTERVAL = 210240;
 export declare const TESTNET_ACTIVATION_HEIGHT = 1066900;
 export declare const MAINNET_ACTIVATION_HEIGHT = 2128896;
 export declare const GRPC_DEFAULT_POOL_LIMIT = 5;
 export declare const DPNS_DATA_CONTRACT_ID = "GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec";
 export declare const DPNS_DATA_CONTRACT_BYTES = "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";
-export declare const LATEST_PLATFORM_VERSION = PlatformVersionWASM.PLATFORM_V11;
+export declare const LATEST_PLATFORM_VERSION = PlatformVersionWASM.PLATFORM_V12;

package/src/constants.js

@@ -1,11 +1,13 @@
+import { PlatformVersionWASM } from 'pshenmic-dpp';
 /**
  * Default amount of documents to retrieve from DAPI
  */
 export const DAPI_DEFAULT_LIMIT = 100;
+export const SHIELDED_MAX_NOTES_PER_QUERY = 8192;
 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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';
-export const LATEST_PLATFORM_VERSION = 11 /* PlatformVersionWASM.PLATFORM_V11 */;
+export const LATEST_PLATFORM_VERSION = PlatformVersionWASM.PLATFORM_V12;

package/src/documents/index.js

@@ -39,7 +39,7 @@ export class DocumentsController {
      * @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) {
+        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);

package/src/documents/query.js

@@ -7,20 +7,17 @@ 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()
+            startAt: startAt.bytes()
         };
     }
     if (startAfter != null) {
         start = {
             oneofKind: 'startAfter',
-            startAt: startAfter.base58()
+            startAfter: startAfter.bytes()
         };
     }
     const getDocumentsRequest = GetDocumentsRequest.create({
@@ -52,7 +49,8 @@ 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), LATEST_PLATFORM_VERSION);
+    const startIdentifier = startAt ?? startAfter;
+    const { rootHash, documents } = verifyDocumentsProof(proof.grovedbProof, dataContract, documentTypeName, where, orderBy, limit, startIdentifier?.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/keyPair/index.d.ts

@@ -1,5 +1,6 @@
 import { HDKey } from '@scure/bip32';
 import { Network } from '../../types.js';
+import { OrchardAddressWASM } from 'pshenmic-dpp';
 /**
  * Collection of functions to work with private keys and seed phrases
  *
@@ -64,4 +65,28 @@ export declare class KeyPairController {
      * @returns {string}
      */
     p2pkhAddress(publicKey: Uint8Array, network: Network): string;
+    /**
+     * Derives a shielded (Orchard) address from a BIP-39 seed via ZIP-32
+     * (m/32'/coinType'/account').
+     *
+     * @param seed {Uint8Array} - BIP-39 seed bytes
+     * @param network {Network} - network (selects the SLIP-44 coin type)
+     * @param account {number} - ZIP-32 account index
+     * @param diversifierIndex {number=} - optional diversifier index
+     *
+     * @returns {OrchardAddressWASM}
+     */
+    deriveShieldedAddress(seed: Uint8Array, network: Network, account: number, diversifierIndex?: number): OrchardAddressWASM;
+    /**
+     * Derives the sender's Orchard outgoing viewing key (OVK, 32 bytes) from a
+     * BIP-39 seed via ZIP-32 (m/32'/coinType'/account'). Used to recover the
+     * outgoing notes a wallet sent.
+     *
+     * @param seed {Uint8Array} - BIP-39 seed bytes
+     * @param network {Network} - network (selects the SLIP-44 coin type)
+     * @param account {number} - ZIP-32 account index
+     *
+     * @returns {Uint8Array} 32-byte outgoing viewing key
+     */
+    deriveShieldedOutgoingViewingKey(seed: Uint8Array, network: Network, account: number): Uint8Array;
 }

package/src/keyPair/index.js

@@ -3,6 +3,7 @@ import mnemonicToSeed from './mnemonicToSeed.js';
 import deriveChild from './deriveChild.js';
 import derivePath from './derivePath.js';
 import { p2pkh } from '@scure/btc-signer';
+import { OrchardAddressWASM, orchardOvkFromSeed } from 'pshenmic-dpp';
 const DASH_VERSIONS = {
     mainnet: { pubKeyHash: 0x4c, scriptHash: 0x10, bech32: 'dc', wif: 0xcc, private: 0x0488ade4, public: 0x0488b21e },
     testnet: { pubKeyHash: 0x8c, scriptHash: 0x13, bech32: 'dc', wif: 0xef, private: 0x04358394, public: 0x043587cf }
@@ -86,4 +87,36 @@ export class KeyPairController {
         const P2PKH = p2pkh(publicKey, DASH_VERSIONS[network]);
         return P2PKH.address;
     }
+    /**
+     * Derives a shielded (Orchard) address from a BIP-39 seed via ZIP-32
+     * (m/32'/coinType'/account').
+     *
+     * @param seed {Uint8Array} - BIP-39 seed bytes
+     * @param network {Network} - network (selects the SLIP-44 coin type)
+     * @param account {number} - ZIP-32 account index
+     * @param diversifierIndex {number=} - optional diversifier index
+     *
+     * @returns {OrchardAddressWASM}
+     */
+    deriveShieldedAddress(seed, network, account, diversifierIndex) {
+        // SLIP-44 coin type: 5 = Dash mainnet, 1 = testnets. Orchard derives via ZIP-32
+        const coinType = network === 'mainnet' ? 5 : 1;
+        return OrchardAddressWASM.fromSeed(seed, coinType, account, diversifierIndex);
+    }
+    /**
+     * Derives the sender's Orchard outgoing viewing key (OVK, 32 bytes) from a
+     * BIP-39 seed via ZIP-32 (m/32'/coinType'/account'). Used to recover the
+     * outgoing notes a wallet sent.
+     *
+     * @param seed {Uint8Array} - BIP-39 seed bytes
+     * @param network {Network} - network (selects the SLIP-44 coin type)
+     * @param account {number} - ZIP-32 account index
+     *
+     * @returns {Uint8Array} 32-byte outgoing viewing key
+     */
+    deriveShieldedOutgoingViewingKey(seed, network, account) {
+        // SLIP-44 coin type: 5 = Dash mainnet, 1 = testnets. Orchard derives via ZIP-32
+        const coinType = network === 'mainnet' ? 5 : 1;
+        return orchardOvkFromSeed(seed, coinType, account);
+    }
 }

package/src/shielded/createStateTransition.d.ts

@@ -0,0 +1,3 @@
+import { ShieldedBuilderWASM, StateTransitionWASM } from 'pshenmic-dpp';
+import { ShieldedTransitionParamsMap, ShieldedTransitionType } from '../../types.js';
+export default function createStateTransition<K extends ShieldedTransitionType>(builder: ShieldedBuilderWASM, type: K, params: ShieldedTransitionParamsMap[K]): StateTransitionWASM;

package/src/shielded/createStateTransition.js

@@ -0,0 +1,55 @@
+import { IdentityCreateFromShieldedPoolTransitionWASM, ShieldedBuilderWASM, ShieldedWithdrawalResultWASM, StateTransitionWASM } from 'pshenmic-dpp';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
+const shieldedTransitionsMap = {
+    shield: {
+        method: ShieldedBuilderWASM.prototype.shield,
+        arguments: ['recipient', 'shieldAmount', 'inputs', 'privateKeys', 'feeStrategy', 'userFeeIncrease', 'memo'],
+        optionalArguments: ['senderOvk']
+    },
+    shieldFromAssetLock: {
+        method: ShieldedBuilderWASM.prototype.shieldFromAssetLock,
+        arguments: ['recipient', 'shieldAmount', 'assetLockProof', 'privateKey', 'memo', 'dummyOutputs'],
+        optionalArguments: ['senderOvk', 'surplusOutput']
+    },
+    shieldedWithdrawal: {
+        method: ShieldedBuilderWASM.prototype.shieldedWithdrawal,
+        arguments: ['spends', 'withdrawalAmount', 'outputScript', 'coreFeePerByte', 'pooling', 'changeAddress', 'seed', 'coinType', 'account', 'anchor', 'memo'],
+        optionalArguments: []
+    },
+    unshield: {
+        method: ShieldedBuilderWASM.prototype.unshield,
+        arguments: ['spends', 'outputAddress', 'unshieldAmount', 'changeAddress', 'seed', 'coinType', 'account', 'anchor', 'memo'],
+        optionalArguments: []
+    },
+    shieldedTransfer: {
+        method: ShieldedBuilderWASM.prototype.shieldedTransfer,
+        arguments: ['spends', 'recipient', 'transferAmount', 'changeAddress', 'seed', 'coinType', 'account', 'anchor', 'memo'],
+        optionalArguments: []
+    },
+    identityCreateFromShieldedPool: {
+        method: ShieldedBuilderWASM.prototype.identityCreateFromShieldedPool,
+        arguments: ['publicKeys', 'privateKeys', 'denomination', 'sendToAddressOnCreationFailure', 'spends', 'changeAddress', 'seed', 'coinType', 'account', 'anchor', 'memo'],
+        optionalArguments: []
+    }
+};
+export default function createStateTransition(builder, type, params) {
+    const { method: builderMethod, arguments: classArguments, optionalArguments } = shieldedTransitionsMap[type];
+    if (builderMethod == null) {
+        throw new Error(`Unimplemented shielded transition type: ${type}`);
+    }
+    const [missingArgument] = classArguments
+        .filter((classArgument) => params[classArgument] == null);
+    if (missingArgument != null) {
+        throw new Error(`Shielded transition param "${missingArgument}" is missing`);
+    }
+    const transitionParams = classArguments.concat(optionalArguments).map((classArgument) => params[classArgument]);
+    const result = builderMethod.apply(builder, [...transitionParams, params.platformVersion ?? LATEST_PLATFORM_VERSION]);
+    if (result instanceof StateTransitionWASM) {
+        return result;
+    }
+    if (result instanceof ShieldedWithdrawalResultWASM) {
+        return result.stateTransition;
+    }
+    const { denomination, sendToAddressOnCreationFailure } = params;
+    return new IdentityCreateFromShieldedPoolTransitionWASM(result.publicKeys, denomination, result.actions, result.anchor, result.proof, result.bindingsSignature, sendToAddressOnCreationFailure, result.identityId).toStateTransition();
+}

package/src/shielded/getMostRecentShieldedAnchor.d.ts

@@ -0,0 +1,2 @@
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+export default function getMostRecentShieldedAnchor(grpcPool: GRPCConnectionPool): Promise<Uint8Array | undefined>;

package/src/shielded/getMostRecentShieldedAnchor.js

@@ -0,0 +1,36 @@
+import { GetMostRecentShieldedAnchorRequest } from '../../proto/generated/platform.js';
+import { verifyMostRecentShieldedAnchorProof } from "pshenmic-dpp";
+import { LATEST_PLATFORM_VERSION } from "../constants.js";
+import { getQuorumPublicKey } from "../utils/getQuorumPublicKey.js";
+import bytesToHex from "../utils/bytesToHex.js";
+import verifyTenderdashProof from "../utils/verifyTenderdashProof.js";
+export default async function getMostRecentShieldedAnchor(grpcPool) {
+    const getMostRecentShieldedAnchorRequest = GetMostRecentShieldedAnchorRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getMostRecentShieldedAnchor(getMostRecentShieldedAnchorRequest);
+    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, anchor } = verifyMostRecentShieldedAnchorProof(proof.grovedbProof, true, 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 anchor;
+}

package/src/shielded/getShieldedAnchors.d.ts

@@ -0,0 +1,2 @@
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+export default function getShieldedAnchors(grpcPool: GRPCConnectionPool): Promise<Uint8Array[]>;

package/src/shielded/getShieldedAnchors.js

@@ -0,0 +1,36 @@
+import { GetShieldedAnchorsRequest } from '../../proto/generated/platform.js';
+import { verifyShieldedAnchorsProof } from "pshenmic-dpp";
+import { LATEST_PLATFORM_VERSION } from "../constants.js";
+import { getQuorumPublicKey } from "../utils/getQuorumPublicKey.js";
+import bytesToHex from "../utils/bytesToHex.js";
+import verifyTenderdashProof from "../utils/verifyTenderdashProof.js";
+export default async function getShieldedAnchors(grpcPool) {
+    const getShieldedAnchorsRequest = GetShieldedAnchorsRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getShieldedAnchors(getShieldedAnchorsRequest);
+    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, anchors } = verifyShieldedAnchorsProof(proof.grovedbProof, true, 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 anchors;
+}

package/src/shielded/getShieldedEncryptedNotes.d.ts

@@ -0,0 +1,3 @@
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { ShieldedEncryptedNote } from '../../types.js';
+export default function getShieldedEncryptedNotes(grpcPool: GRPCConnectionPool, startIndex: bigint, count: number): Promise<ShieldedEncryptedNote[]>;

package/src/shielded/getShieldedEncryptedNotes.js

@@ -0,0 +1,43 @@
+import { GetShieldedEncryptedNotesRequest } from '../../proto/generated/platform.js';
+import { verifyShieldedEncryptedNotesProof } from "pshenmic-dpp";
+import { LATEST_PLATFORM_VERSION, SHIELDED_MAX_NOTES_PER_QUERY } from "../constants.js";
+import { getQuorumPublicKey } from "../utils/getQuorumPublicKey.js";
+import bytesToHex from "../utils/bytesToHex.js";
+import verifyTenderdashProof from "../utils/verifyTenderdashProof.js";
+export default async function getShieldedEncryptedNotes(grpcPool, startIndex, count) {
+    const getShieldedEncryptedNotesRequest = GetShieldedEncryptedNotesRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                startIndex: startIndex.toString(),
+                count,
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getShieldedEncryptedNotes(getShieldedEncryptedNotesRequest);
+    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, notes } = verifyShieldedEncryptedNotesProof(proof.grovedbProof, startIndex, count, SHIELDED_MAX_NOTES_PER_QUERY, true, 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 notes.map(note => ({
+        nullifier: note.nullifier,
+        cmx: note.cmx,
+        encryptedNote: note.encryptedNote,
+        cvNet: note.cvNet
+    }));
+}

package/src/shielded/getShieldedNotesCount.d.ts

@@ -0,0 +1,2 @@
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+export default function getShieldedNotesCount(grpcPool: GRPCConnectionPool): Promise<bigint | undefined>;

package/src/shielded/getShieldedNotesCount.js

@@ -0,0 +1,36 @@
+import { GetShieldedNotesCountRequest } from '../../proto/generated/platform.js';
+import { verifyShieldedNotesCountProof } from "pshenmic-dpp";
+import { LATEST_PLATFORM_VERSION } from "../constants.js";
+import { getQuorumPublicKey } from "../utils/getQuorumPublicKey.js";
+import bytesToHex from "../utils/bytesToHex.js";
+import verifyTenderdashProof from "../utils/verifyTenderdashProof.js";
+export default async function getShieldedNotesCount(grpcPool) {
+    const getShieldedNotesCountRequest = GetShieldedNotesCountRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getShieldedNotesCount(getShieldedNotesCountRequest);
+    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, count } = verifyShieldedNotesCountProof(proof.grovedbProof, true, 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 count;
+}

package/src/shielded/getShieldedNullifiers.d.ts

@@ -0,0 +1,3 @@
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { ShieldedNullifierStatus } from '../../types.js';
+export default function getShieldedNullifiers(grpcPool: GRPCConnectionPool, nullifiers: Uint8Array[]): Promise<ShieldedNullifierStatus[]>;

package/src/shielded/getShieldedNullifiers.js

@@ -0,0 +1,40 @@
+import { GetShieldedNullifiersRequest } from '../../proto/generated/platform.js';
+import { verifyShieldedNullifiersProof } from "pshenmic-dpp";
+import { LATEST_PLATFORM_VERSION } from "../constants.js";
+import { getQuorumPublicKey } from "../utils/getQuorumPublicKey.js";
+import bytesToHex from "../utils/bytesToHex.js";
+import verifyTenderdashProof from "../utils/verifyTenderdashProof.js";
+export default async function getShieldedNullifiers(grpcPool, nullifiers) {
+    const getShieldedNullifiersRequest = GetShieldedNullifiersRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                nullifiers,
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getShieldedNullifiers(getShieldedNullifiersRequest);
+    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, nullifiers: nullifiersStatuses } = verifyShieldedNullifiersProof(proof.grovedbProof, nullifiers, true, 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 nullifiersStatuses.map(entry => ({
+        nullifier: entry.nullifier,
+        isSpent: entry.isSpent
+    }));
+}

package/src/shielded/getShieldedPoolState.d.ts

@@ -0,0 +1,2 @@
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+export default function getShieldedPoolState(grpcPool: GRPCConnectionPool): Promise<bigint | undefined>;

package/src/shielded/getShieldedPoolState.js

@@ -0,0 +1,36 @@
+import { GetShieldedPoolStateRequest } from '../../proto/generated/platform.js';
+import { getQuorumPublicKey } from "../utils/getQuorumPublicKey.js";
+import bytesToHex from "../utils/bytesToHex.js";
+import verifyTenderdashProof from "../utils/verifyTenderdashProof.js";
+import { verifyShieldedPoolStateProof } from "pshenmic-dpp";
+import { LATEST_PLATFORM_VERSION } from "../constants.js";
+export default async function getShieldedPoolState(grpcPool) {
+    const getShieldedPoolStateRequest = GetShieldedPoolStateRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getShieldedPoolState(getShieldedPoolStateRequest);
+    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, totalBalance } = verifyShieldedPoolStateProof(proof.grovedbProof, true, 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 totalBalance;
+}