dash-platform-sdk 1.3.0-dev.8 → 1.4.0-dev.1

package/src/tokens/createStateTransition.d.ts

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

package/src/tokens/getIdentitiesTokenBalances.d.ts

@@ -1,8 +1,8 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-import { IdentifierLike } from '../types.js';
+import { IdentifierLike } from '../../types.js';
 import { IdentifierWASM } from 'pshenmic-dpp';
 export interface IdentitiesTokenBalances {
     identityId: IdentifierWASM;
-    balance?: string | undefined;
+    balance?: bigint | undefined;
 }
 export default function getIdentitiesTokenBalances(grpcPool: GRPCConnectionPool, identifiers: IdentifierLike[], tokenIdentifier: IdentifierLike): Promise<IdentitiesTokenBalances[]>;

package/src/tokens/getIdentitiesTokenBalances.js

@@ -1,8 +1,9 @@
 import { GetIdentitiesTokenBalancesRequest } from '../../proto/generated/platform.js';
-import { IdentifierWASM, PlatformVersionWASM, verifyTokenBalancesForIdentitiesProof } from 'pshenmic-dpp';
+import { IdentifierWASM, verifyTokenBalancesForIdentitiesProof } from 'pshenmic-dpp';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
 export default async function getIdentitiesTokenBalances(grpcPool, identifiers, tokenIdentifier) {
     const ids = identifiers.map(identifier => new IdentifierWASM(identifier));
     const tokenId = new IdentifierWASM(tokenIdentifier);
@@ -29,15 +30,15 @@ export default async function getIdentitiesTokenBalances(grpcPool, identifiers,
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, balances } = verifyTokenBalancesForIdentitiesProof(proof.grovedbProof, tokenId, true, ids, PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, balances } = verifyTokenBalancesForIdentitiesProof(proof.grovedbProof, tokenId, true, ids, 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 balances
-        .map((identityTokenBalance) => ({
-        identityId: new IdentifierWASM(identityTokenBalance.identityId),
-        balance: identityTokenBalance.balance
+        .map(({ id, balance }) => ({
+        identityId: new IdentifierWASM(id),
+        balance
     }));
 }

package/src/tokens/getIdentityTokensBalances.d.ts

@@ -1,8 +1,8 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-import { IdentifierLike } from '../types.js';
+import { IdentifierLike } from '../../types.js';
 import { IdentifierWASM } from 'pshenmic-dpp';
 export interface IdentityTokenBalances {
     tokenId: IdentifierWASM;
-    balance?: string | undefined;
+    balance?: bigint | undefined;
 }
 export default function getIdentityTokensBalances(grpcPool: GRPCConnectionPool, identifier: IdentifierLike, tokenIdentifiers: IdentifierLike[]): Promise<IdentityTokenBalances[]>;

package/src/tokens/getIdentityTokensBalances.js

@@ -1,8 +1,9 @@
-import { IdentifierWASM, PlatformVersionWASM, verifyTokensBalancesForIdentityProof } from 'pshenmic-dpp';
+import { IdentifierWASM, 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';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
 export default async function getIdentityTokensBalances(grpcPool, identifier, tokenIdentifiers) {
     const id = new IdentifierWASM(identifier);
     const tokenIds = tokenIdentifiers.map(tokenIdentifier => new IdentifierWASM(tokenIdentifier));
@@ -29,15 +30,15 @@ export default async function getIdentityTokensBalances(grpcPool, identifier, to
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, balances } = verifyTokensBalancesForIdentityProof(proof.grovedbProof, tokenIds, id, true, PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, balances } = verifyTokensBalancesForIdentityProof(proof.grovedbProof, tokenIds, id, 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 balances
-        .map((tokenBalance) => ({
-        tokenId: new IdentifierWASM(tokenBalance.tokenId),
-        balance: tokenBalance.balance
+        .map(({ id, balance }) => ({
+        tokenId: new IdentifierWASM(id),
+        balance
     }));
 }

package/src/tokens/getTokenContractInfo.d.ts

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

package/src/tokens/getTokenContractInfo.js

@@ -1,8 +1,9 @@
 import { GetTokenContractInfoRequest } from '../../proto/generated/platform.js';
-import { IdentifierWASM, PlatformVersionWASM, verifyTokenContractInfoProof } from 'pshenmic-dpp';
+import { IdentifierWASM, verifyTokenContractInfoProof } from 'pshenmic-dpp';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
 export default async function getTokenContractInfo(grpcPool, tokenIdentifier) {
     const tokenId = new IdentifierWASM(tokenIdentifier);
     const getTokenContractInfoRequest = GetTokenContractInfoRequest.create({
@@ -27,7 +28,7 @@ export default async function getTokenContractInfo(grpcPool, tokenIdentifier) {
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, contractInfo } = verifyTokenContractInfoProof(proof.grovedbProof, tokenId, true, PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, contractInfo } = verifyTokenContractInfoProof(proof.grovedbProof, tokenId, true, LATEST_PLATFORM_VERSION);
     if (contractInfo == null) {
         throw new Error('ContractInfo not found');
     }

package/src/tokens/getTokenDirectPurchasePrices.d.ts

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

package/src/tokens/getTokenDirectPurchasePrices.js

@@ -1,8 +1,9 @@
-import { IdentifierWASM, PlatformVersionWASM, verifyTokenDirectPurchasePrices } from 'pshenmic-dpp';
+import { IdentifierWASM, 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';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
 export default async function getTokenDirectPurchasePrices(grpcPool, tokenIdentifiers) {
     const tokenIds = tokenIdentifiers.map(tokenId => new IdentifierWASM(tokenId).bytes());
     const request = GetTokenDirectPurchasePricesRequest.create({
@@ -27,7 +28,7 @@ export default async function getTokenDirectPurchasePrices(grpcPool, tokenIdenti
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, prices } = verifyTokenDirectPurchasePrices(proof.grovedbProof, tokenIds, true, PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, prices } = verifyTokenDirectPurchasePrices(proof.grovedbProof, tokenIds, true, LATEST_PLATFORM_VERSION);
     if (prices == null) {
         throw new Error('Prices not found');
     }

package/src/tokens/getTokenTotalSupply.d.ts

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

package/src/tokens/getTokenTotalSupply.js

@@ -1,8 +1,9 @@
 import { GetTokenTotalSupplyRequest } from '../../proto/generated/platform.js';
-import { IdentifierWASM, PlatformVersionWASM, verifyTokenTotalSupplyProof } from 'pshenmic-dpp';
+import { IdentifierWASM, verifyTokenTotalSupplyProof } from 'pshenmic-dpp';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
 export default async function getTokenTotalSupply(grpcPool, tokenIdentifier) {
     const tokenId = new IdentifierWASM(tokenIdentifier);
     const getTokenTotalSupplyRequest = GetTokenTotalSupplyRequest.create({
@@ -27,7 +28,7 @@ export default async function getTokenTotalSupply(grpcPool, tokenIdentifier) {
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const { rootHash, totalBalance } = verifyTokenTotalSupplyProof(proof.grovedbProof, tokenId, true, PlatformVersionWASM.PLATFORM_V9);
+    const { rootHash, totalBalance } = verifyTokenTotalSupplyProof(proof.grovedbProof, tokenId, 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) {

package/src/tokens/index.d.ts

@@ -1,5 +1,5 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-import { IdentifierLike, TokenDirectPurchasePrices, TokenTotalSupply, TokenTransitionParams, TokenTransitionType } from '../types.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';

package/src/utils/getEvonodeList.d.ts

@@ -1,2 +1,2 @@
-import { MasternodeList, Network } from '../types.js';
+import { MasternodeList, Network } from '../../types.js';
 export default function getDAPINodeList(network: Network): Promise<MasternodeList>;

package/src/utils/index.d.ts

@@ -1,4 +1,5 @@
 import { IdentifierWASM } from 'pshenmic-dpp';
+import { IdentifierLike } from '../../types.js';
 /**
  * Collection of conversion functions
  *
@@ -62,4 +63,11 @@ export declare class UtilsController {
      * @return {string}
      * */
     createMasternodeIdentifier(proTxHash: string): IdentifierWASM;
+    /**
+     * Validates an identifier, accepts string or buffer
+     *
+     * @param identifier {IdentifierLike} identifier to test
+     * @return {boolean}
+     * */
+    validateIdentifier(identifier: IdentifierLike): boolean;
 }

package/src/utils/index.js

@@ -3,6 +3,7 @@ import { base58 } from '@scure/base';
 import hexToBytes from './hexToBytes.js';
 import bytesToHex from './bytesToHex.js';
 import { createVoterIdentityId } from './createVoterIdentityId.js';
+import { IdentifierWASM } from 'pshenmic-dpp';
 import { createMasternodeIdentityId } from './createMasternodeIdentityId.js';
 /**
  * Collection of conversion functions
@@ -81,4 +82,20 @@ export class UtilsController {
     createMasternodeIdentifier(proTxHash) {
         return createMasternodeIdentityId(proTxHash);
     }
+    /**
+     * Validates an identifier, accepts string or buffer
+     *
+     * @param identifier {IdentifierLike} identifier to test
+     * @return {boolean}
+     * */
+    validateIdentifier(identifier) {
+        try {
+            // eslint-disable-next-line
+            new IdentifierWASM(identifier);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
 }

package/src/voting/index.d.ts

@@ -1,4 +1,4 @@
-import { IdentifierLike, ResourceVoteChoice } from '../types.js';
+import { IdentifierLike, ResourceVoteChoice } from '../../types.js';
 import { IdentifierWASM, StateTransitionWASM, VoteWASM } from 'pshenmic-dpp';
 /**
  * Voting controller for performing masternode votes

package/test/unit/ContestedResources.spec.js

@@ -1,6 +1,7 @@
-import { DataContractWASM, PlatformVersionWASM, PrivateKeyWASM } from 'pshenmic-dpp';
-import { DashPlatformSDK, ContestedStateResultType } from '../../src/types.js';
+import { DataContractWASM, PrivateKeyWASM } from 'pshenmic-dpp';
+import { DashPlatformSDK, ContestedStateResultType } from '../../types.js';
 import stringToIndexValueBytes from '../../src/utils/stringToIndexValueBytes.js';
+import { LATEST_PLATFORM_VERSION } from '../../src/constants.js';
 let sdk;
 let contract;
 describe('Contested Resources', () => {
@@ -171,7 +172,7 @@ describe('Contested Resources', () => {
                 documentsMutable: false,
                 additionalProperties: false
             }
-        }, undefined, undefined, true, PlatformVersionWASM.PLATFORM_V9);
+        }, undefined, undefined, true, LATEST_PLATFORM_VERSION);
         contract.id = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
     });
     test('should be able to get contested resource vote state with finishedVoteInfo', async () => {
@@ -184,6 +185,7 @@ describe('Contested Resources', () => {
         expect(voteState.contenders.length).toBeGreaterThan(0);
         expect(voteState.abstainVoteTally).toBeDefined();
         expect(voteState.lockVoteTally).toBeDefined();
+        expect(voteState.skipped).toBeDefined();
     });
     test('should be able to get contested resource vote state for incorrect values', async () => {
         try {

package/test/unit/DataContract.spec.js

@@ -1,5 +1,5 @@
 import { DataContractWASM, StateTransitionWASM } from 'pshenmic-dpp';
-import { DashPlatformSDK } from '../../src/types.js';
+import { DashPlatformSDK } from '../../types.js';
 let sdk;
 let ownerIdentifier;
 let identityNonce;
@@ -11,7 +11,7 @@ describe('DataContract', () => {
         ownerIdentifier = 'GARSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
         identityNonce = BigInt(11);
         config = {
-            $format_version: '0',
+            $format_version: '1',
             canBeDeleted: true,
             readonly: true,
             keepsHistory: false,
@@ -19,7 +19,8 @@ describe('DataContract', () => {
             documentsMutableContractDefault: false,
             documentsCanBeDeletedContractDefault: true,
             requiresIdentityEncryptionBoundedKey: null,
-            requiresIdentityDecryptionBoundedKey: null
+            requiresIdentityDecryptionBoundedKey: null,
+            sizedIntegerTypes: true
         };
         schema = {
             note: {

package/test/unit/Document.spec.js

@@ -1,4 +1,4 @@
-import { DocumentWASM, GasFeesPaidByWASM, StateTransitionWASM } from 'pshenmic-dpp';
+import { DocumentWASM, StateTransitionWASM } from 'pshenmic-dpp';
 import { DashPlatformSDK } from '../../src/DashPlatformSDK.js';
 let sdk;
 let dataContract;
@@ -67,7 +67,7 @@ describe('Document', () => {
                 tokenContractPosition: 0,
                 minimumTokenCost: BigInt(1000),
                 maximumTokenCost: BigInt(100000),
-                gasFeesPaidBy: GasFeesPaidByWASM.ContractOwner
+                gasFeesPaidBy: 1 /* GasFeesPaidByWASM.ContractOwner */
             };
             const stateTransition = sdk.documents.createStateTransition(document, 'create', { identityContractNonce, tokenPaymentInfo });
             expect(stateTransition).toEqual(expect.any(StateTransitionWASM));

package/test/unit/Identity.spec.js

@@ -1,5 +1,6 @@
-import { IdentityPublicKeyWASM, IdentityWASM, KeyType, PrivateKeyWASM, Purpose, SecurityLevel } from 'pshenmic-dpp';
-import { DashPlatformSDK } from '../../src/types.js';
+import { CoreScriptWASM, IdentityPublicKeyWASM, IdentityWASM, PrivateKeyWASM, StateTransitionWASM } from 'pshenmic-dpp';
+import { DashPlatformSDK } from '../../types.js';
+import { base58 } from '@scure/base';
 let sdk;
 describe('Identity', () => {
     beforeAll(() => {
@@ -49,18 +50,18 @@ describe('Identity', () => {
             const privateKey1 = PrivateKeyWASM.fromHex('a1286dd195e2b8e1f6bdc946c56a53e0c544750d6452ddc0f4c593ef311f21af', 'testnet');
             const identityPublicKeyInCreation1 = {
                 id: 0,
-                purpose: Purpose.AUTHENTICATION,
-                securityLevel: SecurityLevel.MASTER,
-                keyType: KeyType.ECDSA_SECP256K1,
+                purpose: 0 /* Purpose.AUTHENTICATION */,
+                securityLevel: 0 /* SecurityLevel.MASTER */,
+                keyType: 0 /* KeyType.ECDSA_SECP256K1 */,
                 readOnly: false,
                 data: privateKey1.getPublicKey().bytes()
             };
             const privateKey2 = PrivateKeyWASM.fromHex('44a8195e242364b935e9d7ff2106ed109e9baf3800907f5e58a259fdfd1ca5e5', 'testnet');
             const identityPublicKeyInCreation2 = {
                 id: 1,
-                purpose: Purpose.AUTHENTICATION,
-                securityLevel: SecurityLevel.HIGH,
-                keyType: KeyType.ECDSA_SECP256K1,
+                purpose: 0 /* Purpose.AUTHENTICATION */,
+                securityLevel: 2 /* SecurityLevel.HIGH */,
+                keyType: 0 /* KeyType.ECDSA_SECP256K1 */,
                 readOnly: false,
                 data: privateKey2.getPublicKey().bytes()
             };
@@ -75,7 +76,7 @@ describe('Identity', () => {
                     type: 'chainLock'
                 }
             });
-            identityCreateStateTransition.signByPrivateKey(privateKey1, KeyType.ECDSA_SECP256K1);
+            identityCreateStateTransition.signByPrivateKey(privateKey1, 0 /* KeyType.ECDSA_SECP256K1 */);
             identityPublicKeyInCreation1.signature = identityCreateStateTransition.signature;
             // Set identity public key signature for public key 1
             identityCreateStateTransition = sdk.identities.createStateTransition('create', {
@@ -87,7 +88,7 @@ describe('Identity', () => {
                     type: 'chainLock'
                 }
             });
-            identityCreateStateTransition.signByPrivateKey(privateKey2, KeyType.ECDSA_SECP256K1);
+            identityCreateStateTransition.signByPrivateKey(privateKey2, 0 /* KeyType.ECDSA_SECP256K1 */);
             identityPublicKeyInCreation2.signature = identityCreateStateTransition.signature;
             // Finalize
             identityCreateStateTransition = sdk.identities.createStateTransition('create', {
@@ -99,7 +100,7 @@ describe('Identity', () => {
                     type: 'chainLock'
                 }
             });
-            identityCreateStateTransition.signByPrivateKey(assetLockPrivateKey, KeyType.ECDSA_SECP256K1);
+            identityCreateStateTransition.signByPrivateKey(assetLockPrivateKey, 0 /* KeyType.ECDSA_SECP256K1 */);
         });
         test('should be able to create IdentityCreateTransition via InstantSend', async () => {
             const assetLockPrivateKey = PrivateKeyWASM.fromHex('edd04a71bddb31e530f6c2314fd42ada333f6656bb853ece13f0577a8fd30612', 'testnet');
@@ -109,18 +110,18 @@ describe('Identity', () => {
             const privateKey1 = PrivateKeyWASM.fromHex('a1286dd195e2b8e1f6bdc946c56a53e0c544750d6452ddc0f4c593ef311f21af', 'testnet');
             const identityPublicKeyInCreation1 = {
                 id: 0,
-                purpose: Purpose.AUTHENTICATION,
-                securityLevel: SecurityLevel.MASTER,
-                keyType: KeyType.ECDSA_SECP256K1,
+                purpose: 0 /* Purpose.AUTHENTICATION */,
+                securityLevel: 0 /* SecurityLevel.MASTER */,
+                keyType: 0 /* KeyType.ECDSA_SECP256K1 */,
                 readOnly: false,
                 data: privateKey1.getPublicKey().bytes()
             };
             const privateKey2 = PrivateKeyWASM.fromHex('44a8195e242364b935e9d7ff2106ed109e9baf3800907f5e58a259fdfd1ca5e5', 'testnet');
             const identityPublicKeyInCreation2 = {
                 id: 1,
-                purpose: Purpose.AUTHENTICATION,
-                securityLevel: SecurityLevel.HIGH,
-                keyType: KeyType.ECDSA_SECP256K1,
+                purpose: 0 /* Purpose.AUTHENTICATION */,
+                securityLevel: 2 /* SecurityLevel.HIGH */,
+                keyType: 0 /* KeyType.ECDSA_SECP256K1 */,
                 readOnly: false,
                 data: privateKey2.getPublicKey().bytes()
             };
@@ -135,7 +136,7 @@ describe('Identity', () => {
                     type: 'instantLock'
                 }
             });
-            identityCreateStateTransition.signByPrivateKey(privateKey1, KeyType.ECDSA_SECP256K1);
+            identityCreateStateTransition.signByPrivateKey(privateKey1, 0 /* KeyType.ECDSA_SECP256K1 */);
             identityPublicKeyInCreation1.signature = identityCreateStateTransition.signature;
             // Set identity public key signature for public key 1
             identityCreateStateTransition = sdk.identities.createStateTransition('create', {
@@ -147,7 +148,7 @@ describe('Identity', () => {
                     type: 'instantLock'
                 }
             });
-            identityCreateStateTransition.signByPrivateKey(privateKey2, KeyType.ECDSA_SECP256K1);
+            identityCreateStateTransition.signByPrivateKey(privateKey2, 0 /* KeyType.ECDSA_SECP256K1 */);
             identityPublicKeyInCreation2.signature = identityCreateStateTransition.signature;
             // Finalize
             identityCreateStateTransition = sdk.identities.createStateTransition('create', {
@@ -159,7 +160,7 @@ describe('Identity', () => {
                     type: 'instantLock'
                 }
             });
-            identityCreateStateTransition.signByPrivateKey(assetLockPrivateKey, KeyType.ECDSA_SECP256K1);
+            identityCreateStateTransition.signByPrivateKey(assetLockPrivateKey, 0 /* KeyType.ECDSA_SECP256K1 */);
         });
         test('should be able to create IdentityTopUpTransition via InstantSend', async () => {
             const transaction = '03000800011a468e6a7cf1c5111b09b7bca6743f2571a9bf13d2ff6d21d3d230fd1dea1e97000000006b483045022100fceb25c45e77e1a273660e4f4c9a09042fb858a57704806e14bf80a734af232a02201929893dd720cf5855e31dda577cda16df29520a9774b4f3e813a4cc468fe086012103e16ede6dc5c99f28e3a5733f47a7494992bc6ce4f98551c092645910b9888b8fffffffff0200e1f50500000000026a004054fa02000000001976a91416bbe230f46eea86fc4bf4dd550be45dc9adfcb488ac0000000024010100e1f505000000001976a9147f78813975a3282e09e284d97d93c083b202e34188ac';
@@ -176,7 +177,7 @@ describe('Identity', () => {
                     type: 'instantLock'
                 }
             });
-            identityTopUpTransaction.signByPrivateKey(assetLockPrivateKey, undefined, KeyType.ECDSA_SECP256K1);
+            identityTopUpTransaction.signByPrivateKey(assetLockPrivateKey, undefined, 0 /* KeyType.ECDSA_SECP256K1 */);
         });
         test('should be able to create IdentityTopUpTransition via ChainLock', async () => {
             const txid = '61aede830477254876d435a317241ad46753c4b1350dc991a45ebcf19ab80a11';
@@ -193,7 +194,7 @@ describe('Identity', () => {
                     type: 'chainLock'
                 }
             });
-            identityTopUpTransaction.signByPrivateKey(assetLockPrivateKey, undefined, KeyType.ECDSA_SECP256K1);
+            identityTopUpTransaction.signByPrivateKey(assetLockPrivateKey, undefined, 0 /* KeyType.ECDSA_SECP256K1 */);
         });
         test('should be able to create IdentityUpdateTransition', async () => {
             const identityId = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
@@ -206,9 +207,9 @@ describe('Identity', () => {
             const identityPrivateKey = PrivateKeyWASM.fromHex('16f614c6242580628d849e3616491dda1eccce99642a85667eb9a364dc85324a', 'testnet');
             const identityPublicKeyInCreation = {
                 id: keyId,
-                purpose: Purpose.AUTHENTICATION,
-                securityLevel: SecurityLevel.HIGH,
-                keyType: KeyType.ECDSA_SECP256K1,
+                purpose: 0 /* Purpose.AUTHENTICATION */,
+                securityLevel: 2 /* SecurityLevel.HIGH */,
+                keyType: 0 /* KeyType.ECDSA_SECP256K1 */,
                 readOnly: false,
                 data: identityPrivateKey.getPublicKey().bytes()
             };
@@ -218,7 +219,7 @@ describe('Identity', () => {
                 identityNonce,
                 addPublicKeys: [identityPublicKeyInCreation]
             });
-            identityUpdateTransition.signByPrivateKey(masterPrivateKey, masterKeyId, KeyType.ECDSA_SECP256K1);
+            identityUpdateTransition.signByPrivateKey(masterPrivateKey, masterKeyId, 0 /* KeyType.ECDSA_SECP256K1 */);
             identityPublicKeyInCreation.signature = identityUpdateTransition.signature;
             identityUpdateTransition = sdk.identities.createStateTransition('update', {
                 identityId,
@@ -226,7 +227,40 @@ describe('Identity', () => {
                 identityNonce,
                 addPublicKeys: [identityPublicKeyInCreation]
             });
-            identityUpdateTransition.signByPrivateKey(masterPrivateKey, masterKeyId, KeyType.ECDSA_SECP256K1);
+            identityUpdateTransition.signByPrivateKey(masterPrivateKey, masterKeyId, 0 /* KeyType.ECDSA_SECP256K1 */);
+        });
+        test('should able be create credit transfer transition', async () => {
+            const identityId = 'QMfCRPcjXoTnZa9sA9JR2KWgGxZXMRJ4akgS3Uia1Qv';
+            const recipientId = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const amount = 100000n;
+            const identityNonce = await sdk.identities.getIdentityNonce(identityId);
+            const stateTransition = sdk.identities.createStateTransition('creditTransfer', { identityId, identityNonce, recipientId, amount });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        });
+        test('should be able create credit withdrawal', async () => {
+            const identityId = 'QMfCRPcjXoTnZa9sA9JR2KWgGxZXMRJ4akgS3Uia1Qv';
+            const amount = 100000n;
+            const identityNonce = await sdk.identities.getIdentityNonce(identityId);
+            const withdrawalAddress = 'yjHVQ3dj37UJwXFmvMTKR9ZVfoJSc3opTD';
+            const stateTransition = sdk.identities.createStateTransition('withdrawal', { identityId, identityNonce, amount, withdrawalAddress });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        });
+        test('should be able create credit withdrawal with custom CoreScript', async () => {
+            const identityId = 'QMfCRPcjXoTnZa9sA9JR2KWgGxZXMRJ4akgS3Uia1Qv';
+            const amount = 100000n;
+            const identityNonce = await sdk.identities.getIdentityNonce(identityId);
+            const withdrawalAddress = 'yjHVQ3dj37UJwXFmvMTKR9ZVfoJSc3opTD';
+            const outputScript = CoreScriptWASM.newP2PKH(base58.decode(withdrawalAddress).slice(1, 21));
+            const stateTransition = sdk.identities.createStateTransition('withdrawal', { identityId, identityNonce, amount, outputScript });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        });
+        test('should be able create credit withdrawal with no withdrawal address', async () => {
+            const identityId = 'QMfCRPcjXoTnZa9sA9JR2KWgGxZXMRJ4akgS3Uia1Qv';
+            const recipientId = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const amount = 100000n;
+            const identityNonce = await sdk.identities.getIdentityNonce(identityId);
+            const stateTransition = sdk.identities.createStateTransition('creditTransfer', { identityId, recipientId, amount, identityNonce });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
         });
     });
 });

package/test/unit/Names.spec.js

@@ -2,6 +2,7 @@ import broadcast from '../../src/stateTransitions/broadcast.js';
 import { DocumentWASM, PrivateKeyWASM } from 'pshenmic-dpp';
 import { DashPlatformSDK } from '../../src/DashPlatformSDK.js';
 import sleep from '../../src/utils/sleep.js';
+jest.mock('../../src/stateTransitions/waitForStateTransitionResult');
 jest.mock('../../src/stateTransitions/broadcast');
 jest.mock('../../src/utils/sleep');
 let sdk;
@@ -11,6 +12,7 @@ describe('DPNS names', () => {
         // @ts-expect-error
         sleep.mockReturnValue(Promise.resolve());
         sdk.stateTransitions.broadcast = jest.fn();
+        sdk.stateTransitions.waitForStateTransitionResult = jest.fn();
     });
     test('should be able to search names by DPNS name', async () => {
         const documents = await sdk.names.searchByName('xyz.dash');

package/test/unit/Tokens.spec.js

@@ -1,4 +1,4 @@
-import { StateTransitionWASM, TokenBaseTransitionWASM, TokenEmergencyActionWASM } from 'pshenmic-dpp';
+import { StateTransitionWASM, TokenBaseTransitionWASM } from 'pshenmic-dpp';
 import { DashPlatformSDK } from '../../src/DashPlatformSDK.js';
 let sdk;
 describe('Tokens', () => {
@@ -29,7 +29,7 @@ describe('Tokens', () => {
         ]);
         expect(tokensPrices.length).toEqual(2);
         expect(tokensPrices[0].tokenId).toBeTruthy();
-        expect(tokensPrices[0].price).toBeTruthy();
+        expect(tokensPrices[0].pricingSchedule).toBeTruthy();
     });
     test('should be able to get tokens direct purchase prices', async () => {
         const tokensIdentityBalance = await sdk.tokens.getIdentitiesTokenBalances(['8eTDkBhpQjHeqgbVeriwLeZr1tCa6yBGw76SckvD1cwc'], '9YxdbQUjJmQsmVPen95HjAU3Esj7tVkWSY2EQWT84ZQP');
@@ -95,7 +95,7 @@ describe('Tokens', () => {
         test('should be able to create emergency action transition', async () => {
             const tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
             const owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
-            const emergencyAction = TokenEmergencyActionWASM.Pause;
+            const emergencyAction = 0 /* TokenEmergencyActionWASM.Pause */;
             const tokenBaseTransition = await sdk.tokens.createBaseTransition(tokenId, owner);
             const stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'emergencyAction', { emergencyAction });
             expect(stateTransition).toBeInstanceOf(StateTransitionWASM);

package/{src/types.d.ts → types.d.ts}

@@ -1,10 +1,9 @@
-import { DocumentWASM, GasFeesPaidByWASM, IdentifierWASM, KeyType, Purpose, SecurityLevel, TokenEmergencyActionWASM, TokenPricingScheduleWASM } from 'pshenmic-dpp';
-export { IdentifierWASM, IdentityWASM, DocumentWASM, DataContractWASM, StateTransitionWASM, IdentityPublicKeyWASM } from 'pshenmic-dpp';
+import { CoreScriptWASM, DocumentWASM, GasFeesPaidByWASM, IdentifierWASM, KeyType, Purpose, SecurityLevel, TokenEmergencyActionWASM, TokenPricingScheduleWASM } from 'pshenmic-dpp';
+export { CoreScriptWASM, DocumentWASM, GasFeesPaidByWASM, IdentifierWASM, KeyType, Purpose, SecurityLevel, TokenEmergencyActionWASM, TokenPricingScheduleWASM, StateTransitionWASM, BatchTransitionWASM, IdentityPublicKeyWASM, PrivateKeyWASM, DataContractUpdateTransitionWASM, IdentityWASM, IdentityUpdateTransitionWASM, IdentityCreditTransferWASM, MasternodeVoteTransitionWASM } from 'pshenmic-dpp';
 export type IdentifierLike = IdentifierWASM | string | Uint8Array;
 export type Network = 'mainnet' | 'testnet';
-export { DashPlatformSDK } from './DashPlatformSDK.js';
+export { DashPlatformSDK } from './src/DashPlatformSDK.js';
 export type MasternodeList = Record<string, MasternodeInfo>;
-export { AbstractSigner } from './signer/AbstractSigner.js';
 export interface DocumentTransitionParams {
     identityContractNonce: bigint;
     amount?: bigint;
@@ -114,15 +113,16 @@ export interface Contender {
 export interface FinishedVoteInfo {
     type: string;
     wonByIdentityId?: IdentifierWASM | undefined;
-    finishedAtBlockHeight: string;
+    finishedAtBlockHeight: bigint;
     finishedAtCoreBlockHeight: number;
-    finishedAtBlockTimeMs: string;
-    finishedAtEpoch: number;
+    finishedAtBlockTimeMs: bigint;
+    finishedAtEpoch?: number;
 }
 export interface ContestedResourceVoteState {
     contenders: Contender[];
     abstainVoteTally?: number | undefined;
     lockVoteTally?: number | undefined;
+    skipped: boolean;
     finishedVoteInfo?: FinishedVoteInfo;
 }
 export interface DataContractConfig {
@@ -135,6 +135,7 @@ export interface DataContractConfig {
     documentsCanBeDeletedContractDefault: boolean;
     requiresIdentityEncryptionBoundedKey?: number | null;
     requiresIdentityDecryptionBoundedKey?: number | null;
+    sizedIntegerTypes: boolean;
 }
 export type TokenTransitionType = 'burn' | 'mint' | 'transfer' | 'freeze' | 'unfreeze' | 'destroyFrozenFunds' | 'emergencyAction' | 'directPurchase' | 'setPriceForDirectPurchase';
 export interface TokenTransitionParams {
@@ -186,7 +187,13 @@ export interface IdentityTransitionParams {
     disablePublicKeyIds?: number[];
     revision?: bigint;
     identityNonce?: bigint;
+    amount?: bigint;
     identityId?: IdentifierLike;
+    recipientId?: IdentifierLike;
+    withdrawalAddress?: string;
+    outputScript?: CoreScriptWASM;
+    pooling?: 'Standard' | 'Never' | 'IfAvailable';
+    coreFeePerByte?: number;
     userFeeIncrease?: number;
 }
 export interface TokenTotalSupply {
@@ -196,6 +203,6 @@ export interface TokenTotalSupply {
 }
 export interface TokenDirectPurchasePrices {
     tokenId: IdentifierWASM;
-    price: TokenPricingScheduleWASM;
+    pricingSchedule?: TokenPricingScheduleWASM | undefined;
 }
 export type ResourceVoteChoice = IdentifierLike | 'lock' | 'abstain';

package/{src/types.js → types.js}

@@ -1,5 +1,5 @@
-export { IdentifierWASM, IdentityWASM, DocumentWASM, DataContractWASM, StateTransitionWASM, IdentityPublicKeyWASM } from 'pshenmic-dpp';
-export { DashPlatformSDK } from './DashPlatformSDK.js';
+export { CoreScriptWASM, DocumentWASM, IdentifierWASM, TokenPricingScheduleWASM, StateTransitionWASM, BatchTransitionWASM, IdentityPublicKeyWASM, PrivateKeyWASM, DataContractUpdateTransitionWASM, IdentityWASM, IdentityUpdateTransitionWASM, IdentityCreditTransferWASM, MasternodeVoteTransitionWASM } from 'pshenmic-dpp';
+export { DashPlatformSDK } from './src/DashPlatformSDK.js';
 export var ContestedStateResultType;
 (function (ContestedStateResultType) {
     ContestedStateResultType[ContestedStateResultType["DOCUMENTS"] = 0] = "DOCUMENTS";