pshenmic-dpp 1.0.4 → 1.0.5

package/tests/Identity.spec.js

@@ -0,0 +1,113 @@
+const assert = require('assert')
+const { describe, it, before } = require('mocha')
+const initWasm = require('./utils/wasm')
+const { identifier, identityBytesWithoutKeys, identifierBytes, balance, revision } = require('./mocks/Identity')
+const { keyId, purpose, securityLevel, keyType, binaryData } = require('./mocks/PublicKey')
+
+let wasm
+
+describe('Identity', function () {
+  before(async function () {
+    wasm = initWasm()
+  })
+
+  describe('serialization / deserialization', function () {
+    it('should generate identity from identifier', async function () {
+      const identity = new wasm.IdentityWASM(identifier)
+
+      assert.notEqual(identity.__wbg_ptr, 0)
+    })
+
+    it('should generate identity from identifier and return bytes', async function () {
+      const identity = new wasm.IdentityWASM(identifier)
+
+      assert.deepEqual(Array.from(identity.toBytes()), identityBytesWithoutKeys)
+
+      const newIdentity = wasm.IdentityWASM.fromBytes(identity.toBytes())
+
+      assert.notEqual(identity.__wbg_ptr, 0)
+      assert.notEqual(newIdentity.__wbg_ptr, 0)
+    })
+  })
+
+  describe('getters', function () {
+    it('should get id buffer', function () {
+      const identity = new wasm.IdentityWASM(identifier)
+
+      assert.deepEqual(Array.from(identity.getId()), identifierBytes)
+    })
+
+    it('should get balance', function () {
+      const identity = new wasm.IdentityWASM(identifier)
+
+      assert.deepEqual(identity.getBalance(), BigInt(0))
+    })
+
+    it('should get revision', function () {
+      const identity = new wasm.IdentityWASM(identifier)
+
+      assert.deepEqual(identity.getRevision(), BigInt(0))
+    })
+
+    it('should get public keys', function () {
+      const identity = new wasm.IdentityWASM(identifier)
+
+      const pubKey = new wasm.IdentityPublicKeyWASM(
+        keyId,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      const pubKey2 = new wasm.IdentityPublicKeyWASM(
+        keyId + 1,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      identity.addPublicKey(pubKey)
+      identity.addPublicKey(pubKey2)
+
+      assert.equal(identity.getPublicKeys().length, 2)
+    })
+  })
+
+  describe('setters', function () {
+    it('should allows to set public key', function () {
+      const pubKey = new wasm.IdentityPublicKeyWASM(
+        keyId,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      const identity = new wasm.IdentityWASM(identifier)
+
+      identity.addPublicKey(pubKey)
+
+      assert.notEqual(identity.__wbg_ptr, 0)
+
+      assert.deepEqual(identity.getPublicKeyById(keyId).toBytes(), pubKey.toBytes())
+    })
+
+    it('should allows to set balance', function () {
+      const identity = new wasm.IdentityWASM(identifier)
+
+      identity.setBalance(balance)
+
+      assert.equal(identity.getBalance(), balance)
+    })
+
+    it('should allows to set revision', function () {
+      const identity = new wasm.IdentityWASM(identifier)
+
+      identity.setRevision(revision)
+
+      assert.equal(identity.getRevision(), revision)
+    })
+  })
+})

package/tests/IdentityPublicKey.spec.js

@@ -0,0 +1,132 @@
+const assert = require('assert')
+const { describe, it, before } = require('mocha')
+const initWasm = require('./utils/wasm')
+const {
+  keyId, purpose, securityLevel, keyType, binaryData, securityLevelSet, keyIdSet, purposeSet,
+  keyTypeSet, binaryDataSet
+} = require('./mocks/PublicKey')
+const { wif } = require('./mocks/PrivateKey')
+const { toHexString } = require('./utils/hex')
+
+let wasm
+
+describe('PublicKey', function () {
+  before(async function () {
+    wasm = initWasm()
+  })
+
+  describe('serialization / deserialization', function () {
+    it('should generate public key from values with type ECDSA_SECP256K1', function () {
+      const pubKey = new wasm.IdentityPublicKeyWASM(
+        keyId,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      assert.notEqual(pubKey.__wbg_ptr, 0)
+    })
+
+    it('should generate public key from values with type ECDSA_SECP256K1 and generate new from self bytes', function () {
+      const pubKey = new wasm.IdentityPublicKeyWASM(
+        keyId,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      const bytes = pubKey.toBytes()
+
+      const newPubKey = wasm.IdentityPublicKeyWASM.fromBytes(Array.from(bytes))
+
+      assert.notEqual(pubKey.__wbg_ptr, 0)
+      assert.notEqual(newPubKey.__wbg_ptr, 0)
+
+      assert.equal(pubKey.getKeyId(), newPubKey.getKeyId())
+      assert.equal(pubKey.getPurpose(), newPubKey.getPurpose())
+      assert.equal(pubKey.getSecurityLevel(), newPubKey.getSecurityLevel())
+      assert.equal(pubKey.getKeyType(), newPubKey.getKeyType())
+      assert.equal(pubKey.getReadOnly(), newPubKey.getReadOnly())
+      assert.equal(pubKey.getData(), newPubKey.getData())
+
+      assert.deepEqual(pubKey.toBytes(), newPubKey.toBytes())
+
+      assert.notEqual(pubKey.__wbg_ptr, 0)
+      assert.notEqual(newPubKey.__wbg_ptr, 0)
+    })
+
+    it('should return hash of key', function () {
+      const pubKey = new wasm.IdentityPublicKeyWASM(
+        keyId,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      const hash = pubKey.getPublicKeyHash()
+
+      assert.deepEqual(hash, toHexString([211, 114, 240, 150, 37, 159, 114, 104, 110, 24, 102, 61, 125, 181, 248, 98, 52, 221, 111, 85]))
+    })
+  })
+  describe('getters', function () {
+    it('should generate public key from values with type ECDSA_SECP256K1 and return all fields', function () {
+      const pubKey = new wasm.IdentityPublicKeyWASM(
+        keyId,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      assert.equal(pubKey.getKeyId(), keyId)
+      assert.equal(pubKey.getPurpose(), 'AUTHENTICATION')
+      assert.equal(pubKey.getSecurityLevel(), 'CRITICAL')
+      assert.equal(pubKey.getKeyType(), 'ECDSA_SECP256K1')
+      assert.equal(pubKey.getReadOnly(), false)
+      assert.equal(pubKey.getData(), binaryData)
+    })
+
+    it('should allow to validate private key', function () {
+      const pubKey = new wasm.IdentityPublicKeyWASM(
+        keyId,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      const privateKey = wasm.PrivateKeyWASM.fromWIF(wif)
+
+      assert.equal(pubKey.validatePrivateKey(privateKey.getBytes(), wasm.NetworkWASM.Mainnet), false)
+    })
+  })
+
+  describe('setters', function () {
+    it('should generate public key from values with type ECDSA_SECP256K1 and return all fields and set another fields', function () {
+      const pubKey = new wasm.IdentityPublicKeyWASM(
+        keyId,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      pubKey.setKeyId(keyIdSet)
+      pubKey.setPurpose(purposeSet)
+      pubKey.setSecurityLevel(securityLevelSet)
+      pubKey.setKeyType(keyTypeSet)
+      pubKey.setReadOnly(true)
+      pubKey.setData(binaryDataSet)
+
+      assert.equal(pubKey.getKeyId(), keyIdSet)
+      assert.equal(pubKey.getPurpose(), 'ENCRYPTION')
+      assert.equal(pubKey.getSecurityLevel(), 'HIGH')
+      assert.equal(pubKey.getKeyType(), 'ECDSA_HASH160')
+      assert.equal(pubKey.getReadOnly(), true)
+      assert.equal(pubKey.getData(), binaryDataSet)
+    })
+  })
+})

package/tests/PrivateKey.spec.js

@@ -0,0 +1,73 @@
+const assert = require('assert')
+const { describe, it, before } = require('mocha')
+const initWasm = require('./utils/wasm')
+const { wif, bytes, publicKeyHash } = require('./mocks/PrivateKey')
+const { fromHexString, toHexString } = require('./utils/hex')
+
+let wasm
+
+describe('PrivateKey', function () {
+  before(async function () {
+    wasm = initWasm()
+  })
+
+  describe('serialization / deserialization', function () {
+    it('should allows to create PrivateKey from wif', function () {
+      const pkey = wasm.PrivateKeyWASM.fromWIF(wif)
+
+      assert.notEqual(pkey.__wbg_ptr, 0)
+    })
+
+    it('should allows to create PrivateKey from bytes', function () {
+      const pkey = wasm.PrivateKeyWASM.fromBytes(fromHexString(bytes), 'Mainnet')
+
+      assert.notEqual(pkey.__wbg_ptr, 0)
+    })
+
+    it('should allows to create PrivateKey from hex', function () {
+      const pkey = wasm.PrivateKeyWASM.fromBytes(fromHexString(bytes), 'Mainnet')
+
+      const pkeyFromHex = wasm.PrivateKeyWASM.fromHex(bytes, 'Mainnet')
+
+      assert.deepEqual(pkey.getBytes(), pkeyFromHex.getBytes())
+    })
+
+    it('should allow to create PrivateKey from wif and read value in wif', function () {
+      const pkey = wasm.PrivateKeyWASM.fromWIF(wif)
+
+      assert.equal(pkey.getWIF(), wif)
+    })
+
+    it('should allow to create PrivateKey from wif and write value in bytes', function () {
+      const pkey = wasm.PrivateKeyWASM.fromWIF(wif)
+
+      assert.deepEqual(pkey.getBytes(), fromHexString(bytes))
+    })
+  })
+
+  describe('getters', function () {
+    it('should allow to get key wif', function () {
+      const pkey = wasm.PrivateKeyWASM.fromWIF(wif)
+
+      assert.equal(pkey.getWIF(), wif)
+    })
+
+    it('should allow to get key bytes', function () {
+      const pkey = wasm.PrivateKeyWASM.fromWIF(wif)
+
+      assert.equal(toHexString(pkey.getBytes()), bytes)
+    })
+
+    it('should allow to get key hex', function () {
+      const pkey = wasm.PrivateKeyWASM.fromWIF(wif)
+
+      assert.equal(pkey.getHex().toLowerCase(), bytes)
+    })
+
+    it('should allow to get public key hash', function () {
+      const pkey = wasm.PrivateKeyWASM.fromWIF(wif)
+
+      assert.deepEqual(pkey.getPublicKeyHash(), publicKeyHash)
+    })
+  })
+})

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/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: 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
+}