dash-platform-sdk 1.1.4 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dash-platform-sdk",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "main": "index.js",
   "description": "Lightweight SDK for accessing Dash Platform blockchain",
   "ts-standard": {

package/src/node/status.js

@@ -38,17 +38,18 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = status;
 var platform_1 = require("../../proto/generated/platform");
+var bytesToHex_1 = require("../utils/bytesToHex");
 function status(grpcPool) {
     return __awaiter(this, void 0, void 0, function () {
         var getStatusRequest, response, v0;
-        var _a, _b, _c, _d, _e;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return __generator(this, function (_j) {
+            switch (_j.label) {
                 case 0:
                     getStatusRequest = platform_1.GetStatusRequest.fromPartial({ v0: {} });
                     return [4 /*yield*/, grpcPool.getClient().getStatus(getStatusRequest)];
                 case 1:
-                    response = _f.sent();
+                    response = _j.sent();
                     v0 = response.v0;
                     if (v0 == null) {
                         throw new Error('Unable to get node status');
@@ -56,8 +57,8 @@ function status(grpcPool) {
                     return [2 /*return*/, {
                             node: (v0.node != null)
                                 ? {
-                                    id: v0.node.id.reduce(function (acc, code) { return acc + code.toString(16); }, ''),
-                                    proTxHash: (_a = v0.node.proTxHash) === null || _a === void 0 ? void 0 : _a.reduce(function (acc, code) { return acc + code.toString(16); }, '')
+                                    id: (0, bytesToHex_1.default)(v0.node.id),
+                                    proTxHash: v0.node.proTxHash != null ? (0, bytesToHex_1.default)(v0.node.proTxHash) : undefined
                                 }
                                 : undefined,
                             chain: (v0.chain != null)
@@ -67,10 +68,10 @@ function status(grpcPool) {
                                     earliestBlockHeight: v0.chain.earliestBlockHeight,
                                     maxPeerBlockHeight: v0.chain.maxPeerBlockHeight,
                                     coreChainLockedHeight: v0.chain.coreChainLockedHeight,
-                                    latestBlockHash: (_b = v0.chain) === null || _b === void 0 ? void 0 : _b.latestBlockHash.reduce(function (acc, code) { return acc + code.toString(16); }, ''),
-                                    latestAppHash: (_c = v0.chain) === null || _c === void 0 ? void 0 : _c.latestAppHash.reduce(function (acc, code) { return acc + code.toString(16); }, ''),
-                                    earliestBlockHash: (_d = v0.chain) === null || _d === void 0 ? void 0 : _d.earliestBlockHash.reduce(function (acc, code) { return acc + code.toString(16); }, ''),
-                                    earliestAppHash: (_e = v0.chain) === null || _e === void 0 ? void 0 : _e.earliestAppHash.reduce(function (acc, code) { return acc + code.toString(16); }, '')
+                                    latestBlockHash: ((_a = v0.chain) === null || _a === void 0 ? void 0 : _a.latestBlockHash) != null ? (0, bytesToHex_1.default)((_b = v0.chain) === null || _b === void 0 ? void 0 : _b.latestBlockHash) : '',
+                                    latestAppHash: ((_c = v0.chain) === null || _c === void 0 ? void 0 : _c.latestAppHash) != null ? (0, bytesToHex_1.default)((_d = v0.chain) === null || _d === void 0 ? void 0 : _d.latestAppHash) : '',
+                                    earliestBlockHash: ((_e = v0.chain) === null || _e === void 0 ? void 0 : _e.earliestBlockHash) != null ? (0, bytesToHex_1.default)((_f = v0.chain) === null || _f === void 0 ? void 0 : _f.earliestBlockHash) : '',
+                                    earliestAppHash: ((_g = v0.chain) === null || _g === void 0 ? void 0 : _g.earliestAppHash) != null ? (0, bytesToHex_1.default)((_h = v0.chain) === null || _h === void 0 ? void 0 : _h.earliestAppHash) : ''
                                 }
                                 : undefined,
                             version: v0.version,

package/src/tokens/createStateTransition.d.ts

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

package/src/tokens/createStateTransition.js

@@ -0,0 +1,79 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createStateTransition;
+var pshenmic_dpp_1 = require("pshenmic-dpp");
+var tokenTransitionsMap = {
+    burn: {
+        class: pshenmic_dpp_1.TokenBurnTransitionWASM,
+        arguments: ['amount', 'publicNote'],
+        optionalArguments: ['publicNote']
+    },
+    mint: {
+        class: pshenmic_dpp_1.TokenMintTransitionWASM,
+        arguments: ['identityId', 'amount', 'publicNote'],
+        optionalArguments: ['publicNote']
+    },
+    transfer: {
+        class: pshenmic_dpp_1.TokenTransferTransitionWASM,
+        arguments: ['identityId', 'amount', 'publicNote', 'sharedEncryptedNote', 'privateEncryptedNote'],
+        optionalArguments: ['publicNote', 'sharedEncryptedNote', 'privateEncryptedNote']
+    },
+    freeze: {
+        class: pshenmic_dpp_1.TokenFreezeTransitionWASM,
+        arguments: ['identityId', 'publicNote'],
+        optionalArguments: ['publicNote']
+    },
+    unfreeze: {
+        class: pshenmic_dpp_1.TokenUnFreezeTransitionWASM,
+        arguments: ['identityId', 'publicNote'],
+        optionalArguments: ['publicNote']
+    },
+    destroyFrozenFunds: {
+        class: pshenmic_dpp_1.TokenDestroyFrozenFundsTransitionWASM,
+        arguments: ['identityId', 'publicNote'],
+        optionalArguments: ['publicNote']
+    },
+    emergencyAction: {
+        class: pshenmic_dpp_1.TokenEmergencyActionTransitionWASM,
+        arguments: ['emergencyAction', 'publicNote'],
+        optionalArguments: ['publicNote']
+    },
+    directPurchase: {
+        class: pshenmic_dpp_1.TokenDirectPurchaseTransitionWASM,
+        arguments: ['amount', 'totalAgreedPrice'],
+        optionalArguments: []
+    },
+    setPriceForDirectPurchase: {
+        class: pshenmic_dpp_1.TokenSetPriceForDirectPurchaseTransitionWASM,
+        arguments: ['price', 'publicNote'],
+        optionalArguments: ['publicNote']
+    }
+};
+function createStateTransition(base, ownerId, type, params) {
+    var _a = tokenTransitionsMap[type], TransitionClass = _a.class, classArguments = _a.arguments, optionalArguments = _a.optionalArguments;
+    if (TransitionClass == null) {
+        throw new Error("Unimplemented transition type: ".concat(type));
+    }
+    // check if all required params for token transition exists
+    var missingArgument = classArguments
+        .filter(function (classArgument) { return params[classArgument] == null &&
+        !optionalArguments.includes(classArgument); })[0];
+    if (missingArgument != null) {
+        throw new Error("Token transition param \"".concat(missingArgument, "\" is missing"));
+    }
+    var transitionParams = classArguments.map(function (classArgument) { return params[classArgument]; });
+    // @ts-expect-error
+    var tokenTransition = new (TransitionClass.bind.apply(TransitionClass, __spreadArray([void 0, base], transitionParams, false)))();
+    var tokenTransitionWASM = new pshenmic_dpp_1.TokenTransitionWASM(tokenTransition);
+    var batchedTransition = new pshenmic_dpp_1.BatchedTransitionWASM(tokenTransitionWASM);
+    return pshenmic_dpp_1.BatchTransitionWASM.fromV1BatchedTransitions([batchedTransition], ownerId, 1).toStateTransition();
+}

package/src/tokens/getTokenContractInfo.d.ts

@@ -2,7 +2,7 @@ import GRPCConnectionPool from '../grpcConnectionPool';
 import { IdentifierLike } from '../types';
 import { IdentifierWASM } from 'pshenmic-dpp';
 export interface TokenContractInfo {
-    contractId: IdentifierWASM;
+    dataContractId: IdentifierWASM;
     tokenContractPosition: number;
 }
 export default function getTokenContractInfo(grpcPool: GRPCConnectionPool, tokenIdentifier: IdentifierLike): Promise<TokenContractInfo>;

package/src/tokens/getTokenContractInfo.js

@@ -78,7 +78,7 @@ function getTokenContractInfo(grpcPool, tokenIdentifier) {
                         throw new Error('Failed to verify query');
                     }
                     return [2 /*return*/, {
-                            contractId: new pshenmic_dpp_1.IdentifierWASM(contractInfo.contractId),
+                            dataContractId: new pshenmic_dpp_1.IdentifierWASM(contractInfo.contractId),
                             tokenContractPosition: contractInfo.tokenContractPosition
                         }];
             }

package/src/tokens/index.d.ts

@@ -1,9 +1,10 @@
 import GRPCConnectionPool from '../grpcConnectionPool';
-import { IdentifierLike } from '../types';
+import { IdentifierLike, TokenTransitionParams, TokenTransitionType } from '../types';
 import { IdentitiesTokenBalances } from './getIdentitiesTokenBalances';
 import { IdentityTokenBalances } from './getIdentityTokensBalances';
 import { TokenContractInfo } from './getTokenContractInfo';
 import { TokenTotalSupply } from './getTokenTotalSupply';
+import { StateTransitionWASM, TokenBaseTransitionWASM } from 'pshenmic-dpp';
 /**
  * Tokens controller for requesting information about tokens and tokens holders
  *
@@ -47,4 +48,27 @@ export default class TokensController {
      * @return {Promise<TokenTotalSupply>}
      */
     getTokenTotalSupply(tokenIdentifier: IdentifierLike): Promise<TokenTotalSupply>;
+    /**
+     * 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}
+     */
+    createBaseTransition(tokenId: IdentifierLike, ownerId: IdentifierLike): Promise<TokenBaseTransitionWASM>;
+    /**
+     * 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: TokenBaseTransitionWASM, ownerId: IdentifierLike, type: TokenTransitionType, params: TokenTransitionParams): StateTransitionWASM;
 }

package/src/tokens/index.js

@@ -40,6 +40,9 @@ var getIdentitiesTokenBalances_1 = require("./getIdentitiesTokenBalances");
 var getIdentityTokensBalances_1 = require("./getIdentityTokensBalances");
 var getTokenContractInfo_1 = require("./getTokenContractInfo");
 var getTokenTotalSupply_1 = require("./getTokenTotalSupply");
+var createStateTransition_1 = require("./createStateTransition");
+var pshenmic_dpp_1 = require("pshenmic-dpp");
+var getIdentityContractNonce_1 = require("../identities/getIdentityContractNonce");
 /**
  * Tokens controller for requesting information about tokens and tokens holders
  *
@@ -119,6 +122,53 @@ var TokensController = /** @class */ (function () {
             });
         });
     };
+    /**
+     * 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}
+     */
+    TokensController.prototype.createBaseTransition = function (tokenId, ownerId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, dataContractId, tokenContractPosition, identityContractNonce;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, (0, getTokenContractInfo_1.default)(this.grpcPool, tokenId)];
+                    case 1:
+                        _a = _b.sent(), dataContractId = _a.dataContractId, tokenContractPosition = _a.tokenContractPosition;
+                        return [4 /*yield*/, (0, getIdentityContractNonce_1.default)(this.grpcPool, ownerId, dataContractId)];
+                    case 2:
+                        identityContractNonce = _b.sent();
+                        return [2 /*return*/, new pshenmic_dpp_1.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}
+     */
+    TokensController.prototype.createStateTransition = function (base, ownerId, type, params) {
+        var owner = new pshenmic_dpp_1.IdentifierWASM(ownerId);
+        if (params.identityId != null) {
+            params.identityId = new pshenmic_dpp_1.IdentifierWASM(params.identityId);
+        }
+        if (params.price != null && typeof params.price === 'bigint') {
+            params.price = pshenmic_dpp_1.TokenPricingScheduleWASM.SinglePrice(params.price);
+        }
+        return (0, createStateTransition_1.default)(base, owner, type, params);
+    };
     return TokensController;
 }());
 exports.default = TokensController;

package/src/types.d.ts

@@ -1,4 +1,4 @@
-import { IdentifierWASM } from 'pshenmic-dpp';
+import { IdentifierWASM, TokenEmergencyActionWASM, TokenPricingScheduleWASM } from 'pshenmic-dpp';
 import { Versions } from 'dashhd';
 export { IdentifierWASM, IdentityWASM, DocumentWASM, DataContractWASM, StateTransitionWASM, IdentityPublicKeyWASM } from 'pshenmic-dpp';
 export type IdentifierLike = IdentifierWASM | string | Uint8Array;
@@ -135,3 +135,14 @@ export interface DataContractConfig {
     requiresIdentityEncryptionBoundedKey?: number | null;
     requiresIdentityDecryptionBoundedKey?: number | null;
 }
+export type TokenTransitionType = 'burn' | 'mint' | 'transfer' | 'freeze' | 'unfreeze' | 'destroyFrozenFunds' | 'emergencyAction' | 'directPurchase' | 'setPriceForDirectPurchase';
+export interface TokenTransitionParams {
+    identityId?: IdentifierLike;
+    amount?: bigint;
+    price?: bigint | TokenPricingScheduleWASM;
+    totalAgreedPrice?: bigint;
+    publicNote?: string;
+    sharedEncryptedNote?: string;
+    privateEncryptedNote?: string;
+    emergencyAction?: TokenEmergencyActionWASM;
+}

package/test/unit/Tokens.spec.js

@@ -37,6 +37,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var types_1 = require("../../src/types");
+var pshenmic_dpp_1 = require("pshenmic-dpp");
 var sdk;
 describe('Tokens', function () {
     beforeAll(function () {
@@ -63,7 +64,7 @@ describe('Tokens', function () {
                 case 0: return [4 /*yield*/, sdk.tokens.getTokenContractInfo('9YxdbQUjJmQsmVPen95HjAU3Esj7tVkWSY2EQWT84ZQP')];
                 case 1:
                     tokenContractInfo = _a.sent();
-                    expect(tokenContractInfo.contractId.base58()).toEqual('Y189uedQG3CJCuu83P3DqnG7ngQaRKz69x3gY8uDzQe');
+                    expect(tokenContractInfo.dataContractId.base58()).toEqual('Y189uedQG3CJCuu83P3DqnG7ngQaRKz69x3gY8uDzQe');
                     expect(tokenContractInfo.tokenContractPosition).toEqual(0);
                     return [2 /*return*/];
             }
@@ -97,4 +98,174 @@ describe('Tokens', function () {
             }
         });
     }); });
+    test('should be able to create base token transition', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var tokenBaseTransition;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, sdk.tokens.createBaseTransition('A36eJF2kyYXwxCtJGsgbR3CTAscUFaNxZN19UqUfM1kw', '34vkjdeUTP2z798SiXqoB6EAuobh51kXYURqVa9xkujf')];
+                case 1:
+                    tokenBaseTransition = _a.sent();
+                    expect(tokenBaseTransition).toBeInstanceOf(pshenmic_dpp_1.TokenBaseTransitionWASM);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    describe('create state transitions', function () {
+        test('should be able to create burn transition', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var tokenId, owner, amount, tokenBaseTransition, stateTransition;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+                        owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+                        amount = BigInt(10);
+                        return [4 /*yield*/, sdk.tokens.createBaseTransition(tokenId, owner)];
+                    case 1:
+                        tokenBaseTransition = _a.sent();
+                        stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'burn', { amount: amount });
+                        expect(stateTransition).toBeInstanceOf(pshenmic_dpp_1.StateTransitionWASM);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        test('should be able to create mint transition', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var tokenId, owner, recipientId, amount, tokenBaseTransition, stateTransition;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+                        owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+                        recipientId = '8GopLQQCViyroS2gHktesGaCMe2tueXWeQ6Y9vpMFTEC';
+                        amount = BigInt(10);
+                        return [4 /*yield*/, sdk.tokens.createBaseTransition(tokenId, owner)];
+                    case 1:
+                        tokenBaseTransition = _a.sent();
+                        stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'mint', { identityId: recipientId, amount: amount });
+                        expect(stateTransition).toBeInstanceOf(pshenmic_dpp_1.StateTransitionWASM);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        test('should be able to create transfer transition', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var tokenId, owner, recipient, amount, tokenBaseTransition, stateTransition;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+                        owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+                        recipient = '8GopLQQCViyroS2gHktesGaCMe2tueXWeQ6Y9vpMFTEC';
+                        amount = BigInt(100);
+                        return [4 /*yield*/, sdk.tokens.createBaseTransition(tokenId, owner)];
+                    case 1:
+                        tokenBaseTransition = _a.sent();
+                        stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'transfer', { identityId: recipient, amount: amount });
+                        expect(stateTransition).toBeInstanceOf(pshenmic_dpp_1.StateTransitionWASM);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        test('should be able to create freeze transition', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var tokenId, owner, identityId, tokenBaseTransition, stateTransition;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+                        owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+                        identityId = '8GopLQQCViyroS2gHktesGaCMe2tueXWeQ6Y9vpMFTEC';
+                        return [4 /*yield*/, sdk.tokens.createBaseTransition(tokenId, owner)];
+                    case 1:
+                        tokenBaseTransition = _a.sent();
+                        stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'freeze', { identityId: identityId });
+                        expect(stateTransition).toBeInstanceOf(pshenmic_dpp_1.StateTransitionWASM);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        test('should be able to create unfreeze transition', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var tokenId, owner, identityId, tokenBaseTransition, stateTransition;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+                        owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+                        identityId = '8GopLQQCViyroS2gHktesGaCMe2tueXWeQ6Y9vpMFTEC';
+                        return [4 /*yield*/, sdk.tokens.createBaseTransition(tokenId, owner)];
+                    case 1:
+                        tokenBaseTransition = _a.sent();
+                        stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'unfreeze', { identityId: identityId });
+                        expect(stateTransition).toBeInstanceOf(pshenmic_dpp_1.StateTransitionWASM);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        test('should be able to create destroyFrozenFunds transition', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var tokenId, owner, identityId, tokenBaseTransition, stateTransition;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+                        owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+                        identityId = '8GopLQQCViyroS2gHktesGaCMe2tueXWeQ6Y9vpMFTEC';
+                        return [4 /*yield*/, sdk.tokens.createBaseTransition(tokenId, owner)];
+                    case 1:
+                        tokenBaseTransition = _a.sent();
+                        stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'destroyFrozenFunds', { identityId: identityId });
+                        expect(stateTransition).toBeInstanceOf(pshenmic_dpp_1.StateTransitionWASM);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        test('should be able to create emergency action transition', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var tokenId, owner, emergencyAction, tokenBaseTransition, stateTransition;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+                        owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+                        emergencyAction = pshenmic_dpp_1.TokenEmergencyActionWASM.Pause;
+                        return [4 /*yield*/, sdk.tokens.createBaseTransition(tokenId, owner)];
+                    case 1:
+                        tokenBaseTransition = _a.sent();
+                        stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'emergencyAction', { emergencyAction: emergencyAction });
+                        expect(stateTransition).toBeInstanceOf(pshenmic_dpp_1.StateTransitionWASM);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        test('should be able to create setPriceForDirectPurchase transition', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var tokenId, owner, price, tokenBaseTransition, stateTransition;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+                        owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+                        price = BigInt(10);
+                        return [4 /*yield*/, sdk.tokens.createBaseTransition(tokenId, owner)];
+                    case 1:
+                        tokenBaseTransition = _a.sent();
+                        stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'setPriceForDirectPurchase', { price: price });
+                        expect(stateTransition).toBeInstanceOf(pshenmic_dpp_1.StateTransitionWASM);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        test('should be able to create directPurchase transition', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var tokenId, owner, amount, totalAgreedPrice, tokenBaseTransition, stateTransition;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+                        owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+                        amount = BigInt(10);
+                        totalAgreedPrice = BigInt(100);
+                        return [4 /*yield*/, sdk.tokens.createBaseTransition(tokenId, owner)];
+                    case 1:
+                        tokenBaseTransition = _a.sent();
+                        stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'directPurchase', { amount: amount, totalAgreedPrice: totalAgreedPrice });
+                        expect(stateTransition).toBeInstanceOf(pshenmic_dpp_1.StateTransitionWASM);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
 });