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

package/dist/src/dpp/utils.js

@@ -1,8 +1,9 @@
 import { dppProvider } from './provider.js';
 import { UINT32MAX } from './constants.js';
 import { IdentifierWASM } from './structs/Identifier.js';
+import { PlatformAddressWASM } from './structs/PlatformAddress/PlatformAddress.js';
 export function valueToDynamicValue(value) {
-    if (typeof value === 'bigint' || value > UINT32MAX) {
+    if (typeof value === 'bigint' || (value > UINT32MAX && typeof value !== 'string')) {
         return dppProvider.dpp.DynamicValue.fromBigIntString(BigInt(value.toString()).toString());
     }
     else if (value instanceof IdentifierWASM || value instanceof dppProvider.dpp.IdentifierNAPI) {
@@ -43,21 +44,27 @@ export function valueToDynamicValue(value) {
         return new dppProvider.dpp.DynamicValue(value);
     }
 }
-export function valueFromDynamicValue(dynamicValue) {
+export function valueFromDynamicValue(dynamicValue, jsonLike = false) {
     if (dynamicValue.value instanceof dppProvider.dpp.DynamicValue) {
-        return valueToDynamicValue(dynamicValue.value);
+        return valueFromDynamicValue(dynamicValue.value, jsonLike);
     }
     else if (dynamicValue.isBigInt()) {
-        return BigInt(dynamicValue.value);
+        const num = BigInt(dynamicValue.value);
+        if (jsonLike && num < BigInt(Number.MAX_SAFE_INTEGER) && num > BigInt(Number.MIN_SAFE_INTEGER)) {
+            return Number(dynamicValue.value);
+        }
+        else {
+            return num;
+        }
     }
     else if (Array.isArray(dynamicValue.value)) {
-        return dynamicValue.value.map(valueFromDynamicValue);
+        return dynamicValue.value.map(v => valueFromDynamicValue(v, jsonLike));
     }
     else if (typeof dynamicValue.value === 'object' && !(dynamicValue.value instanceof Uint8Array) && dynamicValue.value !== null) {
         const obj = {};
         const keys = Object.keys(dynamicValue.value);
         for (const key of keys) {
-            obj[key] = valueFromDynamicValue(dynamicValue.value[key]);
+            obj[key] = valueFromDynamicValue(dynamicValue.value[key], jsonLike);
         }
         return obj;
     }
@@ -76,3 +83,14 @@ export function prepareIdentifierValue(identifier) {
         return new dppProvider.dpp.DynamicValue(identifier);
     }
 }
+export function preparePlatformAddressValue(address) {
+    if (address instanceof PlatformAddressWASM) {
+        return address._rawPlatformAddress;
+    }
+    else if (address instanceof dppProvider.dpp.PlatformAddressNAPI) {
+        return address;
+    }
+    else {
+        return new dppProvider.dpp.DynamicValue(address);
+    }
+}

package/dist/src/dpp/verify/Contested/verifyVotePollVoteStateProof.d.ts

@@ -1,3 +1,3 @@
 import { PlatformVersionLike, StartAt, VerifiedVoteState, VoteStateResultTypeLike } from '../../types.js';
 import { DataContractWASM } from '../../structs/DataContract.js';
-export declare function verifyVotePollVoteStateProof(proof: Uint8Array, contract: DataContractWASM, documentTypeName: string, indexName: string, indexValues: Uint8Array[], resultType: VoteStateResultTypeLike, allowIncludeLockedAndAbstainingVoteTally: boolean, count: number | undefined, startAt: StartAt | undefined, platformVersion: PlatformVersionLike): VerifiedVoteState;
+export declare function verifyVotePollVoteStateProof(proof: Uint8Array, contract: DataContractWASM, documentTypeName: string, indexName: string, indexValues: Uint8Array[], resultType: VoteStateResultTypeLike, allowIncludeLockedAndAbstainingVoteTally: boolean | undefined, count: number | undefined, startAt: StartAt | undefined, platformVersion: PlatformVersionLike): VerifiedVoteState;

package/dist/src/dpp/verify/Contested/verifyVotePollVoteStateProof.js

@@ -2,7 +2,7 @@ import { dppProvider } from '../../provider.js';
 import { valueFromDynamicValue, valueToDynamicValue } from '../../utils.js';
 import { IdentifierWASM } from '../../structs/Identifier.js';
 export function verifyVotePollVoteStateProof(proof, contract, documentTypeName, indexName, indexValues, resultType, allowIncludeLockedAndAbstainingVoteTally, count, startAt, platformVersion) {
-    const result = dppProvider.dpp.verifyVotePollVoteStateProof(proof, contract._rawDataContract, documentTypeName, indexName, indexValues, valueToDynamicValue(resultType), allowIncludeLockedAndAbstainingVoteTally, count, valueToDynamicValue(startAt), valueToDynamicValue(platformVersion));
+    const result = dppProvider.dpp.verifyVotePollVoteStateProof(proof, contract._rawDataContract, documentTypeName, indexName, indexValues, valueToDynamicValue(resultType), allowIncludeLockedAndAbstainingVoteTally ?? false, count, valueToDynamicValue(startAt), valueToDynamicValue(platformVersion));
     const winner = valueFromDynamicValue(result.result.winner);
     const winnerBlockInfo = winner?.blockInfo;
     const outWinner = winner != null

package/dist/src/dpp/verify/PlatformAddress/verifyPlatformAddressInfo.d.ts

@@ -0,0 +1,2 @@
+import { PlatformAddressLike, PlatformVersionLike, VerifiedPlatformAddressInfoWithRootHash } from '../../types.js';
+export declare function verifyPlatformAddressInfo(proof: Uint8Array, platformAddress: PlatformAddressLike, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedPlatformAddressInfoWithRootHash;

package/dist/src/dpp/verify/PlatformAddress/verifyPlatformAddressInfo.js

@@ -0,0 +1,12 @@
+import { dppProvider } from '../../provider.js';
+import { preparePlatformAddressValue, valueToDynamicValue } from '../../utils.js';
+import { PlatformAddressWASM } from '../../structs/PlatformAddress/PlatformAddress.js';
+export function verifyPlatformAddressInfo(proof, platformAddress, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyAddressInfo(proof, preparePlatformAddressValue(platformAddress), verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        address: result.address != null ? PlatformAddressWASM.createFromRawInstance(result.address) : undefined,
+        balance: result.balance != null ? BigInt(result.balance) : undefined,
+        nonce: result.nonce
+    };
+}

package/dist/src/dpp/verify/PlatformAddress/verifyPlatformAddressesInfos.d.ts

@@ -0,0 +1,2 @@
+import { PlatformAddressLike, PlatformVersionLike, VerifiedPlatformAddressesInfosWithRootHash } from '../../types.js';
+export declare function verifyPlatformAddressesInfos(proof: Uint8Array, platformAddresses: PlatformAddressLike[], verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedPlatformAddressesInfosWithRootHash;

package/dist/src/dpp/verify/PlatformAddress/verifyPlatformAddressesInfos.js

@@ -0,0 +1,14 @@
+import { dppProvider } from '../../provider.js';
+import { preparePlatformAddressValue, valueToDynamicValue } from '../../utils.js';
+import { PlatformAddressWASM } from '../../structs/PlatformAddress/PlatformAddress.js';
+export function verifyPlatformAddressesInfos(proof, platformAddresses, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyAddressesInfos(proof, platformAddresses.map(preparePlatformAddressValue), verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        infos: result.infos.map(({ nonce, credits, address }) => ({
+            nonce,
+            balance: credits != null ? BigInt(credits) : undefined,
+            address: PlatformAddressWASM.createFromRawInstance(address)
+        }))
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyMostRecentShieldedAnchorProof.d.ts

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

package/dist/src/dpp/verify/Shielded/verifyMostRecentShieldedAnchorProof.js

@@ -0,0 +1,9 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyMostRecentShieldedAnchorProof(proof, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyMostRecentShieldedAnchorProof(proof, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        anchor: result.anchor ?? undefined
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedAnchorsProof.d.ts

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

package/dist/src/dpp/verify/Shielded/verifyShieldedAnchorsProof.js

@@ -0,0 +1,9 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedAnchorsProof(proof, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedAnchorsProof(proof, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        anchors: result.anchors
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedEncryptedNotesProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedShieldedEncryptedNotes } from '../../types.js';
+export declare function verifyShieldedEncryptedNotesProof(proof: Uint8Array, startIndex: bigint, count: number, maxElements: number, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedShieldedEncryptedNotes;

package/dist/src/dpp/verify/Shielded/verifyShieldedEncryptedNotesProof.js

@@ -0,0 +1,15 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedEncryptedNotesProof(proof, startIndex, count, maxElements, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedEncryptedNotesProof(proof, startIndex.toString(), count, maxElements, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        notes: result.notes.map((note) => ({
+            cmx: note.cmx,
+            nullifier: note.nullifier,
+            cvNet: note.cvNet,
+            encryptedNote: note.encryptedNote
+        })),
+        totalCount: BigInt(result.totalCount)
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedNotesCountProof.d.ts

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

package/dist/src/dpp/verify/Shielded/verifyShieldedNotesCountProof.js

@@ -0,0 +1,9 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedNotesCountProof(proof, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedNotesCountProof(proof, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        count: result.count != null ? BigInt(result.count) : undefined
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedNullifiersProof.d.ts

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

package/dist/src/dpp/verify/Shielded/verifyShieldedNullifiersProof.js

@@ -0,0 +1,12 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedNullifiersProof(proof, nullifiers, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedNullifiersProof(proof, nullifiers, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        nullifiers: result.nullifiers.map((nullifier) => ({
+            nullifier: nullifier.nullifier,
+            isSpent: nullifier.isSpent
+        }))
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedPoolStateProof.d.ts

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

package/dist/src/dpp/verify/Shielded/verifyShieldedPoolStateProof.js

@@ -0,0 +1,9 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedPoolStateProof(proof, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedPoolStateProof(proof, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        totalBalance: result.totalBalance != null ? BigInt(result.totalBalance) : undefined
+    };
+}

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.21",
   "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"
   }