pshenmic-dpp 1.1.0-dev.3 → 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;
 

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