pshenmic-dpp 1.1.0-dev.2 → 1.1.0-dev.4

package/README.md

@@ -18,18 +18,23 @@ ___
 ### Build JS
 `yarn build:full`
 
-**NOTE. If you want to use ES6 module without CJS, you need to run `yarn babel`**
-
 ### Build with binary instead base122
 `yarn build:raw`
 Now you can import `.js` with base122 buffer for WebAssembly module, or binary which smaller
 ___
 ## Why you need to use `pshenmic-dpp` instead `wasm-dpp`
 
-- `pshenmic-dpp` weighs much less, currently taking up only 3.9 mb in base122 format
+- `pshenmic-dpp` weighs much less, currently taking up only 1.4mb(\*) or 2.2mb(\*) in base122 format with GZIP
 - You can build only necessary modules by removing imports from `lib.rs` before building
 - More accurately replicates `rs-dpp`
 - Some sugar, like enums, which you can pass in string with any case or just use numbers
+
+**(\*)** \- This module contains 2 builds for wasm js layer:
+- JS without bundling or GZIP (2.2mb)
+- Bundled JS with GZIP (1.4mb)
+
+These variations can be imported depending on requirements.
+In both cases, the binary wasm data will be compressed using gzip.
 ___
 
 ## Current features
@@ -129,8 +134,9 @@ yarn tests
 
 ## Example
 
+This example show how to synchronously import module with size 2.2mb  
 ```js
-import wasm from pshenmic_dpp';
+import wasm from 'pshenmic_dpp';
 
 const document = new wasm.DocumentWASM(
     {
@@ -169,3 +175,19 @@ st.sign(privKey, pubKey)
 console.log(st.toBytes())
 console.log(st.hash(false))
 ```
+
+This example show how to asynchronously import module with size 1.4mb
+```js
+const {default: initWASM} = require('pshenmic-dpp/initAsync')
+
+async function main() {
+  let wasm = await initWASM()
+
+  const dataContractIdentifier = new wasm.IdentifierWASM('6QMfQTdKpC3Y9uWBcTwXeY3KdzRLDqASUsDnQ4MEc9XC')
+  const ownerIdentifier = new wasm.IdentifierWASM('B7kcE1juMBWEWkuYRJhVdAE2e6RaevrGxRsa1DrLCpQH')
+
+  const documentInstance = new wasm.DocumentWASM(document, 'documentTypeName', BigInt(1), dataContractIdentifier, ownerIdentifier)
+}
+
+main().catch(console.error)
+```

package/dist/wasm/base122.js

@@ -18,10 +18,9 @@ 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 decodeBase122 (base122Data) {
+export function decode (base122Data) {
   const strData = typeof (base122Data) === 'string' ? base122Data : utf8DataToString(base122Data)
   const decoded = []
-  const decodedIndex = 0
   let curByte = 0
   let bitOfByte = 0
 
@@ -47,7 +46,7 @@ export function decodeBase122 (base122Data) {
       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])
+      if (illegalIndex !== kShortened) push7(kIllegals[illegalIndex])
       // Always push the rest.
       push7(c & 127)
     } else {

package/dist/wasm/index.d.ts

@@ -1,8 +1,8 @@
-import * as DPP from './pshenmic_dpp';
+import * as DPP from './pshenmic_dpp.js';
 
-export * from './pshenmic_dpp'
+export * from './pshenmic_dpp.js'
 
-export * from './base122'
+export * from './base122.js'
 
 export default dpp;
 
@@ -122,4 +122,5 @@ export class DashPlatformProtocolWASM {
     verifyTokenContractInfo: Function
     verifyTokenTotalSupply: Function
     verifyTokensBalancesForIdentity: Function
+    verifyTokenDirectPurchasePrices: Function
 }

package/dist/wasm/index.js

@@ -1,12 +1,13 @@
 import * as DPP from './pshenmic_dpp.js'
-import { default as wasmBytes } from './pshenmic_dpp_bg.js'
-import { decodeBase122 } from './base122.js'
+import wasmBytes from './pshenmic_dpp_bg.js'
+import { decode } from './base122.js'
+import { decompressSync } from 'fflate'
 
 export * from './base122.js'
 export * from './pshenmic_dpp.js'
 
-const bytes = new Uint8Array(decodeBase122(wasmBytes))
+const bytes = new Uint8Array(decode(wasmBytes))
 
-const dppInstance = DPP.initSync({ module: bytes })
+DPP.initSync({ module: decompressSync(bytes) })
 
 export default DPP

package/dist/wasm/initAsync.d.ts

@@ -0,0 +1,6 @@
+import type {DashPlatformProtocolWASM} from "./index.d.ts";
+
+declare function initModule(): Promise<DashPlatformProtocolWASM>
+
+export default initModule;
+export type { DashPlatformProtocolWASM } from './index.d.ts';

package/dist/wasm/initAsync.js

@@ -0,0 +1,20 @@
+import initWASM from './initWASM.js'
+import initWASMInterface from './initInterface.js'
+
+// eslint-disable-next-line
+let dpp
+
+/**
+ * Asynchronously initialization for compressed module (reduced size)
+ * @returns {Promise<*>}
+ */
+async function initModule () {
+  const wasm = await initWASM()
+  const wasmInterface = await initWASMInterface()
+
+  dpp = wasmInterface.initSync(wasm)
+
+  return wasmInterface
+}
+
+export default initModule

package/dist/wasm/initInterface.d.ts

@@ -0,0 +1,5 @@
+import type {DashPlatformProtocolWASM} from "./index.d.ts";
+
+declare function initModule(): Promise<DashPlatformProtocolWASM>
+
+export default initModule;

package/dist/wasm/initInterface.js

@@ -0,0 +1,45 @@
+import wasmInterfaceBytes from './pshenmic_dpp_zipped.js'
+import { decode } from './base122.js'
+
+export * from './base122.js'
+
+const isNode = () =>
+  typeof process !== 'undefined' &&
+  !!process.versions &&
+  !!process.versions.node
+
+const interfaceBytes = new Uint8Array(decode(wasmInterfaceBytes))
+const interfaceBlob = new Blob([interfaceBytes])
+
+async function initInterface () {
+  const decompressionStream = new DecompressionStream('gzip')
+  const decompressedStream = interfaceBlob.stream().pipeThrough(decompressionStream)
+  const decompressedResponse = new Response(decompressedStream)
+  const moduleText = await decompressedResponse.text()
+
+  let module
+  if (isNode()) {
+    const vm = await import('vm')
+
+    const context = vm.createContext({
+      crypto,
+      TextDecoder
+    })
+    const vmModule = new vm.Script(moduleText)
+
+    vmModule.runInContext(context)
+
+    module = context['pshenmic-dpp']
+  } else {
+    const blob = new Blob([moduleText], { type: 'application/javascript' })
+    const moduleUrl = URL.createObjectURL(blob)
+
+    module = await import(moduleUrl)
+
+    URL.revokeObjectURL(moduleUrl)
+  }
+
+  return module
+}
+
+export default initInterface

package/dist/wasm/initWASM.d.ts

@@ -0,0 +1,2 @@
+declare function _default(): Promise<ArrayBuffer>;
+export default _default;

package/dist/wasm/initWASM.js

@@ -0,0 +1,28 @@
+import wasmBytes from './pshenmic_dpp_bg.js'
+import { decode } from './base122.js'
+
+export * from './base122.js'
+
+// eslint-disable-next-line
+const isNode = () =>
+  typeof process !== 'undefined' &&
+  !!process.versions &&
+  !!process.versions.node
+
+const interfaceBytes = new Uint8Array(decode(wasmBytes))
+const interfaceBlob = new Blob([interfaceBytes])
+
+/**
+ * Convert wasm bin string to Uint8Array with decompression via DecompressionStream
+ * @returns {Promise<ArrayBuffer>}
+ */
+async function initWASM () {
+  const decompressionStream = new DecompressionStream('gzip')
+  const decompressedStream = interfaceBlob.stream().pipeThrough(decompressionStream)
+  const decompressedResponse = new Response(decompressedStream)
+  const module = await decompressedResponse.arrayBuffer()
+
+  return module
+}
+
+export default initWASM

package/dist/wasm/pshenmic_dpp.d.ts

@@ -15,6 +15,7 @@ export function verifyEpochsInfoProof(proof: Uint8Array, current_epoch: number,
 export function verifyTotalCreditsProof(proof: Uint8Array, core_subsidy_halving_interval: number, activation_core_height: number, current_core_height: number, js_platform_version: any): VerifiedTotalCreditsWASM;
 export function verifyTokenBalancesForIdentitiesProof(proof: Uint8Array, js_token_id: any, is_proof_subset: boolean, js_identities: any, js_platform_version: any): VerifiedTokenBalancesForIdentitiesWASM;
 export function verifyTokenContractInfoProof(proof: Uint8Array, js_token_id: any, verify_subset_of_proof: boolean, js_platform_version: any): VerifiedTokenContractInfoWASM;
+export function verifyTokenDirectPurchasePrices(proof: Uint8Array, js_token_ids: any, verify_subset_of_proof: boolean, js_platform_version: any): VerifiedTokenDirectPurchasePrices;
 export function verifyTokenTotalSupplyProof(proof: Uint8Array, js_token_id: any, verify_subset_of_proof: boolean, js_platform_version: any): VerifiedTokenTotalSupplyWASM;
 export function verifyTokensBalancesForIdentityProof(proof: Uint8Array, js_token_ids: any, js_identity_id: any, verify_subset_of_proof: boolean, js_platform_version: any): VerifiedTokensBalancesForIdentityWASM;
 export enum ActionGoalWASM {
@@ -2976,6 +2977,16 @@ export class VerifiedTokenContractInfoWASM {
   readonly rootHash: Uint8Array;
   readonly contractInfo: TokenContractInfoWASM | undefined;
 }
+export class VerifiedTokenDirectPurchasePrices {
+  /** @returns {VerifiedTokenDirectPurchasePrices} */
+    private constructor();
+  /** @ignore */
+    free(): void;
+  readonly __type: string;
+  static readonly __struct: string;
+  readonly rootHash: Uint8Array;
+  readonly prices: Array<any> | undefined;
+}
 export class VerifiedTokenTotalSupplyWASM {
   /** @returns {VerifiedTokenTotalSupplyWASM} */
     private constructor();
@@ -3177,6 +3188,12 @@ export interface InitOutput {
   readonly verifiedtokencontractinfowasm_root_hash: (a: number) => number;
   readonly verifiedtokencontractinfowasm_get_contract_info: (a: number) => number;
   readonly verifyTokenContractInfoProof: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly __wbg_verifiedtokendirectpurchaseprices_free: (a: number, b: number) => void;
+  readonly verifiedtokendirectpurchaseprices_type_name: (a: number, b: number) => void;
+  readonly verifiedtokendirectpurchaseprices_struct_name: (a: number) => void;
+  readonly verifiedtokendirectpurchaseprices_root_hash: (a: number) => number;
+  readonly verifiedtokendirectpurchaseprices_prices: (a: number, b: number) => void;
+  readonly verifyTokenDirectPurchasePrices: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly __wbg_totalsingletokenbalancewasm_free: (a: number, b: number) => void;
   readonly totalsingletokenbalancewasm_type_name: (a: number, b: number) => void;
   readonly totalsingletokenbalancewasm_struct_name: (a: number) => void;
@@ -3190,20 +3207,20 @@ export interface InitOutput {
   readonly verifiedtokensbalancesforidentitywasm_type_name: (a: number, b: number) => void;
   readonly verifiedtokensbalancesforidentitywasm_struct_name: (a: number) => void;
   readonly verifyTokensBalancesForIdentityProof: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly __wbg_verifiedidentitynoncewasm_free: (a: number, b: number) => void;
   readonly __wbg_verifiedtotalcreditswasm_free: (a: number, b: number) => void;
-  readonly __wbg_verifiedidentitycontractnoncewasm_free: (a: number, b: number) => void;
+  readonly __wbg_verifiedidentitynoncewasm_free: (a: number, b: number) => void;
   readonly __wbg_verifiedtokentotalsupplywasm_free: (a: number, b: number) => void;
+  readonly __wbg_verifiedidentitycontractnoncewasm_free: (a: number, b: number) => void;
   readonly __wbg_verifiedtokensbalancesforidentitywasm_free: (a: number, b: number) => void;
   readonly __wbg_verifiedidentitybyuniquekeyhashwasm_free: (a: number, b: number) => void;
+  readonly verifiedtokensbalancesforidentitywasm_balances: (a: number) => number;
+  readonly verifiedtokensbalancesforidentitywasm_root_hash: (a: number) => number;
   readonly verifiedidentitynoncewasm_nonce: (a: number, b: number) => void;
   readonly verifiedidentitynoncewasm_root_hash: (a: number) => number;
   readonly verifiedidentitybyuniquekeyhashwasm_identity: (a: number) => number;
   readonly verifiedidentitybyuniquekeyhashwasm_root_hash: (a: number) => number;
   readonly verifiedidentitycontractnoncewasm_contract_nonce: (a: number, b: number) => void;
   readonly verifiedidentitycontractnoncewasm_root_hash: (a: number) => number;
-  readonly verifiedtokensbalancesforidentitywasm_balances: (a: number) => number;
-  readonly verifiedtokensbalancesforidentitywasm_root_hash: (a: number) => number;
   readonly __wbg_partialidentitywasm_free: (a: number, b: number) => void;
   readonly partialidentitywasm_new: (a: number, b: number, c: number, d: number, e: bigint, f: number, g: bigint, h: number) => void;
   readonly partialidentitywasm_id: (a: number) => number;

package/dist/wasm/pshenmic_dpp.js

@@ -677,6 +677,32 @@ export function verifyTokenContractInfoProof(proof, js_token_id, verify_subset_o
     }
 }
 
+/**
+ * @param {Uint8Array} proof
+ * @param {any} js_token_ids
+ * @param {boolean} verify_subset_of_proof
+ * @param {any} js_platform_version
+ * @returns {VerifiedTokenDirectPurchasePrices}
+ */
+export function verifyTokenDirectPurchasePrices(proof, js_token_ids, verify_subset_of_proof, js_platform_version) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.verifyTokenDirectPurchasePrices(retptr, addBorrowedObject(proof), addBorrowedObject(js_token_ids), verify_subset_of_proof, addBorrowedObject(js_platform_version));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return VerifiedTokenDirectPurchasePrices.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        heap[stack_pointer++] = undefined;
+        heap[stack_pointer++] = undefined;
+        heap[stack_pointer++] = undefined;
+    }
+}
+
 /**
  * @param {Uint8Array} proof
  * @param {any} js_token_id
@@ -20771,6 +20797,98 @@ export class VerifiedTokenContractInfoWASM {
     }
 }
 
+const VerifiedTokenDirectPurchasePricesFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_verifiedtokendirectpurchaseprices_free(ptr >>> 0, 1));
+
+export class VerifiedTokenDirectPurchasePrices {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(VerifiedTokenDirectPurchasePrices.prototype);
+        obj.__wbg_ptr = ptr;
+        VerifiedTokenDirectPurchasePricesFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VerifiedTokenDirectPurchasePricesFinalization.unregister(this);
+        return ptr;
+    }
+
+    /** @ignore */
+    /** */
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_verifiedtokendirectpurchaseprices_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.verifiedtokendirectpurchaseprices_type_name(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_3(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.verifiedtokendirectpurchaseprices_struct_name(retptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_3(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get rootHash() {
+        const ret = wasm.verifiedtokendirectpurchaseprices_root_hash(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {Array<any> | undefined}
+     */
+    get prices() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.verifiedtokendirectpurchaseprices_prices(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+
 const VerifiedTokenTotalSupplyWASMFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_verifiedtokentotalsupplywasm_free(ptr >>> 0, 1));