pshenmic-dpp 1.1.2-dev.8 → 2.0.0-dev.10

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

@@ -0,0 +1,115 @@
+import { DataContractWASM } from '../../structs/DataContract.js';
+import { IdentityWASM } from '../../structs/Identity.js';
+import { IdentifierWASM } from '../../structs/Identifier.js';
+import { TokenPricingScheduleWASM } from '../../structs/Batch/TokenPricingSchedule.js';
+import { PartialIdentityWASM } from '../../structs/PartialIdentity.js';
+import { VoteWASM } from '../../structs/MasternodeVote/Vote.js';
+import { DocumentWASM } from '../../structs/Document.js';
+import { PlatformAddressWASM } from '../../structs/PlatformAddress/PlatformAddress.js';
+import { dppProvider } from '../../provider.js';
+const converters = () => {
+    return new Map([
+        [dppProvider.dpp.DataContractNAPI, v => DataContractWASM.createFromRawInstance(v)],
+        [dppProvider.dpp.IdentityNAPI, v => IdentityWASM.createFromRawInstance(v)],
+        [dppProvider.dpp.IdentifierNAPI, v => IdentifierWASM.createFromRawInstance(v)],
+        [dppProvider.dpp.PartialIdentityNAPI, v => PartialIdentityWASM.createFromRawInstance(v)],
+        [dppProvider.dpp.DocumentNAPI, v => DocumentWASM.createFromRawInstance(v)],
+        [dppProvider.dpp.VoteNAPI, v => VoteWASM.createFromRawInstance(v)],
+        [dppProvider.dpp.IdentityTokenBalanceNAPI, (v) => ({
+                id: IdentifierWASM.createFromRawInstance(v.id),
+                balance: BigInt(v.balance)
+            })],
+        [dppProvider.dpp.VerifiedIdentityTokenInfoNAPI, (v) => ({
+                tokenId: IdentifierWASM.createFromRawInstance(v.id),
+                identityTokenInfo: {
+                    frozen: v.identityTokenInfo.frozen
+                }
+            })],
+        [dppProvider.dpp.VerifiedTokenPricingScheduleNAPI, (v) => ({
+                tokenId: IdentifierWASM.createFromRawInstance(v.id),
+                pricingSchedule: v.pricingSchedule != null
+                    ? TokenPricingScheduleWASM.createFromRawInstance(v.pricingSchedule)
+                    : undefined
+            })],
+        [dppProvider.dpp.TokenStatusNAPI, (v) => ({
+                paused: v.paused
+            })],
+        [dppProvider.dpp.VerifiedBalanceTransferNAPI, (v) => ({
+                sender: PartialIdentityWASM.createFromRawInstance(v.sender),
+                recipient: PartialIdentityWASM.createFromRawInstance(v.recipient)
+            })],
+        [dppProvider.dpp.VerifiedTokenGroupActionWithDocumentNAPI, (v) => ({
+                groupSumPower: v.groupSumPower,
+                document: v.document != null ? DocumentWASM.createFromRawInstance(v.document) : undefined
+            })],
+        [dppProvider.dpp.VerifiedTokenGroupActionWithTokenBalanceNAPI, (v) => ({
+                groupSumPower: v.groupSumPower,
+                groupActionStatus: v.groupActionStatus,
+                amount: v.amount != null ? BigInt(v.amount) : undefined
+            })],
+        [dppProvider.dpp.VerifiedTokenGroupActionWithTokenIdentityInfoNAPI, (v) => ({
+                groupSumPower: v.groupSumPower,
+                groupActionStatus: v.groupActionStatus,
+                identityTokenInfo: v.identityTokenInfo != null ? { frozen: v.identityTokenInfo.frozen } : undefined
+            })],
+        [dppProvider.dpp.VerifiedTokenGroupActionWithTokenPricingScheduleNAPI, (v) => ({
+                groupSumPower: v.groupSumPower,
+                groupActionStatus: v.groupActionStatus,
+                pricingSchedule: v.pricingSchedule != null ? TokenPricingScheduleWASM.createFromRawInstance(v.pricingSchedule) : undefined
+            })],
+        [dppProvider.dpp.VerifiedIdentityFullWithAddressInfosNAPI, (v) => ({
+                identity: IdentityWASM.createFromRawInstance(v.identity),
+                infos: v.infos.map(info => ({
+                    nonce: info.nonce,
+                    address: PlatformAddressWASM.createFromRawInstance(info.address),
+                    balance: info.credits != null ? BigInt(info.credits) : undefined
+                }))
+            })],
+        [dppProvider.dpp.VerifiedIdentityWithAddressInfosNAPI, (v) => ({
+                identity: PartialIdentityWASM.createFromRawInstance(v.identity),
+                infos: v.infos.map(info => ({
+                    nonce: info.nonce,
+                    address: PlatformAddressWASM.createFromRawInstance(info.address),
+                    balance: info.credits != null ? BigInt(info.credits) : undefined
+                }))
+            })]
+    ]);
+};
+function convertArray(result) {
+    const [first] = result;
+    if (first == null)
+        return [];
+    if (first instanceof dppProvider.dpp.IdentityTokenBalanceNAPI) {
+        return result.map(item => ({
+            id: IdentifierWASM.createFromRawInstance(item.id),
+            balance: BigInt(item.balance)
+        }));
+    }
+    if (first instanceof dppProvider.dpp.VerifiedDocumentNAPI) {
+        return result.map(item => ({
+            id: IdentifierWASM.createFromRawInstance(item.id),
+            document: item.document != null
+                ? DocumentWASM.createFromRawInstance(item.document)
+                : undefined
+        }));
+    }
+    if (first instanceof dppProvider.dpp.PlatformAddressInfoNAPI) {
+        return result.map(item => ({
+            nonce: item.nonce,
+            address: PlatformAddressWASM.createFromRawInstance(item.address),
+            balance: item.credits != null ? BigInt(item.credits) : undefined
+        }));
+    }
+    throw new Error('Unknown array type');
+}
+export function convertResult(result) {
+    if (Array.isArray(result)) {
+        return convertArray(result);
+    }
+    for (const [Type, handler] of converters()) {
+        if (result instanceof Type) {
+            return handler(result);
+        }
+    }
+    throw new Error(`Unknown result type: ${result?.constructor?.name}`);
+}

package/dist/src/dpp/verify/StateTransition/verifyStateTransitionResult.d.ts

@@ -0,0 +1,4 @@
+import { BlockInfo, PlatformVersionLike, VerifiedStateTransitionResult } from '../../types.js';
+import { StateTransitionWASM } from '../../structs/StateTransition.js';
+import { DataContractWASM } from '../../structs/DataContract.js';
+export declare function verifyStateTransitionResult(proof: Uint8Array, stateTransition: StateTransitionWASM, blockInfo: BlockInfo, knownContractsArray: DataContractWASM[], platformVersion: PlatformVersionLike): VerifiedStateTransitionResult;

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

@@ -0,0 +1,10 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { convertResult } from './utils.js';
+export function verifyStateTransitionResult(proof, stateTransition, blockInfo, knownContractsArray, platformVersion) {
+    const verified = dppProvider.dpp.verifyStateTransitionResult(proof, stateTransition._rawStateTransition, new dppProvider.dpp.BlockInfoNAPI(blockInfo.timeMs.toString(), blockInfo.height.toString(), blockInfo.coreHeight, blockInfo.epoch), knownContractsArray.map(contract => contract._rawDataContract), valueToDynamicValue(platformVersion));
+    return {
+        rootHash: verified.rootHash,
+        result: convertResult(verified.result)
+    };
+}

package/dist/src/dpp/verify/System/verifyEpochsInfoProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedEpochsInfo } from '../../types.js';
+export declare function verifyEpochsInfoProof(proof: Uint8Array, currentEpoch: number, startEpoch: number | undefined, count: number, ascending: boolean, platformVersion: PlatformVersionLike): VerifiedEpochsInfo;

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

@@ -0,0 +1,16 @@
+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 ?? false, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        epochsInfo: result.epochsInfo.map(info => ({
+            index: info.index,
+            firstBlockTime: BigInt(info.firstBlockTime),
+            firstBlockHeight: BigInt(info.firstBlockHeight),
+            firstCoreBlockHeight: info.firstCoreBlockHeight,
+            feeMultiplierPermille: BigInt(info.feeMultiplierPermille),
+            protocolVersion: info.protocolVersion
+        }))
+    };
+}

package/dist/src/dpp/verify/System/verifyTotalCreditsProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedTotalCredits } from '../../types.js';
+export declare function verifyTotalCreditsProof(proof: Uint8Array, coreSubsidyHalvingInterval: number, activationCoreHeight: number, currentCoreHeight: number, platformVersion: PlatformVersionLike): VerifiedTotalCredits;

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

@@ -0,0 +1,9 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyTotalCreditsProof(proof, coreSubsidyHalvingInterval, activationCoreHeight, currentCoreHeight, platformVersion) {
+    const result = dppProvider.dpp.verifyTotalCreditsProof(proof, coreSubsidyHalvingInterval, activationCoreHeight, currentCoreHeight, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        totalCredits: BigInt(result.totalCredits)
+    };
+}

package/dist/src/dpp/verify/Tokens/verifyTokenBalancesForIdentitiesProof.d.ts

@@ -0,0 +1,2 @@
+import { IdentifierLike, PlatformVersionLike, VerifiedTokenBalancesForIdentities } from '../../types.js';
+export declare function verifyTokenBalancesForIdentitiesProof(proof: Uint8Array, tokenId: IdentifierLike, isProofSubset: boolean, identitiesIds: IdentifierLike[], platformVersion: PlatformVersionLike): VerifiedTokenBalancesForIdentities;

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

@@ -0,0 +1,13 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+import { IdentifierWASM } from '../../structs/Identifier.js';
+export function verifyTokenBalancesForIdentitiesProof(proof, tokenId, isProofSubset, identitiesIds, platformVersion) {
+    const result = dppProvider.dpp.verifyTokenBalancesForIdentitiesProof(proof, prepareIdentifierValue(tokenId), isProofSubset, identitiesIds.map(prepareIdentifierValue), valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        balances: result.balances.map(balance => ({
+            balance: balance.balance != null ? BigInt(balance.balance) : undefined,
+            id: IdentifierWASM.createFromRawInstance(balance.id)
+        }))
+    };
+}

package/dist/src/dpp/verify/Tokens/verifyTokenContractInfoProof.d.ts

@@ -0,0 +1,2 @@
+import { IdentifierLike, PlatformVersionLike, VerifiedTokenContractInfo } from '../../types.js';
+export declare function verifyTokenContractInfoProof(proof: Uint8Array, tokenId: IdentifierLike, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedTokenContractInfo;

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

@@ -0,0 +1,15 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+import { IdentifierWASM } from '../../structs/Identifier.js';
+export function verifyTokenContractInfoProof(proof, tokenId, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyTokenContractInfoProof(proof, prepareIdentifierValue(tokenId), verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        contractInfo: result.contractInfo != null
+            ? {
+                contractId: IdentifierWASM.createFromRawInstance(result.contractInfo.contractId),
+                tokenContractPosition: result.contractInfo.tokenContractPosition
+            }
+            : undefined
+    };
+}

package/dist/src/dpp/verify/Tokens/verifyTokenDirectPurchasePrices.d.ts

@@ -0,0 +1,2 @@
+import { IdentifierLike, PlatformVersionLike, VerifiedTokenDirectPurchasePrices } from '../../types.js';
+export declare function verifyTokenDirectPurchasePrices(proof: Uint8Array, tokenIds: IdentifierLike[], verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedTokenDirectPurchasePrices;

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

@@ -0,0 +1,14 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+import { IdentifierWASM } from '../../structs/Identifier.js';
+import { TokenPricingScheduleWASM } from '../../structs/Batch/TokenPricingSchedule.js';
+export function verifyTokenDirectPurchasePrices(proof, tokenIds, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyTokenDirectPurchasePrices(proof, tokenIds.map(prepareIdentifierValue), verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        prices: result.prices.map(price => ({
+            tokenId: IdentifierWASM.createFromRawInstance(price.id),
+            pricingSchedule: price.pricingSchedule != null ? TokenPricingScheduleWASM.createFromRawInstance(price.pricingSchedule) : undefined
+        }))
+    };
+}

package/dist/src/dpp/verify/Tokens/verifyTokenTotalSupplyProof.d.ts

@@ -0,0 +1,2 @@
+import { IdentifierLike, PlatformVersionLike, VerifiedTokenTotalSupply } from '../../types.js';
+export declare function verifyTokenTotalSupplyProof(proof: Uint8Array, tokenId: IdentifierLike, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedTokenTotalSupply;

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

@@ -0,0 +1,12 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+export function verifyTokenTotalSupplyProof(proof, tokenId, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyTokenTotalSupplyProof(proof, prepareIdentifierValue(tokenId), verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        totalBalance: {
+            tokenSupply: BigInt(result.totalBalance.tokenSupply),
+            aggregatedTokenAccountBalances: BigInt(result.totalBalance.aggregatedTokenAccountBalances)
+        }
+    };
+}

package/dist/src/dpp/verify/Tokens/verifyTokensBalancesForIdentityProof.d.ts

@@ -0,0 +1,2 @@
+import { IdentifierLike, PlatformVersionLike, VerifiedTokensBalancesForIdentity } from '../../types.js';
+export declare function verifyTokensBalancesForIdentityProof(proof: Uint8Array, tokenIds: IdentifierLike[], identityId: IdentifierLike, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedTokensBalancesForIdentity;

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

@@ -0,0 +1,13 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+import { IdentifierWASM } from '../../structs/Identifier.js';
+export function verifyTokensBalancesForIdentityProof(proof, tokenIds, identityId, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyTokensBalancesForIdentityProof(proof, tokenIds.map(prepareIdentifierValue), prepareIdentifierValue(identityId), verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        balances: result.balances.map(balance => ({
+            balance: balance.balance != null ? BigInt(balance.balance) : undefined,
+            id: IdentifierWASM.createFromRawInstance(balance.id)
+        }))
+    };
+}

package/dist/src/dpp/verify/verifySignatureDigest.d.ts

@@ -0,0 +1 @@
+export declare function verifySignatureDigest(signDigest: Uint8Array, signature: Uint8Array, pubkeyBytes: Uint8Array): boolean;

package/dist/src/dpp/verify/verifySignatureDigest.js

@@ -0,0 +1,4 @@
+import { dppProvider } from '../provider.js';
+export function verifySignatureDigest(signDigest, signature, pubkeyBytes) {
+    return dppProvider.dpp.verifySignatureDigest(signDigest, signature, pubkeyBytes);
+}

package/dist/src/react-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/react-native.js

@@ -0,0 +1,6 @@
+import * as protocol from '../binaries/pshenmic_dpp.js';
+import { dppProvider } from './dpp/provider.js';
+dppProvider.setDpp(protocol);
+export * from './dpp/enums.js';
+export * from './dpp/dpp.js';
+export * from './dpp/types.js';

package/dist/src/wasm.d.ts

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

package/dist/src/wasm.js

@@ -0,0 +1,6 @@
+import * as protocol from '../binaries/wasm.js';
+import { dppProvider } from './dpp/provider.js';
+dppProvider.setDpp(protocol);
+export * from './dpp/enums.js';
+export * from './dpp/dpp.js';
+export * from './dpp/types.js';

package/dist/utils/base122.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Decodes base-122 encoded data back to the original data.
+ * @param {Uint8Array|String} rawData - The data to be decoded. This can be a Uint8Array
+ * 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: any): Uint8Array;

package/dist/utils/base122.js

@@ -0,0 +1,63 @@
+// Original code: https://github.com/kevinAlbs/Base122
+// Provides functions for encoding/decoding data to and from base-122.
+const kIllegals = [
+    0, // null
+    10, // newline
+    13, // carriage return
+    34, // double quote
+    38, // ampersand
+    92 // backslash
+];
+const kShortened = 0b111; // Uses the illegal index to signify the last two-byte char encodes <= 7 bits.
+/**
+ * Decodes base-122 encoded data back to the original data.
+ * @param {Uint8Array|String} rawData - The data to be decoded. This can be a Uint8Array
+ * 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) {
+    const strData = typeof (base122Data) === 'string' ? base122Data : utf8DataToString(base122Data);
+    const decoded = [];
+    let curByte = 0;
+    let bitOfByte = 0;
+    function push7(byte) {
+        byte <<= 1;
+        // Align this byte to offset for current byte.
+        curByte |= (byte >>> bitOfByte);
+        bitOfByte += 7;
+        if (bitOfByte >= 8) {
+            decoded.push(curByte);
+            bitOfByte -= 8;
+            // Now, take the remainder, left shift by what has been taken.
+            curByte = (byte << (7 - bitOfByte)) & 255;
+        }
+    }
+    for (let i = 0; i < strData.length; i++) {
+        const c = strData.charCodeAt(i);
+        // Check if this is a two-byte character.
+        if (c > 127) {
+            // Note, the charCodeAt will give the codePoint, thus
+            // 0b110xxxxx 0b10yyyyyy will give => xxxxxyyyyyy
+            const illegalIndex = (c >>> 8) & 7; // 7 = 0b111.
+            // We have to first check if this is a shortened two-byte character, i.e. if it only
+            // encodes <= 7 bits.
+            if (illegalIndex !== kShortened)
+                push7(kIllegals[illegalIndex]);
+            // Always push the rest.
+            push7(c & 127);
+        }
+        else {
+            // One byte characters can be pushed directly.
+            push7(c);
+        }
+    }
+    return new Uint8Array(decoded);
+}
+/**
+ * Converts a sequence of UTF-8 bytes to a string.
+ * @param {Uint8Array} data - The UTF-8 data.
+ * @returns {String} A string with each character representing a code point.
+ */
+function utf8DataToString(data) {
+    return new TextDecoder().decode(data);
+}

package/package.json

@@ -1,57 +1,60 @@
 {
   "name": "pshenmic-dpp",
-  "version": "1.1.2-dev.8",
-  "main": "dist/wasm/index.js",
-  "types": "dist/wasm/index.d.ts",
+  "version": "2.0.0-dev.10",
+  "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"
   },
   "scripts": {
-    "build:bin": "./scripts/build.sh",
-    "build:js": "npm run bundle && ./scripts/build-js.sh",
-    "build:full": "./scripts/build.sh && npm run bundle && ./scripts/build-js.sh",
-    "build:raw": "./scripts/build.sh && RAW=true ./scripts/build-js.sh",
+    "build:bin": "node build.cjs",
+    "build:ts": "tsc && cp -R pkg/**/*.*.node dist/binaries/",
+    "build:full": "npm run build:bin && npm run build:ts",
+    "ferric:build": "ferric build",
     "bundle": "rollup -c",
-    "docs": "tsx utils/generate-docs.ts && typedoc",
-    "babel": "babel dist/wasm --out-dir dist/cjs/wasm",
-    "tests": "mocha ./tests/*.spec.cjs",
-    "lint": "cargo fmt",
-    "lint:test": "standard --fix ./tests",
-    "convert:base122": "node ./utils/convertBinary.mjs"
+    "test": "jest",
+    "docs": "typedoc",
+    "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"
   },
   "files": [
-    "dist/wasm",
+    "dist/",
     "tests/"
   ],
-  "exports": {
-    ".": "./dist/wasm/index.js",
-    "./initAsync": "./dist/wasm/initAsync.js",
-    "./initInterface": "./dist/wasm/initInterface.js",
-    "./initWASM": "./dist/wasm/initWASM.js",
-    "./pshenmic_dpp_bg": "./dist/wasm/pshenmic_dpp_bg.js",
-    "./pshenmic_dpp": "./dist/wasm/pshenmic_dpp.js",
-    "./pshenmic_dpp_zipped": "./dist/wasm/pshenmic_dpp_zipped.js"
-  },
   "author": "owl352",
   "license": "ISC",
   "description": "",
   "devDependencies": {
-    "@rollup/plugin-terser": "^0.4.4",
+    "@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",
-    "rollup": "^4.52.2",
-    "standard": "^17.1.2",
+    "toml": "^3.0.0",
     "ts-morph": "^26.0.0",
     "tsx": "^4.20.6",
     "typedoc": "^0.28.7",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "ts-standard": "^12.0.2"
   },
   "dependencies": {
+    "@emnapi/core": "1.9.0",
+    "@emnapi/runtime": "1.9.0",
+    "@tybys/wasm-util": "^0.10.1",
     "fflate": "^0.8.2"
   }
 }

package/tests/unit/DynamicValue.spec.ts

@@ -0,0 +1,126 @@
+import * as dpp from "../../pkg/src/wasm.js";
+import {valueFromDynamicValue, valueToDynamicValue} from "../../pkg/src/dpp/utils.js"
+
+describe('DynamicValue', () => {
+  beforeAll(()=>{
+    // in real scenarios we cannot call valueFromDynamicValue and valueToDynamicValue from outside of module
+    // but tests use these methods and require to import dpp before run,
+    // or we can set dpp manually via setDpp()
+    dpp
+  })
+
+  describe('serialization / deserialization', function () {
+    test('should allow to serialize and deserialize basic types', function () {
+      const uint8ArrayValue = new Uint8Array([1, 2, 3, 4])
+      const numberValue = 122
+      const stringValue = 'bebra'
+      const bigIntValue = BigInt('88888888888888888888')
+      const boolValue = true
+      const nullValue = null
+      const undefinedValue = undefined
+      const floatValue = 24.2000000000
+      const intValue = -567
+
+      const uint8ArrayDynamicValue = valueToDynamicValue(uint8ArrayValue)
+      const numberDynamicValue = valueToDynamicValue(numberValue)
+      const stringDynamicValue = valueToDynamicValue(stringValue)
+      const bigIntDynamicValue = valueToDynamicValue(bigIntValue)
+      const boolDynamicValue = valueToDynamicValue(boolValue)
+      const nullDynamicValue = valueToDynamicValue(nullValue)
+      const undefinedDynamicValue = valueToDynamicValue(undefinedValue)
+      const floatDynamicValue = valueToDynamicValue(floatValue)
+      const intDynamicValue = valueToDynamicValue(intValue)
+
+      expect(uint8ArrayDynamicValue.value).toBeInstanceOf(Uint8Array)
+      expect(numberDynamicValue.value).toStrictEqual(numberValue)
+      expect(stringDynamicValue.value).toStrictEqual(stringValue)
+      expect(bigIntDynamicValue.value).toStrictEqual(bigIntValue.toString())
+      expect(boolDynamicValue.value).toStrictEqual(boolValue)
+      expect(nullDynamicValue.value).toStrictEqual(nullValue)
+      expect(undefinedDynamicValue.value).toStrictEqual(undefinedValue)
+      expect(floatDynamicValue.value).toStrictEqual(floatValue)
+      expect(intDynamicValue.value).toStrictEqual(intValue)
+
+      expect(valueFromDynamicValue(uint8ArrayDynamicValue)).toBeInstanceOf(Uint8Array)
+      expect(valueFromDynamicValue(numberDynamicValue)).toStrictEqual(numberValue)
+      expect(valueFromDynamicValue(stringDynamicValue)).toStrictEqual(stringValue)
+      expect(valueFromDynamicValue(bigIntDynamicValue)).toStrictEqual(bigIntValue)
+      expect(valueFromDynamicValue(boolDynamicValue)).toStrictEqual(boolValue)
+      expect(valueFromDynamicValue(nullDynamicValue)).toStrictEqual(nullValue)
+      expect(valueFromDynamicValue(undefinedDynamicValue)).toStrictEqual(undefinedValue)
+      expect(valueFromDynamicValue(floatDynamicValue)).toStrictEqual(floatValue)
+      expect(valueFromDynamicValue(intDynamicValue)).toStrictEqual(intValue)
+    })
+
+    test('should allow to serialize and deserialize object and array', function () {
+      const defaultObjectValue = {
+        0: 0,
+        1: 3,
+        2: "string",
+        3: false
+      }
+      const extendedObjectValue = {
+        a: 1,
+        b: false,
+        c: new Uint8Array([1, 2, 3, 45]),
+        v: BigInt('1111'),
+        e: {
+          bebra: "here",
+        }
+      }
+
+      const defaultArrayValue = [1, 2, 'b', true]
+      const extendedArrayValue = [1, extendedObjectValue]
+
+      const defaultObjectDynamicValue = valueToDynamicValue(defaultObjectValue)
+      const extendedObjectDynamicValue = valueToDynamicValue(extendedObjectValue)
+      const defaultArrayDynamicValue = valueToDynamicValue(defaultArrayValue)
+      const extendedArrayDynamicValue = valueToDynamicValue(extendedArrayValue)
+
+      expect(valueFromDynamicValue(defaultObjectDynamicValue)).toStrictEqual(defaultObjectValue)
+      expect(valueFromDynamicValue(extendedObjectDynamicValue)).toStrictEqual(extendedObjectValue)
+      expect(valueFromDynamicValue(defaultArrayDynamicValue)).toStrictEqual(defaultArrayValue)
+      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')
+  })
+})