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

package/src/names/index.js

@@ -0,0 +1,102 @@
+import { IdentifierWASM } from 'pshenmic-dpp';
+import searchByName from './searchByName';
+import searchByIdentity from './searchByIdentity';
+import registerName from './registerName';
+import validateName from './validateName';
+import getIdentityByIdentifier from '../identities/getIdentityByIdentifier';
+import convertToHomographSafeChars from '../utils/convertToHomographSafeChars';
+import testNameContested from './testNameContested';
+/**
+ * Functions related to DPNS names (usernames)
+ *
+ * @hideconstructor
+ */
+export class NamesController {
+    /** @ignore **/
+    grpcPool;
+    constructor(grpcPool) {
+        this.grpcPool = grpcPool;
+    }
+    /**
+     * Searches for a registered DPNS name in the network
+     *
+     * Should be in a human-readable format, for example pshenmic.dash
+     *
+     * Returns a {DocumentWASM} document of type 'domain' from DPNS system data contract if found,
+     * returns null if not found.
+     *
+     * https://testnet.platform-explorer.com/dataContract/GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec?tab=schema
+     *
+     * @param name {string}
+     *
+     * @return Promise<DocumentWASM | null>
+     */
+    async searchByName(name) {
+        const validation = validateName(name);
+        if (validation != null) {
+            throw new Error(validation);
+        }
+        return await searchByName(this.grpcPool, name);
+    }
+    /**
+     * Tests a given username against contested names rules.
+     * Contested names includes an additional fee of 0.2 Dash
+     * as a voting resolution fee
+     *
+     * This function return boolean whether given username (f.e pshenmic.dash)
+     * falls under contested names rules.
+     * @param name
+     */
+    testNameContested(name) {
+        const validation = validateName(name);
+        if (validation != null) {
+            throw new Error(validation);
+        }
+        const [label] = name.split('.');
+        const normalizedLabel = convertToHomographSafeChars(label);
+        return testNameContested(normalizedLabel);
+    }
+    async searchByIdentity(identifier) {
+        return await searchByIdentity(this.grpcPool, new IdentifierWASM(identifier));
+    }
+    /**
+     * Performs a DPNS name registration sequence
+     * Contested names are include additional fee of 0.2 Dash
+     * Check your name is contested with .testNameContested(name) method to check if additional fee will be charged
+     *
+     * @param name {string} username (ex. pshenmic.dash)
+     * @param identityId {IdentifierLike} identity identifier
+     * @param privateKey {PrivateKeyWASM} Authentication / High private key from your identity
+     */
+    async registerName(name, identityId, privateKey) {
+        const validation = validateName(name);
+        if (validation != null) {
+            throw new Error(validation);
+        }
+        const identity = await getIdentityByIdentifier(this.grpcPool, identityId);
+        await registerName(this.grpcPool, name, identity, privateKey);
+    }
+    /**
+     * Converts DPNS name to normalized format (ex. alice.dash -> al1ce.dash)
+     *
+     * source: https://github.com/dashpay/platform/blob/master/packages/js-dash-sdk/src/utils/convertToHomographSafeChars.ts
+     *
+     *
+     * @param label {string}
+     *
+     * @return {string}
+     */
+    normalizeLabel(label) {
+        return convertToHomographSafeChars(label);
+    }
+    /**
+     * Validates a DPNS name that you would like to register
+     *
+     * @param fullName {string} full DPNS name (ex. pshenmic.dash)
+     *
+     * @return {string} null if valid or string with a reason
+     */
+    validateName(fullName) {
+        return validateName(fullName);
+    }
+}

package/src/names/registerName.js

@@ -0,0 +1,64 @@
+import convertToHomographSafeChars from '../utils/convertToHomographSafeChars';
+import { PrefundedVotingBalanceWASM } from 'pshenmic-dpp';
+import getRandomBytes from '../utils/getRandomBytes';
+import sha256 from '../utils/sha256';
+import createDocument from '../documents/create';
+import createStateTransition from '../documents/createStateTransition';
+import getIdentityContractNonce from '../identities/getIdentityContractNonce';
+import broadcast from '../stateTransitions/broadcast';
+import waitForStateTransitionResult from '../stateTransitions/waitForStateTransitionResult';
+import testNameContested from './testNameContested';
+import { DPNS_DATA_CONTRACT_ID } from '../constants';
+export default async function registerName(grpcPool, name, identity, privateKey) {
+    const [identityPublicKey] = identity.getPublicKeys().filter(identityPublicKey => identityPublicKey.getPublicKeyHash() === privateKey.getPublicKeyHash());
+    if (identityPublicKey == null) {
+        throw new Error('Private key does not match the identity');
+    }
+    if (identityPublicKey.securityLevel !== 'HIGH' && identityPublicKey.purpose !== 'AUTHENTICATION') {
+        throw new Error('Wrong private key, must be from AUTHENTICATION HIGH identity public key');
+    }
+    const [label, parentDomainName] = name.split('.');
+    const salt = getRandomBytes(32);
+    const normalizedParentDomainName = convertToHomographSafeChars(parentDomainName);
+    const normalizedLabel = convertToHomographSafeChars(label);
+    const normalizedFullDomainName = `${normalizedLabel}.${normalizedParentDomainName}`;
+    const saltedDomainHash = await sha256(await sha256(new Uint8Array([
+        ...salt,
+        ...new TextEncoder().encode(normalizedFullDomainName)
+    ])));
+    let document;
+    let stateTransition;
+    // 1. Create preorder document
+    const preorderData = {
+        saltedDomainHash: Array.from(saltedDomainHash)
+    };
+    const identityContractNonce = await getIdentityContractNonce(grpcPool, identity.id, DPNS_DATA_CONTRACT_ID);
+    document = createDocument(DPNS_DATA_CONTRACT_ID, 'preorder', preorderData, identity.id.base58());
+    stateTransition = createStateTransition(document, 'create', { identityContractNonce: identityContractNonce + BigInt(1) });
+    await stateTransition.sign(privateKey, identityPublicKey);
+    await broadcast(grpcPool, stateTransition);
+    // wait for state transition confirmation before next broadcast
+    await waitForStateTransitionResult(grpcPool, stateTransition);
+    // 2. Create domain document
+    const domainData = {
+        label,
+        normalizedLabel,
+        parentDomainName,
+        normalizedParentDomainName,
+        preorderSalt: Array.from(salt),
+        records: {
+            identity: Array.from(identity.id.bytes())
+        },
+        subdomainRules: {
+            allowSubdomains: false
+        }
+    };
+    document = createDocument(DPNS_DATA_CONTRACT_ID, 'domain', domainData, identity.id.base58());
+    stateTransition = createStateTransition(document, 'create', {
+        identityContractNonce: identityContractNonce + BigInt(2),
+        // @ts-expect-error
+        prefundedVotingBalance: testNameContested(normalizedLabel) ? new PrefundedVotingBalanceWASM('parentNameAndLabel', BigInt(20000000000)) : undefined
+    });
+    await stateTransition.sign(privateKey, identityPublicKey);
+    await broadcast(grpcPool, stateTransition);
+}

package/src/names/searchByIdentity.js

@@ -0,0 +1,5 @@
+import query from '../documents/query';
+const DPNS_DATA_CONTRACT_ID = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
+export default async function searchByIdentity(grpcPool, identifier) {
+    return await query(grpcPool, DPNS_DATA_CONTRACT_ID, 'domain', [['records.identity', '=', identifier.base58()]], [['records.identity', 'asc']]);
+}

package/src/names/searchByName.js

@@ -0,0 +1,16 @@
+import convertToHomographSafeChars from '../utils/convertToHomographSafeChars';
+import query from '../documents/query';
+const DPNS_DATA_CONTRACT_ID = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
+export default async function search(grpcPool, name) {
+    const [label, parentDomainName] = name.split('.');
+    const normalizedParentDomainName = convertToHomographSafeChars(parentDomainName);
+    const normalizedLabelPrefix = convertToHomographSafeChars(label);
+    const where = [
+        ['normalizedParentDomainName', '==', normalizedParentDomainName],
+        ['normalizedLabel', 'startsWith', normalizedLabelPrefix]
+    ];
+    const orderBy = [
+        ['normalizedLabel', 'asc']
+    ];
+    return await query(grpcPool, DPNS_DATA_CONTRACT_ID, 'domain', where, orderBy);
+}

package/src/names/testNameContested.js

@@ -0,0 +1,3 @@
+export default function testNameContested(normalizedLabel) {
+    return /^[a-zA-Z01-]{3,19}$/.test(normalizedLabel);
+}

package/src/names/validateName.js

@@ -0,0 +1,11 @@
+export default function validateName(fullName) {
+    const chunks = fullName.split('.');
+    if (chunks.length !== 2) {
+        return 'Name to search should be a full domain name (ex. pshenmic.dash)';
+    }
+    const [label, parentDomainName] = chunks;
+    if (parentDomainName !== 'dash') {
+        return 'Root domain must be .dash';
+    }
+    return /^[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9]$/.test(label) ? null : 'Unacceptable label name';
+}

package/src/node/epochs.js

@@ -0,0 +1,46 @@
+import { GetEpochsInfoRequest } from '../../proto/generated/platform';
+import { PlatformVersionWASM, verifyEpochsInfoProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+import { UInt32Value } from '../../proto/generated/google/protobuf/wrappers';
+export default async function epochs(grpcPool, count, ascending, start) {
+    const getEpochsInfoRequest = GetEpochsInfoRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                startEpoch: start != null ? UInt32Value.create({ value: start }) : undefined,
+                count,
+                ascending,
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getEpochsInfo(getEpochsInfoRequest);
+    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, epochsInfo } = verifyEpochsInfoProof(proof.grovedbProof, metadata.epoch, start, count, ascending, 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 epochsInfo.map(info => ({
+        number: info.index,
+        firstBlockHeight: info.firstBlockHeight,
+        firstCoreBlockHeight: info.firstCoreBlockHeight,
+        startTime: info.firstBlockTime,
+        feeMultiplier: info.feeMultiplierPermille,
+        protocolVersion: info.protocolVersion
+    }));
+}

package/src/node/index.js

@@ -0,0 +1,43 @@
+import getStatus from './status';
+import getEpochsInfo from './epochs';
+import getTotalCredits from './totalCredits';
+/**
+ * Node controller for requesting information about DAPI node
+ *
+ * @hideconstructor
+ */
+export class NodeController {
+    /** @ignore **/
+    grpcPool;
+    network;
+    constructor(grpcPool, network) {
+        this.grpcPool = grpcPool;
+        this.network = network;
+    }
+    /**
+     * Retrieves an info about node
+     * Includes information about genesis, chain, software versions
+     *
+     * @return {Promise<NodeStatus>}
+     */
+    async status() {
+        return await getStatus(this.grpcPool);
+    }
+    /**
+     * Returns total credits amount in platform
+     *
+     * @return {Promise<bigint>}
+     */
+    async totalCredits() {
+        return await getTotalCredits(this.grpcPool, this.network);
+    }
+    /**
+     * Retrieves an info about epochs
+     * Includes information about first block height, time, fee multiplier, number
+     *
+     * @return {Promise<EpochInfo[]>}
+     */
+    async getEpochsInfo(count, ascending, start) {
+        return await getEpochsInfo(this.grpcPool, count, ascending, start);
+    }
+}

package/src/node/status.js

@@ -0,0 +1,41 @@
+import { GetStatusRequest } from '../../proto/generated/platform';
+import bytesToHex from '../utils/bytesToHex';
+export default async function status(grpcPool) {
+    const getStatusRequest = GetStatusRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {}
+        }
+    });
+    const { response } = await grpcPool.getClient().getStatus(getStatusRequest);
+    const { version } = response;
+    if (version.oneofKind !== 'v0') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be v0)');
+    }
+    const { v0 } = version;
+    return {
+        node: (v0.node != null)
+            ? {
+                id: bytesToHex(v0.node.id),
+                proTxHash: v0.node.proTxHash != null ? bytesToHex(v0.node.proTxHash) : undefined
+            }
+            : undefined,
+        chain: (v0.chain != null)
+            ? {
+                catchingUp: v0.chain.catchingUp,
+                latestBlockHeight: v0.chain.latestBlockHeight,
+                earliestBlockHeight: v0.chain.earliestBlockHeight,
+                maxPeerBlockHeight: v0.chain.maxPeerBlockHeight,
+                coreChainLockedHeight: v0.chain.coreChainLockedHeight,
+                latestBlockHash: v0.chain?.latestBlockHash != null ? bytesToHex(v0.chain?.latestBlockHash) : '',
+                latestAppHash: v0.chain?.latestAppHash != null ? bytesToHex(v0.chain?.latestAppHash) : '',
+                earliestBlockHash: v0.chain?.earliestBlockHash != null ? bytesToHex(v0.chain?.earliestBlockHash) : '',
+                earliestAppHash: v0.chain?.earliestAppHash != null ? bytesToHex(v0.chain?.earliestAppHash) : ''
+            }
+            : undefined,
+        version: v0.version,
+        network: v0.network,
+        stateSync: v0.stateSync,
+        time: v0.time
+    };
+}

package/src/node/totalCredits.js

@@ -0,0 +1,35 @@
+import { GetTotalCreditsInPlatformRequest } from '../../proto/generated/platform';
+import { HALVING_INTERVAL, MAINNET_ACTIVATION_HEIGHT, TESTNET_ACTIVATION_HEIGHT } from '../constants';
+import { PlatformVersionWASM, verifyTotalCreditsProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+export default async function totalCredits(grpcPool, network) {
+    const getTotalCreditsInPlatformRequest = GetTotalCreditsInPlatformRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: { prove: true }
+        }
+    });
+    const { response } = await grpcPool.getClient().getTotalCreditsInPlatform(getTotalCreditsInPlatformRequest);
+    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 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 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 totalCredits;
+}

package/src/signer/AbstractSigner.js

@@ -0,0 +1 @@
+export {};

package/src/signer/PrivateKeySigner.js

@@ -0,0 +1,64 @@
+// import { IdentityWASM, NetworkWASM, PrivateKeyWASM, StateTransitionWASM } from 'pshenmic-dpp'
+// import { base64 } from '@scure/base'
+// import { IdentitiesController } from '../identities'
+// import {AbstractSigner} from "./AbstractSigner";
+//
+// export class PrivateKeySigner implements AbstractSigner {
+//   privateKey: PrivateKeyWASM
+//   identity: IdentityWASM
+//   identities: IdentitiesController
+//
+//   constructor (identitiesController: IdentitiesController, privateKey: string | PrivateKeyWASM, network?: NetworkWASM | string) {
+//     this.identities = identitiesController
+//
+//     if (typeof privateKey === 'string') {
+//       let privateKeyWASM
+//
+//       try {
+//         privateKeyWASM = PrivateKeyWASM.fromWIF(privateKey)
+//       } catch (e) {
+//       }
+//
+//       if (privateKey.length === 64 && !network) {
+//         throw new Error('Network must be specified if hex or base64 private key being used')
+//       }
+//
+//       try {
+//         privateKeyWASM = PrivateKeyWASM.fromHex(privateKey, network)
+//       } catch (e) {
+//       }
+//
+//       try {
+//         privateKeyWASM = PrivateKeyWASM.fromBytes(base64.decode(privateKey), network)
+//       } catch (e) {
+//       }
+//
+//       if (privateKeyWASM == null) {
+//         throw new Error('Could not decode private key')
+//       }
+//     } else if (privateKey?.__type === 'PrivateKeyWASM') {
+//       this.privateKey = privateKey
+//     } else {
+//       throw new Error('Unrecognized private key type')
+//     }
+//   }
+//
+//   async connect (): Promise<void> {
+//     this.identity = await this.identities.getIdentityByPublicKeyHash(this.privateKey.getPublicKeyHash())
+//   }
+//
+//   getCurrentIdentity (): IdentityWASM {
+//     return this.identity
+//   }
+//
+//   signStateTransition (stateTransition: StateTransitionWASM): void {
+//     const [identityPublicKey] = this.identity.getPublicKeys()
+//       .filter(identityPublicKey => identityPublicKey.getPublicKeyHash() === this.privateKey.getPublicKeyHash())
+//
+//     if (identityPublicKey == null) {
+//       throw new Error('Could not find an identity public key of identity matching this private key')
+//     }
+//
+//     stateTransition.sign(this.privateKey, identityPublicKey)
+//   }
+// }

package/src/signer/setSigner.js

@@ -0,0 +1,5 @@
+export default function setSigner(signer) {
+    this.signer = signer;
+    this.signer.identities = this.identities;
+    this.signer.setSigner = setSigner;
+}

package/src/stateTransitions/broadcast.js

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

package/src/stateTransitions/index.js

@@ -0,0 +1,34 @@
+import waitForStateTransitionResult from './waitForStateTransitionResult';
+import broadcast from './broadcast';
+/**
+ * Collection of methods to perform state transitions (transactions) such like broadcast, wait for state transition result
+ *
+ * @hideconstructor
+ */
+export class StateTransitionsController {
+    /** @ignore **/
+    grpcPool;
+    constructor(grpcPool) {
+        this.grpcPool = grpcPool;
+    }
+    /**
+     * Broadcasts a state transition to a network
+     *
+     * @param stateTransition {StateTransitionWASM}
+     *
+     * @return {Promise<void>}
+     */
+    async broadcast(stateTransition) {
+        return await broadcast(this.grpcPool, stateTransition);
+    }
+    /**
+     * Waits for a given state transition to finalize in the network (usually 1-3 sec)
+     *
+     * @param stateTransition {StateTransitionWASM}
+     *
+     * @return {Promise<void>}
+     */
+    async waitForStateTransitionResult(stateTransition) {
+        return await waitForStateTransitionResult(this.grpcPool, stateTransition);
+    }
+}

package/src/stateTransitions/waitForStateTransitionResult.js

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

package/src/tokens/createStateTransition.js

@@ -0,0 +1,67 @@
+import { BatchedTransitionWASM, BatchTransitionWASM, TokenBurnTransitionWASM, TokenDestroyFrozenFundsTransitionWASM, TokenDirectPurchaseTransitionWASM, TokenEmergencyActionTransitionWASM, TokenFreezeTransitionWASM, TokenMintTransitionWASM, TokenSetPriceForDirectPurchaseTransitionWASM, TokenTransferTransitionWASM, TokenTransitionWASM, TokenUnFreezeTransitionWASM } from 'pshenmic-dpp';
+const tokenTransitionsMap = {
+    burn: {
+        class: TokenBurnTransitionWASM,
+        arguments: ['amount', 'publicNote'],
+        optionalArguments: ['publicNote']
+    },
+    mint: {
+        class: TokenMintTransitionWASM,
+        arguments: ['identityId', 'amount', 'publicNote'],
+        optionalArguments: ['publicNote']
+    },
+    transfer: {
+        class: TokenTransferTransitionWASM,
+        arguments: ['identityId', 'amount', 'publicNote', 'sharedEncryptedNote', 'privateEncryptedNote'],
+        optionalArguments: ['publicNote', 'sharedEncryptedNote', 'privateEncryptedNote']
+    },
+    freeze: {
+        class: TokenFreezeTransitionWASM,
+        arguments: ['identityId', 'publicNote'],
+        optionalArguments: ['publicNote']
+    },
+    unfreeze: {
+        class: TokenUnFreezeTransitionWASM,
+        arguments: ['identityId', 'publicNote'],
+        optionalArguments: ['publicNote']
+    },
+    destroyFrozenFunds: {
+        class: TokenDestroyFrozenFundsTransitionWASM,
+        arguments: ['identityId', 'publicNote'],
+        optionalArguments: ['publicNote']
+    },
+    emergencyAction: {
+        class: TokenEmergencyActionTransitionWASM,
+        arguments: ['emergencyAction', 'publicNote'],
+        optionalArguments: ['publicNote']
+    },
+    directPurchase: {
+        class: TokenDirectPurchaseTransitionWASM,
+        arguments: ['amount', 'totalAgreedPrice'],
+        optionalArguments: []
+    },
+    setPriceForDirectPurchase: {
+        class: TokenSetPriceForDirectPurchaseTransitionWASM,
+        arguments: ['price', 'publicNote'],
+        optionalArguments: ['publicNote']
+    }
+};
+export default function createStateTransition(base, ownerId, type, params) {
+    const { class: TransitionClass, arguments: classArguments, optionalArguments } = tokenTransitionsMap[type];
+    if (TransitionClass == null) {
+        throw new Error(`Unimplemented transition type: ${type}`);
+    }
+    // check if all required params for token transition exists
+    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 tokenTransition = new TransitionClass(base, ...transitionParams);
+    const tokenTransitionWASM = new TokenTransitionWASM(tokenTransition);
+    const batchedTransition = new BatchedTransitionWASM(tokenTransitionWASM);
+    return BatchTransitionWASM.fromV1BatchedTransitions([batchedTransition], ownerId, 1).toStateTransition();
+}

package/src/tokens/getIdentitiesTokenBalances.js

@@ -0,0 +1,43 @@
+import { GetIdentitiesTokenBalancesRequest } from '../../proto/generated/platform';
+import { IdentifierWASM, PlatformVersionWASM, verifyTokenBalancesForIdentitiesProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+export default async function getIdentitiesTokenBalances(grpcPool, identifiers, tokenIdentifier) {
+    const ids = identifiers.map(identifier => new IdentifierWASM(identifier));
+    const tokenId = new IdentifierWASM(tokenIdentifier);
+    const getIdentitiesTokenBalancesRequest = GetIdentitiesTokenBalancesRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                tokenId: tokenId.bytes(),
+                identityIds: ids.map(id => id.bytes()),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentitiesTokenBalances(getIdentitiesTokenBalancesRequest);
+    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, balances } = verifyTokenBalancesForIdentitiesProof(proof.grovedbProof, tokenId, true, ids, 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 balances
+        .map((identityTokenBalance) => ({
+        identityId: new IdentifierWASM(identityTokenBalance.identityId),
+        balance: identityTokenBalance.balance
+    }));
+}