pshenmic-dpp 1.0.5 → 1.0.6

package/tests/IdentityUpdateTransition.spec.js

@@ -0,0 +1,147 @@
+const assert = require('assert')
+const { describe, it, before } = require('mocha')
+const initWasm = require('./utils/wasm')
+
+let wasm
+
+describe('IdentityUpdateTransition', function () {
+  before(async function () {
+    wasm = initWasm()
+  })
+
+  describe('serialization / deserialization', function () {
+    it('Should create IdentityUpdateTransition', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [])
+
+      assert.notEqual(transition.__wbg_ptr, 0)
+    })
+
+    it('Should create IdentityUpdateTransition with key', function () {
+      const key = new wasm.IdentityPublicKeyInCreationWASM(
+        1, 'system', 'master', 'ECDSA_SECP256K1', false, [], []
+      )
+
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [key], [])
+
+      assert.notEqual(transition.__wbg_ptr, 0)
+      assert.notEqual(key.__wbg_ptr, 0)
+    })
+  })
+
+  describe('getters', function () {
+    it('Should return revision', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [])
+
+      assert.deepEqual(transition.revision, BigInt(1))
+    })
+
+    it('Should return nonce', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [])
+
+      assert.deepEqual(transition.nonce, BigInt(1))
+    })
+
+    it('Should return identityIdentifier', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [])
+
+      assert.deepEqual(transition.identityIdentifier.base58(), 'GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3')
+    })
+
+    it('Should return publicKeyIdsToDisable', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [11])
+
+      assert.deepEqual(Array.from(transition.publicKeyIdsToDisable), [11])
+    })
+
+    it('Should return publicKeyIdsToAdd', function () {
+      const key = new wasm.IdentityPublicKeyInCreationWASM(
+        1, 'system', 'master', 'ECDSA_SECP256K1', false, [], []
+      )
+
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [key], [11])
+
+      assert.deepEqual(transition.publicKeyIdsToAdd.length, 1)
+    })
+
+    it('Should return userFeeIncrease', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [11])
+
+      assert.deepEqual(transition.userFeeIncrease, 1)
+    })
+
+    it('Should return signature', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [11])
+
+      assert.deepEqual(transition.signature, Uint8Array.from([]))
+    })
+
+    it('Should return signature public key id', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [11])
+
+      assert.deepEqual(transition.signaturePublicKeyId, 0)
+    })
+  })
+
+  describe('setters', function () {
+    it('Should allow to set identityIdentifier', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [11])
+
+      transition.identityIdentifier = '11Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3'
+
+      assert.deepEqual(transition.identityIdentifier.base58(), '11Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3')
+    })
+
+    it('Should allow to set revision', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [11])
+
+      transition.revision = BigInt(11111)
+
+      assert.deepEqual(transition.revision, BigInt(11111))
+    })
+
+    it('Should allow to set nonce', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [11])
+
+      transition.nonce = BigInt(11111)
+
+      assert.deepEqual(transition.nonce, BigInt(11111))
+    })
+
+    it('Should allow to set publicKeyIdsToDisable', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [11])
+
+      transition.publicKeyIdsToDisable = [1, 2, 3, 4]
+
+      assert.deepEqual(transition.publicKeyIdsToDisable, Uint32Array.from([1, 2, 3, 4]))
+    })
+
+    it('Should allow to set publicKeyIdsToAdd', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [11])
+
+      const key = new wasm.IdentityPublicKeyInCreationWASM(
+        1, 'system', 'master', 'ECDSA_SECP256K1', false, [], []
+      )
+
+      transition.publicKeyIdsToAdd = [key, key]
+
+      assert.deepEqual(transition.publicKeyIdsToAdd.length, 2)
+      assert.notEqual(key.__wbg_ptr, 0)
+    })
+
+    it('Should allow to set signature', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [11])
+
+      transition.signature = [0, 1, 2, 3, 5]
+
+      assert.deepEqual(transition.signature, Uint8Array.from([0, 1, 2, 3, 5]))
+    })
+
+    it('Should allow to set signature public key id', function () {
+      const transition = new wasm.IdentityUpdateTransitionWASM('GL2Rq8L3VuBEQfCAZykmUaiXXrsd1Bwub2gcaMmtNbn3', BigInt(1), BigInt(1), 1, [], [11])
+
+      transition.signaturePublicKeyId = 11
+
+      assert.deepEqual(transition.signaturePublicKeyId, 11)
+    })
+  })
+})

package/tests/InstantLockProof.spec.js

@@ -0,0 +1,97 @@
+const assert = require('assert')
+const { describe, it, before } = require('mocha')
+const initWasm = require('./utils/wasm')
+const { instantLockBytes, transactionBytes } = require('./mocks/Locks')
+
+let wasm
+
+describe('InstantLock', function () {
+  before(async function () {
+    wasm = initWasm()
+  })
+
+  describe('serialization / deserialization', function () {
+    it('should allow to create InstantLock from values', () => {
+      const instantLockProof = new wasm.InstantAssetLockProofWASM(instantLockBytes, transactionBytes, 0)
+
+      assert.notEqual(instantLockProof.__wbg_ptr, 0)
+    })
+
+    it('should allow to convert to object', () => {
+      const instantLockProof = new wasm.InstantAssetLockProofWASM(instantLockBytes, transactionBytes, 0)
+
+      const expected = {
+        instantLock: instantLockBytes,
+        transaction: transactionBytes,
+        outputIndex: 0
+      }
+
+      assert.deepEqual(instantLockProof.toObject(), expected)
+    })
+
+    it('should allow to create from object', () => {
+      const lockObject = {
+        instantLock: instantLockBytes,
+        transaction: transactionBytes,
+        outputIndex: 0
+      }
+
+      const instantLockProof = wasm.InstantAssetLockProofWASM.fromObject(lockObject)
+
+      assert.notEqual(instantLockProof.__wbg_ptr, 0)
+    })
+  })
+
+  describe('getters', function () {
+    it('should allow to get output', () => {
+      const instantLockProof = new wasm.InstantAssetLockProofWASM(instantLockBytes, transactionBytes, 0)
+
+      assert.deepEqual(instantLockProof.getOutput().constructor.name, 'TxOutWASM')
+    })
+
+    it('should allow to convert to get OutPoint', () => {
+      const instantLockProof = new wasm.InstantAssetLockProofWASM(instantLockBytes, transactionBytes, 0)
+
+      assert.deepEqual(instantLockProof.getOutPoint().constructor.name, 'OutPointWASM')
+    })
+
+    it('should allow to get output index', () => {
+      const instantLockProof = new wasm.InstantAssetLockProofWASM(instantLockBytes, transactionBytes, 0)
+
+      assert.deepEqual(instantLockProof.outputIndex, 0)
+    })
+
+    it('should allow to get instant lock', () => {
+      const instantLockProof = new wasm.InstantAssetLockProofWASM(instantLockBytes, transactionBytes, 0)
+
+      assert.deepEqual(instantLockProof.instantLock.constructor.name, 'InstantLockWASM')
+    })
+  })
+
+  describe('setters', function () {
+    it('should allow to set output index', () => {
+      const instantLockProof = new wasm.InstantAssetLockProofWASM(instantLockBytes, transactionBytes, 0)
+
+      instantLockProof.outputIndex = 12
+
+      assert.deepEqual(instantLockProof.outputIndex, 12)
+    })
+
+    it('should allow to set instant lock', () => {
+      const instantLockProof = new wasm.InstantAssetLockProofWASM(instantLockBytes, transactionBytes, 0)
+
+      const newInstantLockProof = new wasm.InstantLockWASM(
+        0,
+        [],
+        'dbdb604952d08184b55d48c915ed78aadc81dbc5cc98e8b4821abe5b4bbcbecb',
+        '00000000000000151e0fe3ab9a12c57402153c9f476236148364ec4337213101',
+        'a9f131626c49a2f183b7a2f563ad1dc50ac8220190dbedb805209b608eb864e01d62f18bc9faa60a8b8a27f5a0c7c8b914fa3a14360a2f25558ee0e0a693b18faccbb59ec39b9b3cae430e0b76eb080752ce103df76537a1a583680a5914529d'
+      )
+
+      instantLockProof.instantLock = newInstantLockProof
+
+      assert.deepEqual(instantLockProof.instantLock.version, 0)
+      assert.notEqual(newInstantLockProof.__wbg_ptr, 0)
+    })
+  })
+})

package/tests/OutPoint.spec.js

@@ -0,0 +1,55 @@
+const assert = require('assert')
+const { describe, it, before } = require('mocha')
+const initWasm = require('./utils/wasm')
+
+let wasm
+
+describe('OutPoint', function () {
+  before(async function () {
+    wasm = initWasm()
+  })
+
+  describe('serialization / deserialization', function () {
+    it('should allow to create from values', () => {
+      const outpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 1)
+
+      assert.notEqual(outpoint.__wbg_ptr, 0)
+    })
+
+    it('should allow to create from bytes', () => {
+      const txIdBytes = Buffer.from('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 'hex')
+
+      // 32 bytes for txId and 4 bytes for vout
+      const bytes = [...txIdBytes.reverse(), ...[0, 0, 0, 1].reverse()]
+
+      const outpoint = wasm.OutPointWASM.fromBytes(bytes)
+
+      assert.notEqual(outpoint.__wbg_ptr, 0)
+    })
+  })
+
+  describe('getters', function () {
+    it('should allow to get txid', function () {
+      const outpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 1)
+
+      assert.equal(outpoint.getTXID(), 'e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d')
+    })
+
+    it('should allow to get VOUT', function () {
+      const outpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 1)
+
+      assert.equal(outpoint.getVOUT(), 1)
+    })
+
+    it('should allow to get bytes', function () {
+      const outpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 1)
+
+      const txIdBytes = Buffer.from('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 'hex')
+
+      // 32 bytes for txId and 4 bytes for vout
+      const bytes = [...txIdBytes.reverse(), ...[0, 0, 0, 1].reverse()]
+
+      assert.deepEqual(outpoint.toBytes(), Uint8Array.from(bytes))
+    })
+  })
+})

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/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/PublicKey/index.js

@@ -2,7 +2,7 @@ const { Purpose, SecurityLevel, KeyType } = require('../../../dist/cjs/wasm/pshe
 
 module.exports = {
   keyId: 2,
-  purpose: Purpose.AUTHENTICATION,
+  purpose: 'AUTHENTICATION',
   securityLevel: SecurityLevel.CRITICAL,
   keyType: KeyType.ECDSA_SECP256K1,
   binaryData: '036a394312e40e81d928fde2bde7880070e4fa9c1d1d9b168da707ea468afa2b48',