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

package/test/unit/Identity.spec.js

@@ -0,0 +1,232 @@
+import { IdentityPublicKeyWASM, IdentityWASM, KeyType, PrivateKeyWASM, Purpose, SecurityLevel } from 'pshenmic-dpp';
+import { DashPlatformSDK } from '../../src/types';
+let sdk;
+describe('Identity', () => {
+    beforeAll(() => {
+        sdk = new DashPlatformSDK({ network: 'testnet' });
+    });
+    test('should be able to get identity by identifier', async () => {
+        const identifier = 'QMfCRPcjXoTnZa9sA9JR2KWgGxZXMRJ4akgS3Uia1Qv';
+        const identity = await sdk.identities.getIdentityByIdentifier(identifier);
+        expect(identity).toEqual(expect.any(IdentityWASM));
+    });
+    test('should be able to get identity by public key hash', async () => {
+        const publicKeyHash = 'c1b95d254c405a3d9d82ef88a47f9f792ac8efd7';
+        const identity = await sdk.identities.getIdentityByPublicKeyHash(publicKeyHash);
+        expect(identity).toEqual(expect.any(IdentityWASM));
+    });
+    test('should be able to get identity by non unique public key hash', async () => {
+        const identity = await sdk.identities.getIdentityByNonUniquePublicKeyHash('8b30a2cda275d1110874c0380b8447db3a9b04ee');
+        expect(identity).toEqual(expect.any(IdentityWASM));
+    });
+    test('should be able to get identity contract nonce', async () => {
+        const identifier = 'QMfCRPcjXoTnZa9sA9JR2KWgGxZXMRJ4akgS3Uia1Qv';
+        const dataContract = 'DrEhmVJz56ukHbaFt8xLVRasnNWsrx3x8dGtcu9xg6rV';
+        const identityContractNonce = await sdk.identities.getIdentityContractNonce(identifier, dataContract);
+        expect(identityContractNonce).toEqual(expect.any(BigInt));
+    });
+    test('should be able to get identity nonce', async () => {
+        const identifier = '34vkjdeUTP2z798SiXqoB6EAuobh51kXYURqVa9xkujf';
+        const identityNonce = await sdk.identities.getIdentityNonce(identifier);
+        expect(identityNonce).toEqual(expect.any(BigInt));
+    });
+    test('should be able to get identity public keys', async () => {
+        const identifier = 'QMfCRPcjXoTnZa9sA9JR2KWgGxZXMRJ4akgS3Uia1Qv';
+        const identityPublicKeys = await sdk.identities.getIdentityPublicKeys(identifier);
+        expect(identityPublicKeys.every(identityPublicKey => identityPublicKey instanceof IdentityPublicKeyWASM)).toBeTruthy();
+    });
+    test('should be able to get balance', async () => {
+        const identifier = 'QMfCRPcjXoTnZa9sA9JR2KWgGxZXMRJ4akgS3Uia1Qv';
+        const balance = await sdk.identities.getIdentityBalance(identifier);
+        expect(balance).toEqual(expect.any(BigInt));
+    });
+    describe('createStateTransition', () => {
+        test('should be able to create IdentityCreateTransition via ChainLock', async () => {
+            const assetLockPrivateKey = PrivateKeyWASM.fromHex('edd04a71bddb31e530f6c2314fd42ada333f6656bb853ece13f0577a8fd30612', 'testnet');
+            const txid = '61aede830477254876d435a317241ad46753c4b1350dc991a45ebcf19ab80a11';
+            const outputIndex = 0;
+            const coreChainLockedHeight = 1337;
+            const privateKey1 = PrivateKeyWASM.fromHex('a1286dd195e2b8e1f6bdc946c56a53e0c544750d6452ddc0f4c593ef311f21af', 'testnet');
+            const identityPublicKeyInCreation1 = {
+                id: 0,
+                purpose: Purpose.AUTHENTICATION,
+                securityLevel: SecurityLevel.MASTER,
+                keyType: 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,
+                readOnly: false,
+                data: privateKey2.getPublicKey().bytes()
+            };
+            let identityCreateStateTransition;
+            // Set identity public key signature for public key 0
+            identityCreateStateTransition = sdk.identities.createStateTransition('create', {
+                publicKeys: [identityPublicKeyInCreation1, identityPublicKeyInCreation2],
+                assetLockProof: {
+                    txid,
+                    outputIndex,
+                    coreChainLockedHeight,
+                    type: 'chainLock'
+                }
+            });
+            identityCreateStateTransition.signByPrivateKey(privateKey1, KeyType.ECDSA_SECP256K1);
+            identityPublicKeyInCreation1.signature = identityCreateStateTransition.signature;
+            // Set identity public key signature for public key 1
+            identityCreateStateTransition = sdk.identities.createStateTransition('create', {
+                publicKeys: [identityPublicKeyInCreation1, identityPublicKeyInCreation2],
+                assetLockProof: {
+                    txid,
+                    outputIndex,
+                    coreChainLockedHeight,
+                    type: 'chainLock'
+                }
+            });
+            identityCreateStateTransition.signByPrivateKey(privateKey2, KeyType.ECDSA_SECP256K1);
+            identityPublicKeyInCreation2.signature = identityCreateStateTransition.signature;
+            // Finalize
+            identityCreateStateTransition = sdk.identities.createStateTransition('create', {
+                publicKeys: [identityPublicKeyInCreation1, identityPublicKeyInCreation2],
+                assetLockProof: {
+                    txid,
+                    outputIndex,
+                    coreChainLockedHeight,
+                    type: 'chainLock'
+                }
+            });
+            identityCreateStateTransition.signByPrivateKey(assetLockPrivateKey, KeyType.ECDSA_SECP256K1);
+        });
+        test('should be able to create IdentityCreateTransition via InstantSend', async () => {
+            const assetLockPrivateKey = PrivateKeyWASM.fromHex('edd04a71bddb31e530f6c2314fd42ada333f6656bb853ece13f0577a8fd30612', 'testnet');
+            const transaction = '03000800017dada5379e34ae1b59df35ba7acb879f3afaa12fa522f4b289a34d9fa2a68825010000006b48304502210093d609f65219e0d7ee694d271c4b7460ce89d298ef3e3670d5aef957e5551ead0220085d252e16cb3aae0d4e5d371e359e844fe82db93d8e4e26b5c61dc94676b7df0121037b86a1f7a11b4cc69fc7052e5cabdc625f3db47ee283ed4b87108f2cd879521effffffff0200e1f50500000000026a004054fa02000000001976a91416bbe230f46eea86fc4bf4dd550be45dc9adfcb488ac0000000024010100e1f505000000001976a914883bccdb8bfa44e55a19a1120ff2427537f7e92488ac';
+            const instantLock = '01017dada5379e34ae1b59df35ba7acb879f3afaa12fa522f4b289a34d9fa2a688250100000060afc1323120f0a3b835dd113b3221e92dea56814369925f10dd3e8f6bcfaa6aa89ed4282521863d8eb72e7e0e7d80c86ca64cce9986ae8bb63657f43f0000009179b5d130fe69bd0f2ea7bc90e9ea904a7eeea515a2612045a70925a7c678b0b09499ea307575751e22f804c443d2e1105e1fd4e30aa894324a41cd983ffe58d5312ff8db11676bd530c6ab8af1f7d2980d356dd3c86d0386da7df70aa3a66b';
+            const outputIndex = 0;
+            const privateKey1 = PrivateKeyWASM.fromHex('a1286dd195e2b8e1f6bdc946c56a53e0c544750d6452ddc0f4c593ef311f21af', 'testnet');
+            const identityPublicKeyInCreation1 = {
+                id: 0,
+                purpose: Purpose.AUTHENTICATION,
+                securityLevel: SecurityLevel.MASTER,
+                keyType: 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,
+                readOnly: false,
+                data: privateKey2.getPublicKey().bytes()
+            };
+            let identityCreateStateTransition;
+            // Set identity public key signature for public key 0
+            identityCreateStateTransition = sdk.identities.createStateTransition('create', {
+                publicKeys: [identityPublicKeyInCreation1, identityPublicKeyInCreation2],
+                assetLockProof: {
+                    transaction,
+                    instantLock,
+                    outputIndex,
+                    type: 'instantLock'
+                }
+            });
+            identityCreateStateTransition.signByPrivateKey(privateKey1, KeyType.ECDSA_SECP256K1);
+            identityPublicKeyInCreation1.signature = identityCreateStateTransition.signature;
+            // Set identity public key signature for public key 1
+            identityCreateStateTransition = sdk.identities.createStateTransition('create', {
+                publicKeys: [identityPublicKeyInCreation1, identityPublicKeyInCreation2],
+                assetLockProof: {
+                    transaction,
+                    instantLock,
+                    outputIndex,
+                    type: 'instantLock'
+                }
+            });
+            identityCreateStateTransition.signByPrivateKey(privateKey2, KeyType.ECDSA_SECP256K1);
+            identityPublicKeyInCreation2.signature = identityCreateStateTransition.signature;
+            // Finalize
+            identityCreateStateTransition = sdk.identities.createStateTransition('create', {
+                publicKeys: [identityPublicKeyInCreation1, identityPublicKeyInCreation2],
+                assetLockProof: {
+                    transaction,
+                    instantLock,
+                    outputIndex,
+                    type: 'instantLock'
+                }
+            });
+            identityCreateStateTransition.signByPrivateKey(assetLockPrivateKey, KeyType.ECDSA_SECP256K1);
+        });
+        test('should be able to create IdentityTopUpTransition via InstantSend', async () => {
+            const transaction = '03000800011a468e6a7cf1c5111b09b7bca6743f2571a9bf13d2ff6d21d3d230fd1dea1e97000000006b483045022100fceb25c45e77e1a273660e4f4c9a09042fb858a57704806e14bf80a734af232a02201929893dd720cf5855e31dda577cda16df29520a9774b4f3e813a4cc468fe086012103e16ede6dc5c99f28e3a5733f47a7494992bc6ce4f98551c092645910b9888b8fffffffff0200e1f50500000000026a004054fa02000000001976a91416bbe230f46eea86fc4bf4dd550be45dc9adfcb488ac0000000024010100e1f505000000001976a9147f78813975a3282e09e284d97d93c083b202e34188ac';
+            const instantLock = '01011a468e6a7cf1c5111b09b7bca6743f2571a9bf13d2ff6d21d3d230fd1dea1e9700000000892304531821bcddfe960388f93e6e91bbae170987a5c6db33f0a4cf2d88ef148968a159512600791f94053e30f688aac43bf6e698fd78339a9ab5fd3b00000091ee77cadbf9683ca3d1fb1abcb2f561f0c745b26099fe5294885852a03a4f26770a3d437265f5f00ae21d0f681d0e1610a7ac47b6d463c3efdc5f7f922e310e6f3cd66c319e63e4f1c2cc70e97886e15485dba4f29b836bf55f0619837437e8';
+            const outputIndex = 0;
+            const assetLockPrivateKey = PrivateKeyWASM.fromHex('3ca33236ab14f6df6cf87fcbb0551544fee7dcf4f251557af02c175725764a5a', 'testnet');
+            const identityId = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const identityTopUpTransaction = sdk.identities.createStateTransition('topUp', {
+                identityId,
+                assetLockProof: {
+                    transaction,
+                    instantLock,
+                    outputIndex,
+                    type: 'instantLock'
+                }
+            });
+            identityTopUpTransaction.signByPrivateKey(assetLockPrivateKey, undefined, KeyType.ECDSA_SECP256K1);
+        });
+        test('should be able to create IdentityTopUpTransition via ChainLock', async () => {
+            const txid = '61aede830477254876d435a317241ad46753c4b1350dc991a45ebcf19ab80a11';
+            const outputIndex = 0;
+            const coreChainLockedHeight = 1337;
+            const assetLockPrivateKey = PrivateKeyWASM.fromHex('3ca33236ab14f6df6cf87fcbb0551544fee7dcf4f251557af02c175725764a5a', 'testnet');
+            const identityId = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const identityTopUpTransaction = sdk.identities.createStateTransition('topUp', {
+                identityId,
+                assetLockProof: {
+                    txid,
+                    outputIndex,
+                    coreChainLockedHeight,
+                    type: 'chainLock'
+                }
+            });
+            identityTopUpTransaction.signByPrivateKey(assetLockPrivateKey, undefined, KeyType.ECDSA_SECP256K1);
+        });
+        test('should be able to create IdentityUpdateTransition', async () => {
+            const identityId = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const masterPrivateKey = PrivateKeyWASM.fromHex('16f614c6242580628d849e3616491dda1eccce99642a85667eb9a364dc85324a', 'testnet');
+            const masterKeyId = 0;
+            const identity = await sdk.identities.getIdentityByIdentifier(identityId);
+            const revision = identity.revision + BigInt(1);
+            const identityNonce = await sdk.identities.getIdentityNonce(identityId) + BigInt(1);
+            const keyId = identity.getPublicKeys()[identity.getPublicKeys().length - 1].keyId + 1;
+            const identityPrivateKey = PrivateKeyWASM.fromHex('16f614c6242580628d849e3616491dda1eccce99642a85667eb9a364dc85324a', 'testnet');
+            const identityPublicKeyInCreation = {
+                id: keyId,
+                purpose: Purpose.AUTHENTICATION,
+                securityLevel: SecurityLevel.HIGH,
+                keyType: KeyType.ECDSA_SECP256K1,
+                readOnly: false,
+                data: identityPrivateKey.getPublicKey().bytes()
+            };
+            let identityUpdateTransition = sdk.identities.createStateTransition('update', {
+                identityId,
+                revision,
+                identityNonce,
+                addPublicKeys: [identityPublicKeyInCreation]
+            });
+            identityUpdateTransition.signByPrivateKey(masterPrivateKey, masterKeyId, KeyType.ECDSA_SECP256K1);
+            identityPublicKeyInCreation.signature = identityUpdateTransition.signature;
+            identityUpdateTransition = sdk.identities.createStateTransition('update', {
+                identityId,
+                revision,
+                identityNonce,
+                addPublicKeys: [identityPublicKeyInCreation]
+            });
+            identityUpdateTransition.signByPrivateKey(masterPrivateKey, masterKeyId, KeyType.ECDSA_SECP256K1);
+        });
+    });
+});

package/test/unit/KeyPair.spec.js

@@ -0,0 +1,34 @@
+import { DashPlatformSDK } from '../../src/DashPlatformSDK';
+let sdk;
+let mnemonic;
+describe('KeyPair', () => {
+    beforeAll(() => {
+        sdk = new DashPlatformSDK({ network: 'testnet' });
+        mnemonic = 'deliver frame tomato ring tool second dream mutual fade sponsor visa teach';
+    });
+    describe('mnemonic', () => {
+        test('should be able to get seed from mnemonic', async () => {
+            const seed = sdk.keyPair.mnemonicToSeed(mnemonic);
+            // TODO: Get mock data from sdk
+            expect(seed).toEqual(Uint8Array.from([170, 120, 192, 223, 47, 43, 142, 250, 243, 136, 44, 236, 84, 170, 156, 154, 126, 231, 185, 130, 242, 40, 134, 27, 36, 33, 187, 102, 29, 177, 119, 141, 61, 157, 81, 35, 85, 33, 43, 28, 108, 24, 108, 159, 119, 233, 104, 100, 2, 206, 18, 245, 142, 99, 19, 143, 141, 0, 207, 31, 143, 58, 245, 107]));
+        });
+        test('should be able to derive hd wallet from seed', async () => {
+            const seed = sdk.keyPair.mnemonicToSeed(mnemonic);
+            const hdKey = sdk.keyPair.seedToHdKey(seed);
+            expect(hdKey.privateKey).toEqual(new Uint8Array([105, 213, 35, 36, 214, 9, 104, 32, 148, 57, 157, 10, 134, 251, 79, 152, 252, 58, 194, 48, 145, 102, 7, 252, 191, 69, 164, 97, 195, 136, 182, 93]));
+        });
+        test('should be able to derive address from wallet via derive path', async () => {
+            const seed = sdk.keyPair.mnemonicToSeed(mnemonic);
+            const seedHdKey = sdk.keyPair.seedToHdKey(seed, 'testnet');
+            const derivedHdKey = await sdk.keyPair.derivePath(seedHdKey, "m/44'/1'/0'/0/0");
+            const address = sdk.keyPair.p2pkhAddress(derivedHdKey.publicKey, 'testnet');
+            expect(address).toEqual('yRGEqFgmuqJct4jzH48sFrvBCc3WuPKDTp');
+        });
+        test('should be able to derive identity hd key from wallet', async () => {
+            const seed = sdk.keyPair.mnemonicToSeed(mnemonic);
+            const seedHdKey = sdk.keyPair.seedToHdKey(seed);
+            const key = sdk.keyPair.deriveIdentityPrivateKey(seedHdKey, 0, 0, 'testnet');
+            expect(key.privateKey).toEqual(Uint8Array.from([89, 255, 64, 41, 202, 170, 83, 68, 135, 58, 161, 107, 130, 20, 3, 50, 69, 16, 108, 104, 32, 68, 13, 100, 225, 24, 79, 20, 193, 184, 238, 55]));
+        });
+    });
+});

package/test/unit/Names.spec.js

@@ -0,0 +1,33 @@
+import broadcast from '../../src/stateTransitions/broadcast';
+import { DocumentWASM, PrivateKeyWASM } from 'pshenmic-dpp';
+import { DashPlatformSDK } from '../../src/DashPlatformSDK';
+import sleep from '../../src/utils/sleep';
+jest.mock('../../src/stateTransitions/broadcast');
+jest.mock('../../src/utils/sleep');
+let sdk;
+describe('DPNS names', () => {
+    beforeAll(() => {
+        sdk = new DashPlatformSDK({ network: 'testnet' });
+        // @ts-expect-error
+        sleep.mockReturnValue(Promise.resolve());
+        sdk.stateTransitions.broadcast = jest.fn();
+    });
+    test('should be able to search names by DPNS name', async () => {
+        const documents = await sdk.names.searchByName('xyz.dash');
+        expect(documents?.length).toEqual(1);
+        expect(documents[0]).toEqual(expect.any(DocumentWASM));
+    });
+    test('should be able to search names by identity', async () => {
+        const documents = await sdk.names.searchByIdentity('36LGwPSXef8q8wpdnx4EdDeVNuqCYNAE9boDu5bxytsm');
+        expect(documents?.length).toEqual(3);
+        const [xyzDocument] = documents;
+        expect(xyzDocument.ownerId.base58()).toEqual('36LGwPSXef8q8wpdnx4EdDeVNuqCYNAE9boDu5bxytsm');
+    });
+    test('should be able to register a name', async () => {
+        const fullName = 'test-identity-050.dash';
+        const identityId = 'CKKYnVeKoxCbvuEhiT6MDoQaRyXgDECwtxoKL5cqucZE';
+        const privateKey = PrivateKeyWASM.fromWIF('XERm528aQWJ3hzEcb79KMQKewbSSJQtni3fWHbu75wDxg6xg6AA3');
+        await sdk.names.registerName(fullName, identityId, privateKey);
+        expect(broadcast).toHaveBeenCalledTimes(2);
+    });
+});

package/test/unit/Node.spec.js

@@ -0,0 +1,58 @@
+import { DashPlatformSDK } from '../../src/DashPlatformSDK';
+let sdk;
+describe('Node', () => {
+    beforeAll(() => {
+        sdk = new DashPlatformSDK({ network: 'testnet' });
+    });
+    test('should be able to call getStatus', async () => {
+        const status = await sdk.node.status();
+        expect(status.version?.software?.dapi).toEqual(expect.any(String));
+        expect(status.version?.software?.drive).toEqual(expect.any(String));
+        expect(status.version?.software?.tenderdash).toEqual(expect.any(String));
+        expect(status.version?.protocol?.tenderdash?.p2P).toEqual(expect.any(Number));
+        expect(status.version?.protocol?.tenderdash?.block).toEqual(expect.any(Number));
+        expect(status.version?.protocol?.drive?.latest).toEqual(expect.any(Number));
+        expect(status.version?.protocol?.drive?.current).toEqual(expect.any(Number));
+        expect(status.node?.id).toEqual(expect.any(String));
+        expect(status.chain?.catchingUp).toEqual(expect.any(Boolean));
+        expect(status.chain?.latestBlockHash).toEqual(expect.any(String));
+        expect(status.chain?.latestAppHash).toEqual(expect.any(String));
+        expect(status.chain?.latestBlockHeight).toEqual(expect.any(String));
+        expect(status.chain?.earliestBlockHash).toEqual(expect.any(String));
+        expect(status.chain?.earliestAppHash).toEqual(expect.any(String));
+        expect(status.chain?.earliestBlockHeight).toEqual(expect.any(String));
+        expect(status.chain?.maxPeerBlockHeight).toEqual(expect.any(String));
+        expect(status.chain?.coreChainLockedHeight).toEqual(expect.any(Number));
+        expect(status.network?.chainId).toEqual(expect.any(String));
+        expect(status.network?.peersCount).toEqual(expect.any(Number));
+        expect(status.network?.listening).toEqual(expect.any(Boolean));
+        expect(status.stateSync?.totalSyncedTime).toEqual(expect.any(String));
+        expect(status.stateSync?.remainingTime).toEqual(expect.any(String));
+        expect(status.stateSync?.totalSnapshots).toEqual(expect.any(Number));
+        expect(status.stateSync?.chunkProcessAvgTime).toEqual(expect.any(String));
+        expect(status.stateSync?.snapshotHeight).toEqual(expect.any(String));
+        expect(status.stateSync?.snapshotChunksCount).toEqual(expect.any(String));
+        expect(status.stateSync?.backfilledBlocks).toEqual(expect.any(String));
+        expect(status.stateSync?.backfillBlocksTotal).toEqual(expect.any(String));
+        expect(status.time?.local).toEqual(expect.any(String));
+        expect(status.time?.block).toEqual(expect.any(String));
+        expect(status.time?.genesis).toEqual(expect.any(String));
+        expect(status.time?.epoch).toEqual(expect.any(Number));
+    });
+    test('should be able to call getEpochsInfo in desc', async () => {
+        const epochsInfo = await sdk.node.getEpochsInfo(10, false, 8607);
+        const expectedEpochsNumbers = Array.from({ length: 10 }, (_val, index) => 8598 + index);
+        expect(epochsInfo.length).toEqual(10);
+        expect(epochsInfo.map(epochInfo => epochInfo.number)).toEqual(expectedEpochsNumbers);
+    });
+    test('should be able to call getEpochsInfo in asc', async () => {
+        const epochsInfo = await sdk.node.getEpochsInfo(10, true, 8596);
+        const expectedEpochsNumbers = Array.from({ length: 10 }, (_val, index) => 8596 + index);
+        expect(epochsInfo.length).toEqual(10);
+        expect(epochsInfo.map(epochInfo => epochInfo.number)).toEqual(expectedEpochsNumbers);
+    });
+    test('should be able to call getTotalCreditsInPlatform', async () => {
+        const totalCredits = await sdk.node.totalCredits();
+        expect(Number(totalCredits)).toBeGreaterThan(0);
+    });
+});

package/test/unit/SDK.spec.js

@@ -0,0 +1,10 @@
+import { DashPlatformSDK } from '../../src/DashPlatformSDK';
+let sdk;
+describe('DashPlatformSDK', () => {
+    beforeAll(() => {
+        sdk = new DashPlatformSDK({ network: 'testnet' });
+    });
+    test('should be constructable throw `new`', () => {
+        expect(sdk).toEqual(expect.any(DashPlatformSDK));
+    });
+});

package/test/unit/Tokens.spec.js

@@ -0,0 +1,121 @@
+import { StateTransitionWASM, TokenBaseTransitionWASM, TokenEmergencyActionWASM } from 'pshenmic-dpp';
+import { DashPlatformSDK } from '../../src/DashPlatformSDK';
+let sdk;
+describe('Tokens', () => {
+    beforeAll(() => {
+        sdk = new DashPlatformSDK({ network: 'testnet' });
+    });
+    test('should be able to get token total supply', async () => {
+        const tokenTotalSupply = await sdk.tokens.getTokenTotalSupply('9YxdbQUjJmQsmVPen95HjAU3Esj7tVkWSY2EQWT84ZQP');
+        expect(tokenTotalSupply.tokenId).toBeTruthy();
+        expect(tokenTotalSupply.totalSystemAmount).toBeTruthy();
+        expect(tokenTotalSupply.totalAggregatedAmountInUserAccounts).toBeTruthy();
+    });
+    test('should be able to get token contract info', async () => {
+        const tokenContractInfo = await sdk.tokens.getTokenContractInfo('9YxdbQUjJmQsmVPen95HjAU3Esj7tVkWSY2EQWT84ZQP');
+        expect(tokenContractInfo.dataContractId.base58()).toEqual('Y189uedQG3CJCuu83P3DqnG7ngQaRKz69x3gY8uDzQe');
+        expect(tokenContractInfo.tokenContractPosition).toEqual(0);
+    });
+    test('should be able to get identity tokens balances', async () => {
+        const tokensIdentityBalance = await sdk.tokens.getIdentityTokensBalances('8eTDkBhpQjHeqgbVeriwLeZr1tCa6yBGw76SckvD1cwc', ['9YxdbQUjJmQsmVPen95HjAU3Esj7tVkWSY2EQWT84ZQP']);
+        expect(tokensIdentityBalance.length).toEqual(1);
+        expect(tokensIdentityBalance[0].tokenId).toBeTruthy();
+        expect(tokensIdentityBalance[0].balance).toBeTruthy();
+    });
+    test('should be able to get token identities token balances', async () => {
+        const tokensPrices = await sdk.tokens.getTokensDirectPurchasePrice([
+            '3oTHkj8nqn82QkZRHkmUmNBX696nzE1rg1fwPRpemEdz',
+            '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C'
+        ]);
+        expect(tokensPrices.length).toEqual(2);
+        expect(tokensPrices[0].tokenId).toBeTruthy();
+        expect(tokensPrices[0].price).toBeTruthy();
+    });
+    test('should be able to get tokens direct purchase prices', async () => {
+        const tokensIdentityBalance = await sdk.tokens.getIdentitiesTokenBalances(['8eTDkBhpQjHeqgbVeriwLeZr1tCa6yBGw76SckvD1cwc'], '9YxdbQUjJmQsmVPen95HjAU3Esj7tVkWSY2EQWT84ZQP');
+        expect(tokensIdentityBalance.length).toEqual(1);
+        expect(tokensIdentityBalance[0].identityId).toBeTruthy();
+        expect(tokensIdentityBalance[0].balance).toBeTruthy();
+    });
+    test('should be able to create base token transition', async () => {
+        const tokenBaseTransition = await sdk.tokens.createBaseTransition('A36eJF2kyYXwxCtJGsgbR3CTAscUFaNxZN19UqUfM1kw', '34vkjdeUTP2z798SiXqoB6EAuobh51kXYURqVa9xkujf');
+        expect(tokenBaseTransition).toBeInstanceOf(TokenBaseTransitionWASM);
+    });
+    describe('create state transitions', () => {
+        test('should be able to create burn transition', async () => {
+            const tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+            const owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const amount = BigInt(10);
+            const tokenBaseTransition = await sdk.tokens.createBaseTransition(tokenId, owner);
+            const stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'burn', { amount });
+            expect(stateTransition).toBeInstanceOf(StateTransitionWASM);
+        });
+        test('should be able to create mint transition', async () => {
+            const tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+            const owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const recipientId = '8GopLQQCViyroS2gHktesGaCMe2tueXWeQ6Y9vpMFTEC';
+            const amount = BigInt(10);
+            const tokenBaseTransition = await sdk.tokens.createBaseTransition(tokenId, owner);
+            const stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'mint', { identityId: recipientId, amount });
+            expect(stateTransition).toBeInstanceOf(StateTransitionWASM);
+        });
+        test('should be able to create transfer transition', async () => {
+            const tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+            const owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const recipient = '8GopLQQCViyroS2gHktesGaCMe2tueXWeQ6Y9vpMFTEC';
+            const amount = BigInt(100);
+            const tokenBaseTransition = await sdk.tokens.createBaseTransition(tokenId, owner);
+            const stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'transfer', { identityId: recipient, amount });
+            expect(stateTransition).toBeInstanceOf(StateTransitionWASM);
+        });
+        test('should be able to create freeze transition', async () => {
+            const tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+            const owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const identityId = '8GopLQQCViyroS2gHktesGaCMe2tueXWeQ6Y9vpMFTEC';
+            const tokenBaseTransition = await sdk.tokens.createBaseTransition(tokenId, owner);
+            const stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'freeze', { identityId });
+            expect(stateTransition).toBeInstanceOf(StateTransitionWASM);
+        });
+        test('should be able to create unfreeze transition', async () => {
+            const tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+            const owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const identityId = '8GopLQQCViyroS2gHktesGaCMe2tueXWeQ6Y9vpMFTEC';
+            const tokenBaseTransition = await sdk.tokens.createBaseTransition(tokenId, owner);
+            const stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'unfreeze', { identityId });
+            expect(stateTransition).toBeInstanceOf(StateTransitionWASM);
+        });
+        test('should be able to create destroyFrozenFunds transition', async () => {
+            const tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+            const owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const identityId = '8GopLQQCViyroS2gHktesGaCMe2tueXWeQ6Y9vpMFTEC';
+            const tokenBaseTransition = await sdk.tokens.createBaseTransition(tokenId, owner);
+            const stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'destroyFrozenFunds', { identityId });
+            expect(stateTransition).toBeInstanceOf(StateTransitionWASM);
+        });
+        test('should be able to create emergency action transition', async () => {
+            const tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+            const owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const emergencyAction = TokenEmergencyActionWASM.Pause;
+            const tokenBaseTransition = await sdk.tokens.createBaseTransition(tokenId, owner);
+            const stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'emergencyAction', { emergencyAction });
+            expect(stateTransition).toBeInstanceOf(StateTransitionWASM);
+        });
+        test('should be able to create setPriceForDirectPurchase transition', async () => {
+            const tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+            const owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const price = BigInt(10);
+            const tokenBaseTransition = await sdk.tokens.createBaseTransition(tokenId, owner);
+            const stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'setPriceForDirectPurchase', { price });
+            expect(stateTransition).toBeInstanceOf(StateTransitionWASM);
+        });
+        test('should be able to create directPurchase transition', async () => {
+            const tokenId = '6niNoQpsT9zyVDJtXcbpV3tR3qEGi6BC6xoDdJyx1u7C';
+            const owner = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
+            const amount = BigInt(10);
+            const totalAgreedPrice = BigInt(100);
+            const tokenBaseTransition = await sdk.tokens.createBaseTransition(tokenId, owner);
+            const stateTransition = sdk.tokens.createStateTransition(tokenBaseTransition, owner, 'directPurchase', { amount, totalAgreedPrice });
+            expect(stateTransition).toBeInstanceOf(StateTransitionWASM);
+        });
+    });
+});