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

package/src/node/totalCredits.js

@@ -0,0 +1,35 @@
+import { GetTotalCreditsInPlatformRequest } from '../../proto/generated/platform.js';
+import { HALVING_INTERVAL, MAINNET_ACTIVATION_HEIGHT, TESTNET_ACTIVATION_HEIGHT } from '../constants.js';
+import { PlatformVersionWASM, verifyTotalCreditsProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
+import bytesToHex from '../utils/bytesToHex.js';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+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.d.ts

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

package/src/signer/PrivateKeySigner.js

@@ -0,0 +1,65 @@
+export {};
+// 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.d.ts

@@ -1,2 +1,2 @@
-import { AbstractSigner } from './AbstractSigner';
+import { AbstractSigner } from './AbstractSigner.js';
 export default function setSigner(signer: AbstractSigner): void;

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.d.ts

@@ -1,3 +1,3 @@
 import { StateTransitionWASM } from 'pshenmic-dpp';
-import GRPCConnectionPool from '../grpcConnectionPool';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function broadcast(grpcPool: GRPCConnectionPool, stateTransition: StateTransitionWASM): Promise<void>;

package/src/stateTransitions/broadcast.js

@@ -0,0 +1,10 @@
+import { BroadcastStateTransitionRequest } from '../../proto/generated/platform.js';
+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.d.ts

@@ -1,5 +1,5 @@
 import { StateTransitionWASM } from 'pshenmic-dpp';
-import GRPCConnectionPool from '../grpcConnectionPool';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
 /**
  * Collection of methods to perform state transitions (transactions) such like broadcast, wait for state transition result
  *

package/src/stateTransitions/index.js

@@ -0,0 +1,34 @@
+import waitForStateTransitionResult from './waitForStateTransitionResult.js';
+import broadcast from './broadcast.js';
+/**
+ * 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.d.ts

@@ -1,3 +1,3 @@
 import { StateTransitionWASM } from 'pshenmic-dpp';
-import GRPCConnectionPool from '../grpcConnectionPool';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function waitForStateTransitionResult(grpcPool: GRPCConnectionPool, stateTransition: StateTransitionWASM): Promise<void>;

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.d.ts

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

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.d.ts

@@ -1,5 +1,5 @@
-import GRPCConnectionPool from '../grpcConnectionPool';
-import { IdentifierLike } from '../types';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { IdentifierLike } from '../types.js';
 import { IdentifierWASM } from 'pshenmic-dpp';
 export interface IdentitiesTokenBalances {
     identityId: IdentifierWASM;

package/src/tokens/getIdentitiesTokenBalances.js

@@ -0,0 +1,43 @@
+import { GetIdentitiesTokenBalancesRequest } from '../../proto/generated/platform.js';
+import { IdentifierWASM, PlatformVersionWASM, verifyTokenBalancesForIdentitiesProof } 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 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
+    }));
+}

package/src/tokens/getIdentityTokensBalances.d.ts

@@ -1,5 +1,5 @@
-import GRPCConnectionPool from '../grpcConnectionPool';
-import { IdentifierLike } from '../types';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { IdentifierLike } from '../types.js';
 import { IdentifierWASM } from 'pshenmic-dpp';
 export interface IdentityTokenBalances {
     tokenId: IdentifierWASM;

package/src/tokens/getIdentityTokensBalances.js

@@ -0,0 +1,43 @@
+import { IdentifierWASM, PlatformVersionWASM, verifyTokensBalancesForIdentityProof } from 'pshenmic-dpp';
+import { GetIdentityTokenBalancesRequest } from '../../proto/generated/platform.js';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
+import bytesToHex from '../utils/bytesToHex.js';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+export default async function getIdentityTokensBalances(grpcPool, identifier, tokenIdentifiers) {
+    const id = new IdentifierWASM(identifier);
+    const tokenIds = tokenIdentifiers.map(tokenIdentifier => new IdentifierWASM(tokenIdentifier));
+    const getIdentityTokenBalancesRequest = GetIdentityTokenBalancesRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                tokenIds: tokenIds.map((identifier) => identifier.bytes()),
+                identityId: id.bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityTokenBalances(getIdentityTokenBalancesRequest);
+    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 } = verifyTokensBalancesForIdentityProof(proof.grovedbProof, tokenIds, id, true, 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((tokenBalance) => ({
+        tokenId: new IdentifierWASM(tokenBalance.tokenId),
+        balance: tokenBalance.balance
+    }));
+}

package/src/tokens/getTokenContractInfo.d.ts

@@ -1,5 +1,5 @@
-import GRPCConnectionPool from '../grpcConnectionPool';
-import { IdentifierLike } from '../types';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { IdentifierLike } from '../types.js';
 import { IdentifierWASM } from 'pshenmic-dpp';
 export interface TokenContractInfo {
     dataContractId: IdentifierWASM;

package/src/tokens/getTokenContractInfo.js

@@ -0,0 +1,43 @@
+import { GetTokenContractInfoRequest } from '../../proto/generated/platform.js';
+import { IdentifierWASM, PlatformVersionWASM, verifyTokenContractInfoProof } 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 getTokenContractInfo(grpcPool, tokenIdentifier) {
+    const tokenId = new IdentifierWASM(tokenIdentifier);
+    const getTokenContractInfoRequest = GetTokenContractInfoRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                tokenId: (tokenId).bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getTokenContractInfo(getTokenContractInfoRequest);
+    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, contractInfo } = verifyTokenContractInfoProof(proof.grovedbProof, tokenId, true, PlatformVersionWASM.PLATFORM_V9);
+    if (contractInfo == null) {
+        throw new Error('ContractInfo 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 {
+        dataContractId: contractInfo.contractId,
+        tokenContractPosition: contractInfo.tokenContractPosition
+    };
+}

package/src/tokens/getTokenDirectPurchasePrices.d.ts

@@ -1,3 +1,3 @@
-import GRPCConnectionPool from '../grpcConnectionPool';
-import { IdentifierLike, TokenDirectPurchasePrices } from '../types';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { IdentifierLike, TokenDirectPurchasePrices } from '../types.js';
 export default function getTokenDirectPurchasePrices(grpcPool: GRPCConnectionPool, tokenIdentifiers: IdentifierLike[]): Promise<TokenDirectPurchasePrices[]>;

package/src/tokens/getTokenDirectPurchasePrices.js

@@ -0,0 +1,40 @@
+import { IdentifierWASM, PlatformVersionWASM, verifyTokenDirectPurchasePrices } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import bytesToHex from '../utils/bytesToHex.js';
+import { GetTokenDirectPurchasePricesRequest } from '../../proto/generated/platform.js';
+export default async function getTokenDirectPurchasePrices(grpcPool, tokenIdentifiers) {
+    const tokenIds = tokenIdentifiers.map(tokenId => new IdentifierWASM(tokenId).bytes());
+    const request = GetTokenDirectPurchasePricesRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                tokenIds,
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getTokenDirectPurchasePrices(request);
+    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, prices } = verifyTokenDirectPurchasePrices(proof.grovedbProof, tokenIds, true, PlatformVersionWASM.PLATFORM_V9);
+    if (prices == null) {
+        throw new Error('Prices 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 prices;
+}

package/src/tokens/getTokenTotalSupply.d.ts

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

package/src/tokens/getTokenTotalSupply.js

@@ -0,0 +1,41 @@
+import { GetTokenTotalSupplyRequest } from '../../proto/generated/platform.js';
+import { IdentifierWASM, PlatformVersionWASM, verifyTokenTotalSupplyProof } 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 getTokenTotalSupply(grpcPool, tokenIdentifier) {
+    const tokenId = new IdentifierWASM(tokenIdentifier);
+    const getTokenTotalSupplyRequest = GetTokenTotalSupplyRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                tokenId: (tokenId).bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getTokenTotalSupply(getTokenTotalSupplyRequest);
+    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 } = verifyTokenTotalSupplyProof(proof.grovedbProof, tokenId, true, 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 {
+        tokenId,
+        totalSystemAmount: totalBalance.tokenSupply,
+        totalAggregatedAmountInUserAccounts: totalBalance.aggregatedTokenAccountBalances
+    };
+}

package/src/tokens/index.d.ts

@@ -1,8 +1,8 @@
-import GRPCConnectionPool from '../grpcConnectionPool';
-import { IdentifierLike, TokenDirectPurchasePrices, TokenTotalSupply, TokenTransitionParams, TokenTransitionType } from '../types';
-import { IdentitiesTokenBalances } from './getIdentitiesTokenBalances';
-import { IdentityTokenBalances } from './getIdentityTokensBalances';
-import { TokenContractInfo } from './getTokenContractInfo';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { IdentifierLike, TokenDirectPurchasePrices, TokenTotalSupply, TokenTransitionParams, TokenTransitionType } from '../types.js';
+import { IdentitiesTokenBalances } from './getIdentitiesTokenBalances.js';
+import { IdentityTokenBalances } from './getIdentityTokensBalances.js';
+import { TokenContractInfo } from './getTokenContractInfo.js';
 import { StateTransitionWASM, TokenBaseTransitionWASM } from 'pshenmic-dpp';
 /**
  * Tokens controller for requesting information about tokens and tokens holders

package/src/tokens/index.js

@@ -0,0 +1,108 @@
+import getIdentitiesTokenBalances from './getIdentitiesTokenBalances.js';
+import getIdentityTokensBalances from './getIdentityTokensBalances.js';
+import getTokenContractInfo from './getTokenContractInfo.js';
+import getTokenTotalSupply from './getTokenTotalSupply.js';
+import createStateTransition from './createStateTransition.js';
+import { IdentifierWASM, TokenBaseTransitionWASM, TokenPricingScheduleWASM } from 'pshenmic-dpp';
+import getIdentityContractNonce from '../identities/getIdentityContractNonce.js';
+import getTokenDirectPurchasePrices from './getTokenDirectPurchasePrices.js';
+/**
+ * Tokens controller for requesting information about tokens and tokens holders
+ *
+ * @hideconstructor
+ */
+export class TokensController {
+    /** @ignore **/
+    grpcPool;
+    constructor(grpcPool) {
+        this.grpcPool = grpcPool;
+    }
+    /**
+     * Retrieves a token balances for identities
+     *
+     * @param identifiers {IdentifierLike[]} - list of identifiers which balance we need to get
+     * @param tokenIdentifier {IdentifierLike} - token identifier
+     *
+     * @return {Promise<IdentitiesTokenBalances>}
+     */
+    async getIdentitiesTokenBalances(identifiers, tokenIdentifier) {
+        return await getIdentitiesTokenBalances(this.grpcPool, identifiers, tokenIdentifier);
+    }
+    /**
+     * Retrieves a tokens balances for identity
+     *
+     * @param identifier {IdentifierLike} - identifier which balance we need to get
+     * @param tokenIdentifiers {IdentifierLike[]} - list of tokens ids which used in request
+     *
+     * @return {Promise<IdentityTokenBalances>}
+     */
+    async getIdentityTokensBalances(identifier, tokenIdentifiers) {
+        return await getIdentityTokensBalances(this.grpcPool, identifier, tokenIdentifiers);
+    }
+    /**
+     * Retrieves a tokens contract info by id
+     *
+     * @param tokenIdentifier {IdentifierLike} - token id which contract info we need
+     *
+     * @return {Promise<TokenContractInfo>}
+     */
+    async getTokenContractInfo(tokenIdentifier) {
+        return await getTokenContractInfo(this.grpcPool, tokenIdentifier);
+    }
+    /**
+     * Retrieves a token total supply
+     *
+     * @param tokenIdentifier {IdentifierLike} - token id which total supply we need
+     *
+     * @return {Promise<TokenTotalSupply>}
+     */
+    async getTokenTotalSupply(tokenIdentifier) {
+        return await getTokenTotalSupply(this.grpcPool, tokenIdentifier);
+    }
+    /**
+     * Retrieves a tokens prices
+     *
+     * @param tokenIdentifiers {IdentifierLike[]} - token ids which price we need
+     *
+     * @return {Promise<TokenDirectPurchasePrices[]>}
+     */
+    async getTokensDirectPurchasePrice(tokenIdentifiers) {
+        return await getTokenDirectPurchasePrices(this.grpcPool, tokenIdentifiers);
+    }
+    /**
+     * Creates a Token Base Transition that contains base information about token transition
+     *
+     * @param tokenId {IdentifierLike} - token identifier
+     * @param ownerId {IdentifierLike} - identity identifier of sender of the transaction
+     *
+     * @return {TokenBaseTransitionWASM}
+     */
+    async createBaseTransition(tokenId, ownerId) {
+        const { dataContractId, tokenContractPosition } = await getTokenContractInfo(this.grpcPool, tokenId);
+        const identityContractNonce = await getIdentityContractNonce(this.grpcPool, ownerId, dataContractId);
+        return new TokenBaseTransitionWASM(identityContractNonce + BigInt(1), tokenContractPosition, dataContractId, tokenId, undefined);
+    }
+    /**
+     * Helper function for creation of a token state transition to be broadcasted in the network
+     *
+     * You have to pass token base transition acquired from .createBaseTransition() method
+     * together with token transition type and its params
+     *
+     * @param base {TokenBaseTransitionWASM} - token Base transition
+     * @param ownerId {IdentifierLike} - `identity identifier of the owner of the transaction`
+     * @param type {TokenTransitionType} - token transition type as string (f.e. 'transfer')
+     * @param params {TokenTransitionParams} - params required for a token transition
+     *
+     * @return {StateTransitionWASM}
+     */
+    createStateTransition(base, ownerId, type, params) {
+        const owner = new IdentifierWASM(ownerId);
+        if (params.identityId != null) {
+            params.identityId = new IdentifierWASM(params.identityId);
+        }
+        if (params.price != null && typeof params.price === 'bigint') {
+            params.price = TokenPricingScheduleWASM.SinglePrice(params.price);
+        }
+        return createStateTransition(base, owner, type, params);
+    }
+}