pshenmic-dpp 1.0.4 → 1.0.6

package/tests/PublicKeyInCreation.spec.js

@@ -0,0 +1,258 @@
+const assert = require('assert')
+const { describe, it, before } = require('mocha')
+const initWasm = require('./utils/wasm')
+
+let wasm
+
+describe('InstantLock', function () {
+  before(async function () {
+    wasm = initWasm()
+  })
+
+  describe('serialization / deserialization', function () {
+    it('should allow to create from values', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      assert.notEqual(publicKeyInCreation.__wbg_ptr, 0)
+    })
+
+    it('should allow to create from values and convert to identity public key', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      const publicKey = publicKeyInCreation.toIdentityPublicKey()
+
+      assert.notEqual(publicKeyInCreation.__wbg_ptr, 0)
+      assert.equal(publicKey.constructor.name, 'IdentityPublicKeyWASM')
+    })
+  })
+
+  describe('getters', function () {
+    it('should allow to get key id', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      assert.equal(publicKeyInCreation.keyId, 0)
+    })
+
+    it('should allow to get purpose', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      assert.equal(publicKeyInCreation.purpose, 'AUTHENTICATION')
+    })
+
+    it('should allow to get security level', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      assert.equal(publicKeyInCreation.securityLevel, 'MASTER')
+    })
+
+    it('should allow to get key type', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      assert.equal(publicKeyInCreation.keyType, 'ECDSA_SECP256K1')
+    })
+
+    it('should allow to get read only', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      assert.equal(publicKeyInCreation.readOnly, false)
+    })
+
+    it('should allow to get data', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      assert.deepEqual(Buffer.from(publicKeyInCreation.data), Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'))
+    })
+
+    it('should allow to get signature', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      assert.deepEqual([...publicKeyInCreation.signature], [])
+    })
+  })
+
+  describe('setters', function () {
+    it('should allow to set key id', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      publicKeyInCreation.keyId = 123
+
+      assert.equal(publicKeyInCreation.keyId, 123)
+    })
+
+    it('should allow to set purpose', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      publicKeyInCreation.purpose = 'OWNER'
+
+      assert.equal(publicKeyInCreation.purpose, 'OWNER')
+    })
+
+    it('should allow to set security level', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      publicKeyInCreation.securityLevel = 'critical'
+
+      assert.equal(publicKeyInCreation.securityLevel, 'CRITICAL')
+    })
+
+    it('should allow to set key type', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      publicKeyInCreation.keyType = 'ECDSA_HASH160'
+
+      assert.equal(publicKeyInCreation.keyType, 'ECDSA_HASH160')
+    })
+
+    it('should allow to set read only', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      publicKeyInCreation.readOnly = true
+
+      assert.equal(publicKeyInCreation.readOnly, true)
+    })
+
+    it('should allow to set data', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      publicKeyInCreation.data = Buffer.from('333333333334001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex')
+
+      assert.deepEqual(Buffer.from(publicKeyInCreation.data), Buffer.from('333333333334001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'))
+    })
+
+    it('should allow to set signature', () => {
+      const publicKeyInCreation = new wasm.IdentityPublicKeyInCreationWASM(
+        0,
+        'AUTHENTICATION',
+        'master',
+        'ECDSA_SECP256K1',
+        false,
+        Buffer.from('0333d5cf3674001d2f64c55617b7b11a2e8fc62aab09708b49355e30c7205bdb2e', 'hex'),
+        []
+      )
+
+      publicKeyInCreation.signature = [1, 2, 3, 4, 5, 6]
+
+      assert.deepEqual([...publicKeyInCreation.signature], [1, 2, 3, 4, 5, 6])
+    })
+  })
+})

package/tests/TxOut.spec.js

@@ -0,0 +1,76 @@
+const assert = require('assert')
+const { describe, it, before } = require('mocha')
+const initWasm = require('./utils/wasm')
+
+let wasm
+
+describe('TxOut', function () {
+  before(async function () {
+    wasm = initWasm()
+  })
+
+  describe('serialization / deserialization', function () {
+    it('should allow to create from values with pubkey hex', function () {
+      const out = new wasm.TxOutWASM(BigInt(100), '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+      assert.notEqual(out.__wbg_ptr, 0)
+    })
+
+    it('should allow to create from values with pubkey array', function () {
+      const out = new wasm.TxOutWASM(BigInt(100), Array.from(Buffer.from('76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac', 'hex')))
+
+      assert.notEqual(out.__wbg_ptr, 0)
+    })
+  })
+
+  describe('getters', function () {
+    it('should allow to get value', function () {
+      const out = new wasm.TxOutWASM(BigInt(100), '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+
+      assert.equal(out.value, BigInt(100))
+    })
+
+    it('should allow to get script hex', function () {
+      const out = new wasm.TxOutWASM(BigInt(100), '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+
+      assert.equal(out.scriptPubKeyHex, '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+    })
+
+    it('should allow to get script bytes', function () {
+      const out = new wasm.TxOutWASM(BigInt(100), '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+
+      assert.deepEqual(out.scriptPubKeyBytes, Uint8Array.from(Buffer.from('76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac', 'hex')))
+    })
+
+    it('should allow to get script asm', function () {
+      const out = new wasm.TxOutWASM(BigInt(100), '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+
+      assert.deepEqual(out.getScriptPubKeyASM(), 'OP_DUP OP_HASH160 OP_PUSHBYTES_20 1a486a3855e6dc6dd02874424f53a6f2197b3d45 OP_EQUALVERIFY OP_CHECKSIG')
+    })
+  })
+
+  describe('setters', function () {
+    it('should allow to set value', function () {
+      const out = new wasm.TxOutWASM(BigInt(100), '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+
+      out.value = BigInt(101)
+
+      assert.equal(out.value, BigInt(101))
+    })
+
+    it('should allow to set script hex', function () {
+      const out = new wasm.TxOutWASM(BigInt(100), '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+
+      out.scriptPubKeyHex = '16a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac'
+
+      assert.equal(out.scriptPubKeyHex, '16a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+    })
+
+    it('should allow to set script bytes', function () {
+      const out = new wasm.TxOutWASM(BigInt(100), '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+
+      out.scriptPubKeyBytes = Array.from(Buffer.from('76a914f995e42d1aa7a31b0106b63e1b896fe9aeeccc9988ac', 'hex'))
+
+      assert.deepEqual(out.scriptPubKeyBytes, Uint8Array.from(Buffer.from('76a914f995e42d1aa7a31b0106b63e1b896fe9aeeccc9988ac', 'hex')))
+    })
+  })
+})

package/tests/mocks/DataContract/DataContract.json

@@ -0,0 +1,153 @@
+{
+  "$format_version": "0",
+  "id": "4fJLR2GYTPFdomuTVvNy3VRrvWgvkKPzqehEBpNf2nk6",
+  "config": {
+    "$format_version": "0",
+    "canBeDeleted": false,
+    "readonly": false,
+    "keepsHistory": false,
+    "documentsKeepHistoryContractDefault": false,
+    "documentsMutableContractDefault": true,
+    "documentsCanBeDeletedContractDefault": true,
+    "requiresIdentityEncryptionBoundedKey": null,
+    "requiresIdentityDecryptionBoundedKey": null
+  },
+  "version": 1,
+  "ownerId": "11111111111111111111111111111111",
+  "schemaDefs": null,
+  "documentSchemas": {
+    "withdrawal": {
+      "description": "Withdrawal document to track underlying withdrawal transactions. Withdrawals should be created with IdentityWithdrawalTransition",
+      "creationRestrictionMode": 2,
+      "type": "object",
+      "indices": [
+        {
+          "name": "identityStatus",
+          "properties": [
+            {
+              "$ownerId": "asc"
+            },
+            {
+              "status": "asc"
+            },
+            {
+              "$createdAt": "asc"
+            }
+          ],
+          "unique": false
+        },
+        {
+          "name": "identityRecent",
+          "properties": [
+            {
+              "$ownerId": "asc"
+            },
+            {
+              "$updatedAt": "asc"
+            },
+            {
+              "status": "asc"
+            }
+          ],
+          "unique": false
+        },
+        {
+          "name": "pooling",
+          "properties": [
+            {
+              "status": "asc"
+            },
+            {
+              "pooling": "asc"
+            },
+            {
+              "coreFeePerByte": "asc"
+            },
+            {
+              "$updatedAt": "asc"
+            }
+          ],
+          "unique": false
+        },
+        {
+          "name": "transaction",
+          "properties": [
+            {
+              "status": "asc"
+            },
+            {
+              "transactionIndex": "asc"
+            }
+          ],
+          "unique": false
+        }
+      ],
+      "properties": {
+        "transactionIndex": {
+          "type": "integer",
+          "description": "Sequential index of asset unlock (withdrawal) transaction. Populated when a withdrawal pooled into withdrawal transaction",
+          "minimum": 1,
+          "position": 0
+        },
+        "transactionSignHeight": {
+          "type": "integer",
+          "description": "The Core height on which transaction was signed",
+          "minimum": 1,
+          "position": 1
+        },
+        "amount": {
+          "type": "integer",
+          "description": "The amount to be withdrawn",
+          "minimum": 1000,
+          "position": 2
+        },
+        "coreFeePerByte": {
+          "type": "integer",
+          "description": "This is the fee that you are willing to spend for this transaction in Duffs/Byte",
+          "minimum": 1,
+          "maximum": 4294967295,
+          "position": 3
+        },
+        "pooling": {
+          "type": "integer",
+          "description": "This indicated the level at which Platform should try to pool this transaction",
+          "enum": [
+            0,
+            1,
+            2
+          ],
+          "position": 4
+        },
+        "outputScript": {
+          "type": "array",
+          "byteArray": true,
+          "minItems": 23,
+          "maxItems": 25,
+          "position": 5
+        },
+        "status": {
+          "type": "integer",
+          "enum": [
+            0,
+            1,
+            2,
+            3,
+            4
+          ],
+          "description": "0 - Pending, 1 - Signed, 2 - Broadcasted, 3 - Complete, 4 - Expired",
+          "position": 6
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "$createdAt",
+        "$updatedAt",
+        "amount",
+        "coreFeePerByte",
+        "pooling",
+        "outputScript",
+        "status"
+      ]
+    }
+  }
+}

package/tests/mocks/DataContract/index.js

@@ -0,0 +1,6 @@
+module.exports = {
+  value: require('./DataContract.json'),
+  id: '4fJLR2GYTPFdomuTVvNy3VRrvWgvkKPzqehEBpNf2nk6',
+  ownerId: '11111111111111111111111111111111',
+  dataContractsBytes: ['00ea8920edea52fa400de2ccc43052b2821f45585241a2875d4250e35d4ce937c800000000000101000001ab321b19457b1c16b12762509276d47d952f582d978cbd8b50bbfc2fd8a7767d0001046e6f7465160312047479706512066f626a656374120a70726f70657274696573160112076d65737361676516021204747970651206737472696e671208706f736974696f6e030012146164646974696f6e616c50726f706572746965731300']
+}

package/tests/mocks/Document/DataContract.json

@@ -0,0 +1,23 @@
+{
+  "$format_version": "0",
+  "version": 1,
+  "ownerId": "11111111111111111111111111111111",
+  "schemaDefs": null,
+  "id": "4fJLR2GYTPFdomuTVvNy3VRrvWgvkKPzqehEBpNf2nk6",
+  "documentSchemas": {
+    "note": {
+      "type": "object",
+      "properties": {
+        "author": {
+          "type": "string",
+          "position": 1
+        },
+        "message": {
+          "type": "string",
+          "position": 0
+        }
+      },
+      "additionalProperties": false
+    }
+  }
+}

package/tests/mocks/Document/document.json

@@ -0,0 +1,3 @@
+{
+  "message": "Tutorial CI Test @ Tue, 07 Jan 2025 15:27:50 GMT"
+}

package/tests/mocks/Document/document2.json

@@ -0,0 +1,3 @@
+{
+  "message": "bb"
+}

package/tests/mocks/Document/index.js

@@ -0,0 +1,11 @@
+module.exports = {
+  document: require('./document.json'),
+  document2: require('./document2.json'),
+  dataContractValue: require('./DataContract.json'),
+  documentTypeName: 'note',
+  revision: BigInt(1),
+  dataContractId: 'GnXgMaiqAwTxh44ccQe8AoCgFvcseHK5CncH3sUorW4X',
+  ownerId: 'CXH2kZCATjvDTnQAPVg28EgPg9WySUvwvnR5ZkmNqY5i',
+  id: '9tSsCqKHTZ8ro16MydChSxgHBukFW36eMLJKKRtebJEn',
+  documentBytes: '00840b5cec9f0401b1950610e85dcb26829122ac8853464e1e2c7e38ed22b48903ab321b19457b1c16b12762509276d47d952f582d978cbd8b50bbfc2fd8a7767d01000001305475746f7269616c20434920546573742040205475652c203037204a616e20323032352031353a32373a353020474d5400'
+}

package/tests/mocks/Identity/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+  identifier: 'H2pb35GtKpjLinncBYeMsXkdDYXCbsFzzVmssce6pSJ1',
+  identifierBytes: [238, 50, 96, 211, 63, 140, 169, 225, 76, 97, 8, 6, 212, 109, 184, 253, 51, 67, 82, 42, 208, 228, 72, 192, 215, 137, 161, 88, 144, 55, 244, 230],
+  balance: BigInt(100),
+  revision: BigInt(99111),
+  identityBytesWithoutKeys: [0, 238, 50, 96, 211, 63, 140, 169, 225, 76, 97, 8, 6, 212, 109, 184, 253, 51, 67, 82, 42, 208, 228, 72, 192, 215, 137, 161, 88, 144, 55, 244, 230, 0, 0, 0]
+}

package/tests/mocks/Locks/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  instantLockBytes: [1, 1, 89, 68, 206, 254, 139, 111, 183, 115, 169, 122, 19, 26, 29, 175, 97, 14, 156, 207, 215, 16, 92, 152, 110, 29, 167, 34, 91, 149, 243, 48, 250, 217, 0, 0, 0, 0, 61, 111, 50, 237, 225, 255, 25, 159, 133, 89, 244, 234, 150, 19, 61, 198, 218, 144, 144, 44, 45, 189, 109, 187, 247, 117, 93, 95, 156, 46, 12, 216, 1, 49, 33, 55, 67, 236, 100, 131, 20, 54, 98, 71, 159, 60, 21, 2, 116, 197, 18, 154, 171, 227, 15, 30, 21, 0, 0, 0, 0, 0, 0, 0, 169, 241, 49, 98, 108, 73, 162, 241, 131, 183, 162, 245, 99, 173, 29, 197, 10, 200, 34, 1, 144, 219, 237, 184, 5, 32, 155, 96, 142, 184, 100, 224, 29, 98, 241, 139, 201, 250, 166, 10, 139, 138, 39, 245, 160, 199, 200, 185, 20, 250, 58, 20, 54, 10, 47, 37, 85, 142, 224, 224, 166, 147, 177, 143, 172, 203, 181, 158, 195, 155, 155, 60, 174, 67, 14, 11, 118, 235, 8, 7, 82, 206, 16, 61, 247, 101, 55, 161, 165, 131, 104, 10, 89, 20, 82, 157],
+  transactionBytes: [3, 0, 8, 0, 1, 89, 68, 206, 254, 139, 111, 183, 115, 169, 122, 19, 26, 29, 175, 97, 14, 156, 207, 215, 16, 92, 152, 110, 29, 167, 34, 91, 149, 243, 48, 250, 217, 0, 0, 0, 0, 107, 72, 48, 69, 2, 33, 0, 157, 215, 234, 11, 75, 36, 23, 153, 82, 143, 163, 76, 75, 118, 142, 19, 6, 13, 64, 50, 24, 199, 141, 199, 163, 14, 86, 81, 67, 150, 240, 28, 2, 32, 105, 238, 106, 123, 228, 237, 166, 210, 251, 103, 249, 36, 15, 233, 177, 30, 40, 125, 67, 108, 224, 183, 4, 5, 18, 239, 231, 185, 223, 195, 92, 240, 1, 33, 3, 238, 76, 67, 141, 205, 25, 38, 200, 164, 105, 53, 55, 189, 36, 52, 232, 121, 166, 108, 186, 227, 161, 55, 7, 105, 135, 102, 219, 224, 117, 213, 70, 255, 255, 255, 255, 2, 128, 29, 44, 4, 0, 0, 0, 0, 2, 106, 0, 48, 232, 38, 1, 0, 0, 0, 0, 25, 118, 169, 20, 232, 101, 217, 39, 144, 120, 74, 135, 230, 203, 134, 239, 207, 15, 238, 152, 16, 172, 45, 177, 136, 172, 0, 0, 0, 0, 36, 1, 1, 128, 29, 44, 4, 0, 0, 0, 0, 25, 118, 169, 20, 12, 182, 70, 130, 142, 161, 106, 83, 94, 200, 33, 4, 251, 5, 50, 93, 28, 107, 159, 168, 136, 172]
+
+}

package/tests/mocks/PrivateKey/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  wif: 'cR4EZ2nAvCmn2cFepKn7UgSSQFgFTjkySAchvcoiEVdm48eWjQGn',
+  bytes: '67ad1669d882da256b6fa05e1b0ae384a6ac8aed146ea53602b8ff0e1e9c18e9',
+  publicKeyHash: '622fd260c35f0d826d05983d1f0524b02dec27a0'
+}

package/tests/mocks/PublicKey/index.js

@@ -0,0 +1,14 @@
+const { Purpose, SecurityLevel, KeyType } = require('../../../dist/cjs/wasm/pshenmic_dpp')
+
+module.exports = {
+  keyId: 2,
+  purpose: 'AUTHENTICATION',
+  securityLevel: SecurityLevel.CRITICAL,
+  keyType: KeyType.ECDSA_SECP256K1,
+  binaryData: '036a394312e40e81d928fde2bde7880070e4fa9c1d1d9b168da707ea468afa2b48',
+  keyIdSet: 3,
+  purposeSet: Purpose.ENCRYPTION,
+  securityLevelSet: SecurityLevel.HIGH,
+  keyTypeSet: KeyType.ECDSA_HASH160,
+  binaryDataSet: '0300000002e40e81d928fde2bde7880070e4fa9c1d1d9b168da707ea468afa2b48'
+}

package/tests/utils/hex.js

@@ -0,0 +1,15 @@
+module.exports = {
+  toHexString: (byteArray) => {
+    return Array.prototype.map.call(byteArray, function (byte) {
+      return ('0' + (byte & 0xFF).toString(16)).slice(-2)
+    }).join('')
+  },
+  fromHexString: (str) => {
+    const bytes = []
+    for (let i = 0; i < str.length; i += 2) {
+      bytes.push(parseInt(str.slice(i, i + 2), 16))
+    }
+
+    return Uint8Array.from(bytes)
+  }
+}

package/tests/utils/wasm.js

@@ -0,0 +1,14 @@
+const wasm = require('../../dist/cjs/wasm/pshenmic_dpp')
+const { default: wasmBytes } = require('../../dist/cjs/wasm/pshenmic_dpp_bg')
+
+module.exports = () => {
+  const binaryString = atob(wasmBytes)
+  const bytes = new Uint8Array(binaryString.length)
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i)
+  }
+
+  wasm.initSync({ module: bytes.buffer })
+
+  return wasm
+}

package/typings/index.d.ts

@@ -0,0 +1,52 @@
+import * as DPP from './pshenmic_dpp';
+
+export * from './pshenmic_dpp';
+
+export class DashPlatformProtocolWASM {
+    // CLASSES
+    AssetLockProofWASM: typeof DPP.AssetLockProofWASM
+    ChainAssetLockProofWASM: typeof DPP.ChainAssetLockProofWASM
+    CoreScriptWASM: typeof DPP.CoreScriptWASM
+    DataContractCreateTransitionWASM: typeof DPP.DataContractCreateTransitionWASM
+    DataContractUpdateTransitionWASM: typeof DPP.DataContractUpdateTransitionWASM
+    DataContractWASM: typeof DPP.DataContractWASM
+    DocumentBaseTransitionWASM: typeof DPP.DocumentBaseTransitionWASM
+    DocumentCreateTransitionWASM: typeof DPP.DocumentCreateTransitionWASM
+    DocumentDeleteTransitionWASM: typeof DPP.DocumentDeleteTransitionWASM
+    DocumentPurchaseTransitionWASM: typeof DPP.DocumentPurchaseTransitionWASM
+    DocumentReplaceTransitionWASM: typeof DPP.DocumentReplaceTransitionWASM
+    DocumentTransferTransitionWASM: typeof DPP.DocumentTransferTransitionWASM
+    DocumentTransitionWASM: typeof DPP.DocumentTransitionWASM
+    DocumentUpdatePriceTransitionWASM: typeof DPP.DocumentUpdatePriceTransitionWASM
+    DocumentWASM: typeof DPP.DocumentWASM
+    DocumentsBatchWASM: typeof DPP.DocumentsBatchWASM
+    IdentifierWASM: typeof DPP.IdentifierWASM
+    IdentityCreateTransitionWASM: typeof DPP.IdentityCreateTransitionWASM
+    IdentityCreditTransferWASM: typeof DPP.IdentityCreditTransferWASM
+    IdentityCreditWithdrawalTransitionWASM: typeof DPP.IdentityCreditWithdrawalTransitionWASM
+    IdentityPublicKeyInCreationWASM: typeof DPP.IdentityPublicKeyInCreationWASM
+    IdentityPublicKeyWASM: typeof DPP.IdentityPublicKeyWASM
+    IdentityTopUpTransitionWASM: typeof DPP.IdentityTopUpTransitionWASM
+    IdentityUpdateTransitionWASM: typeof DPP.IdentityUpdateTransitionWASM
+    IdentityWASM: typeof DPP.IdentityWASM
+    InstantAssetLockProofWASM: typeof DPP.InstantAssetLockProofWASM
+    InstantLockWASM: typeof DPP.InstantLockWASM
+    OutPointWASM: typeof DPP.OutPointWASM
+    PrefundedVotingBalanceWASM: typeof DPP.PrefundedVotingBalanceWASM
+    PrivateKeyWASM: typeof DPP.PrivateKeyWASM
+    StateTransitionWASM: typeof DPP.StateTransitionWASM
+    TxOutWASM: typeof DPP.TxOutWASM
+    // ENUMS
+    AssetLockProofTypeWASM: typeof DPP.AssetLockProofTypeWASM
+    BatchType: typeof DPP.BatchType
+    KeyType: typeof DPP.KeyType
+    NetworkWASM: typeof DPP.NetworkWASM
+    PlatformVersionWASM: typeof DPP.PlatformVersionWASM
+    PoolingWASM: typeof DPP.PoolingWASM
+    Purpose: typeof DPP.Purpose
+    SecurityLevel: typeof DPP.SecurityLevel
+    // METHODS
+    cborToObject: typeof DPP.cborToObject
+    objectToCbor: typeof DPP.objectToCbor
+    initSync: typeof DPP.initSync
+}