pshenmic-dpp 2.0.0-dev.2 → 2.0.0-dev.20

package/dist/src/dpp/verify/StateTransition/utils.js

@@ -5,7 +5,7 @@ import { TokenPricingScheduleWASM } from '../../structs/Batch/TokenPricingSchedu
 import { PartialIdentityWASM } from '../../structs/PartialIdentity.js';
 import { VoteWASM } from '../../structs/MasternodeVote/Vote.js';
 import { DocumentWASM } from '../../structs/Document.js';
-import { PlatformAddressWASM } from '../../structs/Address/PlatformAddress.js';
+import { PlatformAddressWASM } from '../../structs/PlatformAddress/PlatformAddress.js';
 import { dppProvider } from '../../provider.js';
 const converters = () => {
     return new Map([
@@ -62,7 +62,7 @@ const converters = () => {
                 infos: v.infos.map(info => ({
                     nonce: info.nonce,
                     address: PlatformAddressWASM.createFromRawInstance(info.address),
-                    credits: info.credits != null ? BigInt(info.credits) : undefined
+                    balance: info.credits != null ? BigInt(info.credits) : undefined
                 }))
             })],
         [dppProvider.dpp.VerifiedIdentityWithAddressInfosNAPI, (v) => ({
@@ -70,11 +70,40 @@ const converters = () => {
                 infos: v.infos.map(info => ({
                     nonce: info.nonce,
                     address: PlatformAddressWASM.createFromRawInstance(info.address),
-                    credits: info.credits != null ? BigInt(info.credits) : undefined
+                    balance: info.credits != null ? BigInt(info.credits) : undefined
                 }))
             })]
     ]);
 };
+function convertPlatformAddressInfos(infos) {
+    return infos.map(info => ({
+        nonce: info.nonce,
+        address: PlatformAddressWASM.createFromRawInstance(info.address),
+        balance: info.credits != null ? BigInt(info.credits) : undefined
+    }));
+}
+function convertVerifiedDocuments(docs) {
+    return docs.map(item => ({
+        id: IdentifierWASM.createFromRawInstance(item.id),
+        document: item.document != null
+            ? DocumentWASM.createFromRawInstance(item.document)
+            : undefined
+    }));
+}
+function convertAssetLockValue(v) {
+    return {
+        initialCreditValue: BigInt(v.initialCreditValue),
+        txOutScript: v.txOutScript,
+        remainingCreditValue: BigInt(v.remainingCreditValue),
+        usedTags: v.usedTags
+    };
+}
+function convertStoredAssetLockInfo(v) {
+    return {
+        type: v.type,
+        value: v.value != null ? convertAssetLockValue(v.value) : undefined
+    };
+}
 function convertArray(result) {
     const [first] = result;
     if (first == null)
@@ -86,26 +115,62 @@ function convertArray(result) {
         }));
     }
     if (first instanceof dppProvider.dpp.VerifiedDocumentNAPI) {
-        return result.map(item => ({
-            id: IdentifierWASM.createFromRawInstance(item.id),
-            document: item.document != null
-                ? DocumentWASM.createFromRawInstance(item.document)
-                : undefined
-        }));
+        return convertVerifiedDocuments(result);
     }
-    if (first instanceof dppProvider.dpp.VerifiedAddressInfosNAPI) {
-        return result.map(item => ({
-            nonce: item.nonce,
-            address: PlatformAddressWASM.createFromRawInstance(item.address),
-            credits: item.credits != null ? BigInt(item.credits) : undefined
-        }));
+    if (first instanceof dppProvider.dpp.PlatformAddressInfoNAPI) {
+        return convertPlatformAddressInfos(result);
     }
     throw new Error('Unknown array type');
 }
+function convertTuple(result) {
+    const [first, second] = result;
+    if (first instanceof dppProvider.dpp.StoredAssetLockInfoNAPI) {
+        return {
+            storedAssetLockInfo: convertStoredAssetLockInfo(first),
+            infos: convertPlatformAddressInfos(second)
+        };
+    }
+    if (first instanceof dppProvider.dpp.IdentityNAPI) {
+        return {
+            identity: IdentityWASM.createFromRawInstance(first),
+            nullifiers: second
+        };
+    }
+    if (Array.isArray(first) && Array.isArray(second)) {
+        const secondFirst = second[0];
+        if (secondFirst != null && secondFirst instanceof dppProvider.dpp.VerifiedDocumentNAPI) {
+            return {
+                nullifiers: first,
+                documents: convertVerifiedDocuments(second)
+            };
+        }
+        return {
+            nullifiers: first,
+            infos: secondFirst != null ? convertPlatformAddressInfos(second) : []
+        };
+    }
+    throw new Error('Unknown tuple type');
+}
 export function convertResult(result) {
     if (Array.isArray(result)) {
+        if (result.length === 2) {
+            const [first] = result;
+            if (first instanceof dppProvider.dpp.StoredAssetLockInfoNAPI || first instanceof dppProvider.dpp.IdentityNAPI) {
+                return convertTuple(result);
+            }
+            if (Array.isArray(first) && (first.length === 0 || Array.isArray(first[0]))) {
+                return convertTuple(result);
+            }
+        }
+        const [first] = result;
+        if (first != null && Array.isArray(first) && first[0] instanceof Uint8Array) {
+            return result;
+        }
         return convertArray(result);
     }
+    if (result instanceof dppProvider.dpp.StoredAssetLockInfoNAPI) {
+        return convertStoredAssetLockInfo(result);
+    }
     for (const [Type, handler] of converters()) {
         if (result instanceof Type) {
             return handler(result);

package/dist/src/dpp/verify/System/verifyEpochsInfoProof.js

@@ -1,7 +1,7 @@
 import { dppProvider } from '../../provider.js';
 import { valueToDynamicValue } from '../../utils.js';
 export function verifyEpochsInfoProof(proof, currentEpoch, startEpoch, count, ascending, platformVersion) {
-    const result = dppProvider.dpp.verifyEpochsInfoProof(proof, currentEpoch, startEpoch, count, ascending, valueToDynamicValue(platformVersion));
+    const result = dppProvider.dpp.verifyEpochsInfoProof(proof, currentEpoch, startEpoch, count, ascending ?? false, valueToDynamicValue(platformVersion));
     return {
         rootHash: result.rootHash,
         epochsInfo: result.epochsInfo.map(info => ({

package/dist/src/dpp/verify/Tokens/verifyTokenBalancesForIdentitiesProof.js

@@ -6,7 +6,7 @@ export function verifyTokenBalancesForIdentitiesProof(proof, tokenId, isProofSub
     return {
         rootHash: result.rootHash,
         balances: result.balances.map(balance => ({
-            balance: BigInt(balance.balance),
+            balance: balance.balance != null ? BigInt(balance.balance) : undefined,
             id: IdentifierWASM.createFromRawInstance(balance.id)
         }))
     };

package/dist/src/dpp/verify/Tokens/verifyTokensBalancesForIdentityProof.js

@@ -6,7 +6,7 @@ export function verifyTokensBalancesForIdentityProof(proof, tokenIds, identityId
     return {
         rootHash: result.rootHash,
         balances: result.balances.map(balance => ({
-            balance: BigInt(balance.balance),
+            balance: balance.balance != null ? BigInt(balance.balance) : undefined,
             id: IdentifierWASM.createFromRawInstance(balance.id)
         }))
     };

package/dist/src/native.d.ts

@@ -0,0 +1,3 @@
+export * from './dpp/enums.js';
+export * from './dpp/dpp.js';
+export * from './dpp/types.js';

package/dist/src/native.js

@@ -0,0 +1,8 @@
+// @ts-ignore
+import protocol from '../binaries/node.cjs';
+import { dppProvider } from './dpp/provider.js';
+// @ts-ignore
+dppProvider.setDpp(protocol);
+export * from './dpp/enums.js';
+export * from './dpp/dpp.js';
+export * from './dpp/types.js';

package/dist/utils/{base122.js → base122.cjs}

@@ -1,3 +1,4 @@
+"use strict";
 // Original code: https://github.com/kevinAlbs/Base122
 // Provides functions for encoding/decoding data to and from base-122.
 const kIllegals = [
@@ -15,7 +16,7 @@ const kShortened = 0b111; // Uses the illegal index to signify the last two-byte
  * with raw data bytes or a string of bytes (i.e. the type of argument to btoa())
  * @returns {Uint8Array} The data in a regular array representing byte values.
  */
-export function decode(base122Data) {
+function decode(base122Data) {
     const strData = typeof (base122Data) === 'string' ? base122Data : utf8DataToString(base122Data);
     const decoded = [];
     let curByte = 0;
@@ -61,3 +62,4 @@ export function decode(base122Data) {
 function utf8DataToString(data) {
     return new TextDecoder().decode(data);
 }
+module.exports = { decode };

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "pshenmic-dpp",
-  "version": "2.0.0-dev.2",
+  "version": "2.0.0-dev.20",
   "main": "dist/src/wasm.js",
   "types": "dist/src/wasm.d.ts",
   "react-native": "./dist/src/react-native.js",
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "https://github.com/owl352/pshenmic-dpp"
+    "url": "git+https://github.com/owl352/pshenmic-dpp.git"
   },
   "scripts": {
     "build:bin": "node build.cjs",
-    "build:ts": "tsc && cp -R pkg/**/*.*.node dist/binaries/",
+    "build:ts": "tsc && cp -R pkg/**/*.*.node dist/binaries/ && cp -R pkg/binaries/native dist/binaries/",
     "build:full": "npm run build:bin && npm run build:ts",
     "ferric:build": "ferric build",
     "bundle": "rollup -c",
@@ -20,40 +20,30 @@
     "lint:rust": "cargo fmt",
     "lint:src": "ts-standard --fix ./pkg/src",
     "lint:tests": "ts-standard --fix ./pkg/src",
-    "lint": "npm run lint:rust && npm run lint:src && npm run lint:tests"
+    "lint": "npm run lint:rust && npm run lint:src && npm run lint:tests",
+    "prepack": "npm pkg delete devDependencies"
   },
   "files": [
     "dist/",
     "tests/"
   ],
+  "exports": {
+    ".": {
+      "browser": "./dist/src/wasm.js",
+      "node": "./dist/src/native.js",
+      "react-native": "./dist/src/react-native.js",
+      "default": "./dist/src/wasm.js"
+    },
+    "./wasm": "./dist/src/wasm.js",
+    "./wasm/utils": "./dist/src/dpp/utils.js",
+    "./native": "./dist/src/native.js"
+  },
   "author": "owl352",
   "license": "ISC",
   "description": "",
-  "devDependencies": {
-    "@babel/core": "^7.28.5",
-    "@babel/preset-env": "^7.28.5",
-    "@babel/preset-typescript": "^7.28.5",
-    "@scure/base": "^1.2.4",
-    "@types/jest": "^30.0.0",
-    "@types/node": "^24.0.13",
-    "babel": "^6.23.0",
-    "babel-jest": "^30.2.0",
-    "core-js": "^3.41.0",
-    "ferric-cli": "0.3.9",
-    "jest": "^30.2.0",
-    "mocha": "^11.1.0",
-    "node-addon-api": "^8.5.0",
-    "path": "^0.12.7",
-    "toml": "^3.0.0",
-    "ts-morph": "^26.0.0",
-    "tsx": "^4.20.6",
-    "typedoc": "^0.28.7",
-    "typescript": "^5.8.3",
-    "ts-standard": "^12.0.2"
-  },
   "dependencies": {
-    "@emnapi/core": "^1.7.0",
-    "@emnapi/runtime": "^1.7.0",
+    "@emnapi/core": "1.9.0",
+    "@emnapi/runtime": "1.9.0",
     "@tybys/wasm-util": "^0.10.1",
     "fflate": "^0.8.2"
   }

package/tests/unit/DataContract.spec.ts

@@ -0,0 +1,281 @@
+import {AuthorizedActionTakersWASM, ChangeControlRulesWASM, DataContractWASM,
+  DistributionFunctionWASM, IdentifierWASM, PlatformVersionWASM,
+  RewardDistributionTypeWASM, TokenConfigurationConventionWASM, TokenConfigurationLocalizationWASM,
+  TokenConfigurationWASM,
+  TokenDistributionRecipientWASM, TokenDistributionRulesWASM, TokenKeepsHistoryRulesWASM,
+  TokenMarketplaceRulesWASM, TokenPerpetualDistributionWASM,
+  TokenTradeModeWASM} from 'pshenmic-dpp'
+import {buildTokenConfiguration} from './utils/buildTokenConfiguration.js'
+
+const OWNER_ID_BASE58 = 'HEAmUtC72dPcZ59yyLUgfS8pfrEWqzYfDPzTofgWxXRr'
+
+const DOCUMENT_SCHEMA = {
+  note: {
+    type: 'object',
+    properties: {
+      message: {
+        type: 'string',
+        position: 0
+      }
+    },
+    additionalProperties: false
+  }
+}
+
+describe('DataContract', function () {
+  describe('constructor', function () {
+    test('should create a contract with document schemas only', function () {
+      const contract = new DataContractWASM(
+        OWNER_ID_BASE58,
+        BigInt(1),
+        DOCUMENT_SCHEMA,
+        undefined,
+        undefined,
+        true,
+        PlatformVersionWASM.PLATFORM_V10
+      )
+
+      expect(contract).toBeInstanceOf(DataContractWASM)
+      expect(contract.ownerId.base58()).toEqual(OWNER_ID_BASE58)
+      expect(contract.tokens.length).toEqual(0)
+      expect(Object.keys(contract.getSchemas())).toEqual(['note'])
+    })
+
+    test('should create a tokens-only contract (no document schemas)', function () {
+      const tokenConfig = buildTokenConfiguration()
+
+      const contract = new DataContractWASM(
+        OWNER_ID_BASE58,
+        BigInt(1),
+        {},
+        undefined,
+        [{position: 0, tokenConfiguration: tokenConfig}],
+        true,
+        PlatformVersionWASM.PLATFORM_V10
+      )
+
+      expect(contract).toBeInstanceOf(DataContractWASM)
+      expect(contract.tokens.length).toEqual(1)
+      expect(contract.tokens[0].position).toEqual(0)
+      expect(contract.tokens[0].tokenConfiguration.baseSupply).toEqual(BigInt(100000))
+    })
+
+    test('should fail to create a contract with neither documents nor tokens', function () {
+      expect(() => new DataContractWASM(
+        OWNER_ID_BASE58,
+        BigInt(1),
+        {},
+        undefined,
+        undefined,
+        true,
+        PlatformVersionWASM.PLATFORM_V10
+      )).toThrow()
+    })
+
+    test('should create a contract with both documents and tokens', function () {
+      const tokenConfig = buildTokenConfiguration({baseSupply: BigInt(50)})
+
+      const contract = new DataContractWASM(
+        OWNER_ID_BASE58,
+        BigInt(1),
+        DOCUMENT_SCHEMA,
+        undefined,
+        [{position: 0, tokenConfiguration: tokenConfig}],
+        true,
+        PlatformVersionWASM.PLATFORM_V10
+      )
+
+      expect(contract.tokens.length).toEqual(1)
+      expect(Object.keys(contract.getSchemas())).toEqual(['note'])
+    })
+
+    test('should generate a deterministic id from owner id and nonce', function () {
+      const contract = new DataContractWASM(
+        OWNER_ID_BASE58,
+        BigInt(42),
+        DOCUMENT_SCHEMA,
+        undefined,
+        undefined,
+        true,
+        PlatformVersionWASM.PLATFORM_V10
+      )
+
+      const expectedId = DataContractWASM.generateId(OWNER_ID_BASE58, BigInt(42))
+
+      expect(contract.id.base58()).toEqual(expectedId.base58())
+    })
+  })
+
+  describe('serialization', function () {
+    test('should serialize / deserialize via bytes', function () {
+      const contract = new DataContractWASM(
+        OWNER_ID_BASE58,
+        BigInt(1),
+        DOCUMENT_SCHEMA,
+        undefined,
+        undefined,
+        true,
+        PlatformVersionWASM.PLATFORM_V10
+      )
+
+      const bytes = contract.bytes(PlatformVersionWASM.PLATFORM_V10)
+      const restored = DataContractWASM.fromBytes(bytes, true, PlatformVersionWASM.PLATFORM_V10)
+
+      expect(restored.id.base58()).toEqual(contract.id.base58())
+      expect(restored.ownerId.base58()).toEqual(contract.ownerId.base58())
+    })
+
+    test('should serialize / deserialize a tokens-only contract via bytes', function () {
+      const tokenConfig = buildTokenConfiguration()
+
+      const contract = new DataContractWASM(
+        OWNER_ID_BASE58,
+        BigInt(1),
+        {},
+        undefined,
+        [{position: 0, tokenConfiguration: tokenConfig}],
+        true,
+        PlatformVersionWASM.PLATFORM_V10
+      )
+
+      const bytes = contract.bytes(PlatformVersionWASM.PLATFORM_V10)
+      const restored = DataContractWASM.fromBytes(bytes, true, PlatformVersionWASM.PLATFORM_V10)
+
+      expect(restored.tokens.length).toEqual(1)
+      expect(restored.tokens[0].tokenConfiguration.baseSupply).toEqual(tokenConfig.baseSupply)
+    })
+
+    test('should round-trip via hex', function () {
+      const contract = new DataContractWASM(
+        OWNER_ID_BASE58,
+        BigInt(1),
+        DOCUMENT_SCHEMA,
+        undefined,
+        undefined,
+        true,
+        PlatformVersionWASM.PLATFORM_V10
+      )
+
+      const hex = contract.hex(PlatformVersionWASM.PLATFORM_V10)
+      const restored = DataContractWASM.fromHex(hex, true, PlatformVersionWASM.PLATFORM_V10)
+
+      expect(restored.id.base58()).toEqual(contract.id.base58())
+    })
+
+    test('should round-trip via base64', function () {
+      const contract = new DataContractWASM(
+        OWNER_ID_BASE58,
+        BigInt(1),
+        DOCUMENT_SCHEMA,
+        undefined,
+        undefined,
+        true,
+        PlatformVersionWASM.PLATFORM_V10
+      )
+
+      const b64 = contract.base64(PlatformVersionWASM.PLATFORM_V10)
+      const restored = DataContractWASM.fromBase64(b64, true, PlatformVersionWASM.PLATFORM_V10)
+
+      expect(restored.id.base58()).toEqual(contract.id.base58())
+    })
+  })
+
+  describe('mutators', function () {
+    test('should allow setting tokens after construction', function () {
+      const contract = new DataContractWASM(
+        OWNER_ID_BASE58,
+        BigInt(1),
+        DOCUMENT_SCHEMA,
+        undefined,
+        undefined,
+        true,
+        PlatformVersionWASM.PLATFORM_V10
+      )
+
+      expect(contract.tokens.length).toEqual(0)
+
+      contract.tokens = [{position: 0, tokenConfiguration: buildTokenConfiguration()}]
+
+      expect(contract.tokens.length).toEqual(1)
+    })
+
+    test('should allow setting and reading description / keywords', function () {
+      const contract = new DataContractWASM(
+        OWNER_ID_BASE58,
+        BigInt(1),
+        DOCUMENT_SCHEMA,
+        undefined,
+        undefined,
+        true,
+        PlatformVersionWASM.PLATFORM_V10
+      )
+
+      contract.description = 'test contract'
+      contract.keywords = ['alpha', 'beta']
+
+      expect(contract.description).toEqual('test contract')
+      expect(contract.keywords).toEqual(['alpha', 'beta'])
+    })
+
+    test('should allow changing the owner id', function () {
+      const contract = new DataContractWASM(
+        OWNER_ID_BASE58,
+        BigInt(1),
+        DOCUMENT_SCHEMA,
+        undefined,
+        undefined,
+        true,
+        PlatformVersionWASM.PLATFORM_V10
+      )
+
+      const newOwner = new IdentifierWASM('ckBqfQe7LU7vwrwXopyCB4n5phZShjA16BGhNGpsD5U')
+
+      contract.ownerId = newOwner
+
+      expect(contract.ownerId.base58()).toEqual(newOwner.base58())
+    })
+  })
+
+  describe('tokens', function () {
+    test('should allow setting tokens after construction', function () {
+      const owner = '8J8k9aQ5Hotx8oLdnYAhYpyBJJGg4wZALptKLuDE9Df6'
+      const taker = () => AuthorizedActionTakersWASM.ContractOwner()
+      const rule = () => new ChangeControlRulesWASM(taker(), taker(), false, false, false)
+
+      const conventions = new TokenConfigurationConventionWASM(
+        {en: new TokenConfigurationLocalizationWASM(true, 'Tok', 'Toks')}, 8)
+
+      const perpetual = new TokenPerpetualDistributionWASM(
+        RewardDistributionTypeWASM.EpochBasedDistribution(1, DistributionFunctionWASM.FixedAmountDistribution(1n)),
+        TokenDistributionRecipientWASM.Identity(IdentifierWASM.fromBase58(owner))) // <- swap to .ContractOwner() => passes
+
+      const distributionRules = new TokenDistributionRulesWASM(
+        rule(), rule(), true, rule(), rule(), perpetual, undefined, undefined)
+
+      const tokenConfiguration = new TokenConfigurationWASM(
+        conventions, rule(), 100n,
+        new TokenKeepsHistoryRulesWASM(true, true, true, true, true, true),
+        false, false, rule(), distributionRules,
+        new TokenMarketplaceRulesWASM(TokenTradeModeWASM.NotTradeable(), rule()),
+        rule(), rule(), rule(), rule(), rule(), rule(),
+        taker(), undefined, undefined, undefined)
+
+      const contract = new DataContractWASM(owner, 1n, {note: {}}, undefined,
+        [{position: 0, tokenConfiguration}], true, undefined)
+
+      expect(contract).toBeInstanceOf(DataContractWASM)
+      expect(contract.tokens.length).toEqual(1)
+      expect(contract.tokens[0].position).toEqual(0)
+
+      const perpetualDistribution = contract.tokens[0].tokenConfiguration
+        .distributionRules.perpetualDistribution
+
+      expect(perpetualDistribution).toBeDefined()
+
+      const recipient = perpetualDistribution!.distributionRecipient
+
+      expect(recipient.getType()).toEqual(`Identity(${owner})`)
+      expect(recipient.getValue()?.base58()).toEqual(owner)
+    })
+  })
+})

package/tests/unit/DynamicValue.spec.ts

@@ -1,5 +1,5 @@
-import * as dpp from "../../pkg/src/wasm.js";
-import {valueFromDynamicValue, valueToDynamicValue} from "../../pkg/src/dpp/utils.js"
+import * as dpp from "pshenmic-dpp";
+import {valueFromDynamicValue, valueToDynamicValue} from "pshenmic-dpp/wasm/utils"
 
 describe('DynamicValue', () => {
   beforeAll(()=>{
@@ -83,4 +83,44 @@ describe('DynamicValue', () => {
       expect(valueFromDynamicValue(extendedArrayDynamicValue)).toStrictEqual(extendedArrayValue)
     })
   })
+
+  describe('number values in object', function () {
+    const mock = {
+      uint: 1999,
+      int: -293,
+      float: 2222.11231,
+      smallBigInt: BigInt(2),
+      bigBigInt: BigInt(2000000000000),
+      stringUint: '11',
+      stringInt: '-11',
+      stringFloat: '11.2',
+      bigStringNumber: '11111111111111111111111111111111'
+    }
+
+    const dynValue = valueToDynamicValue(mock)
+
+    const result = valueFromDynamicValue(dynValue)
+
+    expect(valueFromDynamicValue(dynValue)).toStrictEqual(mock)
+    expect(dynValue.value.uint.getType()).toStrictEqual('u32')
+    expect(dynValue.value.int.getType()).toStrictEqual('i64')
+    expect(dynValue.value.float.getType()).toStrictEqual('f64')
+    expect(dynValue.value.smallBigInt.getType()).toStrictEqual('BigIntString')
+    expect(dynValue.value.bigBigInt.getType()).toStrictEqual('BigIntString')
+    expect(dynValue.value.stringUint.getType()).toStrictEqual('String')
+    expect(dynValue.value.stringInt.getType()).toStrictEqual('String')
+    expect(dynValue.value.stringFloat.getType()).toStrictEqual('String')
+  })
+
+  describe('should decode document from state transition in jsonLike', function () {
+    const stateTransition = dpp.StateTransitionWASM.fromBase64('AgHv88sfWzscuW2Ob/0v5d+EgqmWG7ZIvlQG7mHWBH7z9gEAAAAB7JH7W+JkM0Vne2U1zlWYVeQNzRPTpdiWRfsgfwNS2UoCCGJsb2dQb3N0KBdMgeznVQ1smUXVFNPfE2PC379wpWVH8cdu2ilzeI0Ah/i2xfrKCm5ACQAbEQkSc+GRUkdLor4Eu7Vzf6oRc9UHBmJsb2dJZAogdhC4nVm3ufPCgdfoOKXtnhqwg7O3axyTS9WB3EFvNBYPY29tbWVudHNFbmFibGVkEwEHY29udGVudAr7AUh4nM2TTWrDMBCFrxK0jkCyJMvqLnRV6A1KFhpplJgotrEVaAi+e8clpdBuvCnNcn7ezPvQ6O3G2siemKgNSGETT8ZarhUm7hpX8yStEpVCk6xlW1auA1L34Ed/GP1wpNQw9sPEnm6s4Ht57nM/UkPE5C+5UBl8OB3G/tLF37VFscvtoTtjV6iSMRU2b1nou/KZIXf3jUvrXUHRrosbv8ltKRk30JbNl2LLpnLNuPiZ5z1NOrY5jtjRqP28vbM656zTleagJHCNXnIQiUIpgozGg2/0N2s4Yji9tlN5KXj+A97FJG1AcpZ8nnANv1wHGo22ASrFXQDJde0SBzDIdQBVRQEoDDw2aLUONPkKtfF0s9bR9bqGkJW3PNYCg/FOgIqPDarWgQrRxKapBXdCJ3pR7TjUVnJrpAo6yhSc/4dv+tPu/gNBt2qtC3B1Ymxpc2hlZEF0Av0AAAGcptJlIwRzbHVnEhV0aGlzLWlzLW15LWZpcnN0LXBvc3QIc3VidGl0bGUSD1dpdGggYSBzdWJ0aXRsZQV0aXRsZRIVVGhpcyBpcyBteSBmaXJzdCBwb3N0AAABQR+H40MbUEmFXQbTPcwy9vMD8EiTwDzMpW3YIkfSIDvHij5ZIAVvqm0ZJScJzKV7EnRUi/f1tZ/wFJfd1+LDtpps')
+
+    const batch = dpp.BatchTransitionWASM.fromStateTransition(stateTransition)
+
+    const transition = batch.transitions[0].toTransition() as dpp.DocumentTransitionWASM
+
+    const publishedAt = transition.createTransition.data.publishedAt
+
+    expect(typeof publishedAt).toEqual('number')
+  })
 })

package/tests/unit/Identifier.spec.ts

@@ -1,4 +1,4 @@
-import { IdentifierWASM } from "../../dist/src/wasm.js";
+import { IdentifierWASM } from "pshenmic-dpp";
 
 let identifierBytes: Uint8Array;
 

package/tests/unit/Identity.spec.ts

@@ -1,4 +1,4 @@
-import {IdentifierWASM, IdentityWASM, PlatformVersionWASM, IdentityPublicKeyWASM} from '../../dist/src/wasm.js'
+import {IdentifierWASM, IdentityWASM, PlatformVersionWASM, IdentityPublicKeyWASM} from 'pshenmic-dpp'
 
 let identifierBytes: Uint8Array
 let identifier: IdentifierWASM

package/tests/unit/IdentityPublicKey.spec.ts

@@ -1,4 +1,4 @@
-import {IdentityPublicKeyWASM, Purpose, SecurityLevel, KeyType} from '../../dist/src/wasm.js'
+import {IdentityPublicKeyWASM, Purpose, SecurityLevel, KeyType} from 'pshenmic-dpp'
 
 let keyId: number
 let purpose: Purpose

package/tests/unit/NodeApi.spec.ts

@@ -0,0 +1,49 @@
+import * as dpp from "pshenmic-dpp/native";
+import {IdentifierWASM} from "pshenmic-dpp/native";
+
+let identifierBytes: Uint8Array;
+
+describe("dpp", function () {
+  beforeAll(async function () {
+    identifierBytes = Uint8Array.from([
+      9, 40, 40, 237, 192, 129, 211, 186, 26, 84, 240, 67, 37, 155, 148, 19,
+      104, 242, 199, 24, 136, 27, 6, 169, 211, 71, 136, 59, 33, 191, 227, 19,
+    ]);
+  });
+
+  it('dpp object shouldn\'t be undefined or empty', () => {
+    expect(dpp).toBeDefined();
+  });
+
+  describe('classes accesibles', function () {
+    test("should allows to create Identifier from base58 via dpp object", function () {
+      const identifier = dpp.IdentifierWASM.fromBase58(
+        "ckBqfQe7LU7vwrwXopyCB4n5phZShjA16BGhNGpsD5U",
+      );
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+
+    test("should allows to create Identifier from base64 via IdentifierWASM import", function () {
+      const identifier = IdentifierWASM.fromBase64(
+        "CSgo7cCB07oaVPBDJZuUE2jyxxiIGwap00eIOyG/4xM=",
+      );
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+
+    test("should allows to create Identifier from hex", function () {
+      const identifier = IdentifierWASM.fromHex(
+        "092828edc081d3ba1a54f043259b941368f2c718881b06a9d347883b21bfe313",
+      );
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+
+    test("should allows to create Identifier from bytes", function () {
+      const identifier = IdentifierWASM.fromBytes(identifierBytes);
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+  })
+});