pshenmic-dpp 1.1.2-dev.7 → 2.0.0-dev.1

package/tests/unit/Identifier.spec.ts

@@ -0,0 +1,105 @@
+import { IdentifierWASM } from "../../dist/src/wasm.js";
+
+let identifierBytes: Uint8Array;
+
+describe("Identifier", function () {
+  beforeAll(async function () {
+    identifierBytes = Uint8Array.from([
+      9, 40, 40, 237, 192, 129, 211, 186, 26, 84, 240, 67, 37, 155, 148, 19,
+      104, 242, 199, 24, 136, 27, 6, 169, 211, 71, 136, 59, 33, 191, 227, 19,
+    ]);
+  });
+
+  describe("serialization / deserialization", function () {
+    test("should allows to create Identifier from base58", function () {
+      const identifier = IdentifierWASM.fromBase58(
+        "ckBqfQe7LU7vwrwXopyCB4n5phZShjA16BGhNGpsD5U",
+      );
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+
+    test("should allows to create Identifier from base64", function () {
+      const identifier = IdentifierWASM.fromBase64(
+        "CSgo7cCB07oaVPBDJZuUE2jyxxiIGwap00eIOyG/4xM=",
+      );
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+
+    test("should allows to create Identifier from hex", function () {
+      const identifier = IdentifierWASM.fromHex(
+        "092828edc081d3ba1a54f043259b941368f2c718881b06a9d347883b21bfe313",
+      );
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+
+    test("should allows to create Identifier from bytes", function () {
+      const identifier = IdentifierWASM.fromBytes(identifierBytes);
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+
+    test("should allows to create Identifier from Identifier", function () {
+      const identifier = IdentifierWASM.fromBytes(identifierBytes);
+      const identifier2 = new IdentifierWASM(identifier);
+
+      expect(identifier2.bytes()).toEqual(identifierBytes);
+    });
+
+    test("should allows to create Identifier from bytes in constructor", function () {
+      const identifier = new IdentifierWASM(identifierBytes);
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+
+    test("should allows to create Identifier from base58 in constructor", function () {
+      const identifier = new IdentifierWASM(
+        "ckBqfQe7LU7vwrwXopyCB4n5phZShjA16BGhNGpsD5U",
+      );
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+  });
+
+  describe("getters", function () {
+    test("should allow to get identifier base58", function () {
+      const identifier = IdentifierWASM.fromBase58(
+        "ckBqfQe7LU7vwrwXopyCB4n5phZShjA16BGhNGpsD5U",
+      );
+
+      expect(identifier.base58()).toEqual(
+        "ckBqfQe7LU7vwrwXopyCB4n5phZShjA16BGhNGpsD5U",
+      );
+    });
+
+    test("should allow to get identifier base64", function () {
+      const identifier = IdentifierWASM.fromBase58(
+        "ckBqfQe7LU7vwrwXopyCB4n5phZShjA16BGhNGpsD5U",
+      );
+
+      expect(identifier.base64()).toEqual(
+        "CSgo7cCB07oaVPBDJZuUE2jyxxiIGwap00eIOyG/4xM=",
+      );
+    });
+
+    test("should allow to get identifier hex", function () {
+      const identifier = IdentifierWASM.fromBase58(
+        "ckBqfQe7LU7vwrwXopyCB4n5phZShjA16BGhNGpsD5U",
+      );
+
+      expect(identifier.hex()).toEqual(
+        "092828edc081d3ba1a54f043259b941368f2c718881b06a9d347883b21bfe313",
+      );
+    });
+
+    test("should allow to get identifier bytes", function () {
+      const identifier = IdentifierWASM.fromBase58(
+        "ckBqfQe7LU7vwrwXopyCB4n5phZShjA16BGhNGpsD5U",
+      );
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+  });
+});

package/tests/unit/Identity.spec.ts

@@ -0,0 +1,119 @@
+import {IdentifierWASM, IdentityWASM, PlatformVersionWASM, IdentityPublicKeyWASM} from '../../dist/src/wasm.js'
+
+let identifierBytes: Uint8Array
+let identifier: IdentifierWASM
+
+describe('Identity', function () {
+  beforeAll(function () {
+    identifierBytes = Uint8Array.from([9, 40, 40, 237, 192, 129, 211, 186, 26, 84, 240, 67, 37, 155, 148, 19, 104, 242, 199, 24, 136, 27, 6, 169, 211, 71, 136, 59, 33, 191, 227, 19])
+    identifier = new IdentifierWASM(identifierBytes)
+  })
+
+  describe('serialization / deserialization', function () {
+    test('should generate identity from identifier str', async function () {
+      const identity = new IdentityWASM('HEAmUtC72dPcZ59yyLUgfS8pfrEWqzYfDPzTofgWxXRr')
+
+      expect(identity).toBeInstanceOf(IdentityWASM)
+      expect(identity.id.base58()).toEqual('HEAmUtC72dPcZ59yyLUgfS8pfrEWqzYfDPzTofgWxXRr')
+    })
+
+    test('should generate identity from identifier bytes ', async function () {
+      const identity = new IdentityWASM(identifierBytes)
+
+      expect(identity.id.base58()).toEqual(identifier.base58())
+    })
+
+    test('should generate identity from identifier bytes with PlatformVersion', async function () {
+      const identity = new IdentityWASM(identifierBytes, PlatformVersionWASM.PLATFORM_V10)
+
+      expect(identity.id.base58()).toEqual(identifier.base58())
+    })
+
+    test('should generate identity from identifier and return bytes', async function () {
+      const identity = new IdentityWASM(identifier)
+
+      const newIdentity = IdentityWASM.fromBytes(identity.bytes())
+
+      expect(identity.id.base58()).toEqual(newIdentity.id.base58())
+    })
+  })
+
+  describe('getters', function () {
+    test('should get id buffer', function () {
+      const identity = new IdentityWASM(identifier)
+
+      expect(identity.id.bytes()).toEqual(identifierBytes)
+    })
+
+    test('should get balance', function () {
+      const identity = new IdentityWASM(identifier)
+
+      expect(identity.balance).toEqual(BigInt(0))
+    })
+
+    test('should get revision', function () {
+      const identity = new IdentityWASM(identifier)
+
+      expect(identity.revision).toEqual(BigInt(0))
+    })
+
+    test('should get public keys', function () {
+      const identity = new IdentityWASM(identifier)
+
+      const pubKey = new IdentityPublicKeyWASM(
+        0,
+        0,
+        0,
+        0,
+        false,
+        '036a394312e40e81d928fde2bde7880070e4fa9c1d1d9b168da707ea468afa2b48')
+
+      const pubKey2 = new IdentityPublicKeyWASM(
+        1,
+        0,
+        0,
+        0,
+        false,
+        '036a394312e40e81d928fde2bde7880070e4fa9c1d1d9b168da707ea468afa2b48')
+
+      identity.addPublicKey(pubKey)
+      identity.addPublicKey(pubKey2)
+
+      expect(identity.getPublicKeys().length).toEqual(2)
+    })
+  })
+
+  describe('setters', function () {
+    test('should allows to set public key', function () {
+      const pubKey = new IdentityPublicKeyWASM(
+        0,
+        0,
+        0,
+        0,
+        false,
+        '036a394312e40e81d928fde2bde7880070e4fa9c1d1d9b168da707ea468afa2b48')
+
+      const identity = new IdentityWASM(identifier)
+
+      identity.addPublicKey(pubKey)
+
+      expect(identity.getPublicKeyById(0)?.bytes()).toEqual(pubKey.bytes())
+    })
+
+    test('should allows to set balance', function () {
+      const identity = new IdentityWASM(identifier)
+
+      identity.balance = BigInt(21)
+
+      expect(identity.balance).toEqual(BigInt(21))
+    })
+
+    test('should allows to set revision', function () {
+      const identity = new IdentityWASM(identifier)
+
+      identity.revision = BigInt(21)
+
+      expect(identity.revision).toEqual(BigInt(21))
+    })
+  })
+})

package/tests/unit/IdentityPublicKey.spec.ts

@@ -0,0 +1,126 @@
+import {IdentityPublicKeyWASM, Purpose, SecurityLevel, KeyType} from '../../dist/src/wasm.js'
+
+let keyId: number
+let purpose: Purpose
+let securityLevel: SecurityLevel
+let keyType: KeyType
+let binaryData: string
+
+describe('PublicKey', function () {
+  beforeAll(function () {
+    keyId = 0
+    purpose = Purpose.DECRYPTION
+    securityLevel = SecurityLevel.HIGH
+    keyType = KeyType.ECDSA_SECP256K1
+    binaryData = '036a394312e40e81d928fde2bde7880070e4fa9c1d1d9b168da707ea468afa2b48'
+  })
+
+  describe('serialization / deserialization', function () {
+    test('should generate public key from values with type ECDSA_SECP256K1', function () {
+      const pubKey = new IdentityPublicKeyWASM(
+        keyId,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      expect(pubKey.data).toEqual(binaryData)
+    })
+
+    test('should generate public key from values with type ECDSA_SECP256K1 and generate new from self bytes', function () {
+      const pubKey = new IdentityPublicKeyWASM(
+        keyId,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      const bytes = pubKey.bytes()
+
+      const newPubKey = IdentityPublicKeyWASM.fromBytes(bytes)
+
+      expect(pubKey.keyId).toEqual(newPubKey.keyId)
+      expect(pubKey.purpose).toEqual(newPubKey.purpose)
+      expect(pubKey.securityLevel).toEqual(newPubKey.securityLevel)
+      expect(pubKey.keyType).toEqual(newPubKey.keyType)
+      expect(pubKey.readOnly).toEqual(newPubKey.readOnly)
+      expect(pubKey.data).toEqual(newPubKey.data)
+
+      expect(pubKey.bytes()).toEqual(newPubKey.bytes())
+    })
+
+    test('should return hash of key', function () {
+      const pubKey = new IdentityPublicKeyWASM(
+        keyId,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      const hash = pubKey.getPublicKeyHash()
+
+      expect(hash).toEqual('d372f096259f72686e18663d7db5f86234dd6f55')
+    })
+  })
+  describe('getters', function () {
+    test('should generate public key from values with type ECDSA_SECP256K1 and return all fields', function () {
+      const pubKey = new IdentityPublicKeyWASM(
+        keyId,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      expect(pubKey.keyId).toEqual(keyId)
+      expect(pubKey.purpose).toEqual('DECRYPTION')
+      expect(pubKey.securityLevel).toEqual('HIGH')
+      expect(pubKey.keyType).toEqual('ECDSA_SECP256K1')
+      expect(pubKey.readOnly).toEqual(false)
+      expect(pubKey.data).toEqual(binaryData)
+    })
+
+    // test('should allow to validate private key', function () {
+    //   const pubKey = new IdentityPublicKeyWASM(
+    //     keyId,
+    //     purpose,
+    //     securityLevel,
+    //     keyType,
+    //     false,
+    //     binaryData)
+    //
+    //   const privateKey = PrivateKeyWASM.fromWIF(wif)
+    //
+    //   assert.equal(pubKey.validatePrivateKey(privateKey.bytes(), NetworkWASM.Mainnet), false)
+    // })
+  })
+
+  describe('setters', function () {
+    test('should generate public key from values with type ECDSA_SECP256K1 and return all fields and set another fields', function () {
+      const pubKey = new IdentityPublicKeyWASM(
+        keyId,
+        purpose,
+        securityLevel,
+        keyType,
+        false,
+        binaryData)
+
+      pubKey.keyId = 1
+      pubKey.purpose = Purpose.TRANSFER
+      pubKey.securityLevel = SecurityLevel.MEDIUM
+      pubKey.keyType = KeyType.EDDSA_25519_HASH160
+      pubKey.readOnly = true
+      pubKey.data = '111a394312e40e81d928fde2bde7880070e4fa9c1d1d9b168da707ea468afa2b48'
+
+      expect(pubKey.keyId).toEqual(1)
+      expect(pubKey.purpose).toEqual('TRANSFER')
+      expect(pubKey.securityLevel).toEqual('MEDIUM')
+      expect(pubKey.keyType).toEqual('EDDSA_25519_HASH160')
+      expect(pubKey.readOnly).toEqual(true)
+      expect(pubKey.data).toEqual('111a394312e40e81d928fde2bde7880070e4fa9c1d1d9b168da707ea468afa2b48')
+    })
+  })
+})

package/dist/wasm/base122.d.ts

@@ -1 +0,0 @@
-export function decodeBase122 (base122: Uint8Array | string): Uint8Array;

package/dist/wasm/base122.js

@@ -1,67 +0,0 @@
-// Original code: https://github.com/kevinAlbs/Base122
-
-// Provides functions for encoding/decoding data to and from base-122.
-
-const kIllegals = [
-  0, // null
-  10, // newline
-  13, // carriage return
-  34, // double quote
-  38, // ampersand
-  92 // backslash
-]
-const kShortened = 0b111 // Uses the illegal index to signify the last two-byte char encodes <= 7 bits.
-
-/**
- * Decodes base-122 encoded data back to the original data.
- * @param {Uint8Array|String} rawData - The data to be decoded. This can be a Uint8Array
- * 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 decode (base122Data) {
-  const strData = typeof (base122Data) === 'string' ? base122Data : utf8DataToString(base122Data)
-  const decoded = []
-  let curByte = 0
-  let bitOfByte = 0
-
-  function push7 (byte) {
-    byte <<= 1
-    // Align this byte to offset for current byte.
-    curByte |= (byte >>> bitOfByte)
-    bitOfByte += 7
-    if (bitOfByte >= 8) {
-      decoded.push(curByte)
-      bitOfByte -= 8
-      // Now, take the remainder, left shift by what has been taken.
-      curByte = (byte << (7 - bitOfByte)) & 255
-    }
-  }
-
-  for (let i = 0; i < strData.length; i++) {
-    const c = strData.charCodeAt(i)
-    // Check if this is a two-byte character.
-    if (c > 127) {
-      // Note, the charCodeAt will give the codePoint, thus
-      // 0b110xxxxx 0b10yyyyyy will give => xxxxxyyyyyy
-      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])
-      // Always push the rest.
-      push7(c & 127)
-    } else {
-      // One byte characters can be pushed directly.
-      push7(c)
-    }
-  }
-  return new Uint8Array(decoded)
-}
-
-/**
- * Converts a sequence of UTF-8 bytes to a string.
- * @param {Uint8Array} data - The UTF-8 data.
- * @returns {String} A string with each character representing a code point.
- */
-function utf8DataToString (data) {
-  return new TextDecoder().decode(data)
-}

package/dist/wasm/index.d.ts

@@ -1,128 +0,0 @@
-import * as DPP from './pshenmic_dpp.js';
-
-export * from './pshenmic_dpp.js';
-
-export * from './base122.js';
-
-
-declare const dpp: DashPlatformProtocolWASM;
-export default dpp;
-
-export class DashPlatformProtocolWASM {
-    // CLASSES
-    AssetLockProofWASM: DPP.AssetLockProofWASM
-    ChainAssetLockProofWASM: DPP.ChainAssetLockProofWASM
-    CoreScriptWASM: DPP.CoreScriptWASM
-    DataContractCreateTransitionWASM: DPP.DataContractCreateTransitionWASM
-    DataContractUpdateTransitionWASM: DPP.DataContractUpdateTransitionWASM
-    DataContractWASM: DPP.DataContractWASM
-    DocumentBaseTransitionWASM: DPP.DocumentBaseTransitionWASM
-    DocumentCreateTransitionWASM: DPP.DocumentCreateTransitionWASM
-    DocumentDeleteTransitionWASM: DPP.DocumentDeleteTransitionWASM
-    DocumentPurchaseTransitionWASM: DPP.DocumentPurchaseTransitionWASM
-    DocumentReplaceTransitionWASM: DPP.DocumentReplaceTransitionWASM
-    DocumentTransferTransitionWASM: DPP.DocumentTransferTransitionWASM
-    DocumentTransitionWASM: DPP.DocumentTransitionWASM
-    DocumentUpdatePriceTransitionWASM: DPP.DocumentUpdatePriceTransitionWASM
-    DocumentWASM: DPP.DocumentWASM
-    BatchTransitionWASM: DPP.BatchTransitionWASM
-    BatchedTransitionWASM: DPP.BatchedTransitionWASM
-    TokenTransitionWASM: DPP.TokenTransitionWASM
-    TokenBaseTransitionWASM: DPP.TokenBaseTransitionWASM
-    TokenPricingScheduleWASM: DPP.TokenPricingScheduleWASM
-    TokenConfigUpdateTransitionWASM: DPP.TokenConfigUpdateTransitionWASM
-    TokenDirectPurchaseTransitionWASM: DPP.TokenDirectPurchaseTransitionWASM
-    TokenSetPriceForDirectPurchaseTransitionWASM: DPP.TokenSetPriceForDirectPurchaseTransitionWASM
-    TokenBurnTransitionWASM: DPP.TokenBurnTransitionWASM
-    TokenClaimTransitionWASM: DPP.TokenClaimTransitionWASM
-    TokenDestroyFrozenFundsTransitionWASM: DPP.TokenDestroyFrozenFundsTransitionWASM
-    TokenEmergencyActionTransitionWASM: DPP.TokenEmergencyActionTransitionWASM
-    TokenFreezeTransitionWASM: DPP.TokenFreezeTransitionWASM
-    TokenMintTransitionWASM: DPP.TokenMintTransitionWASM
-    TokenTransferTransitionWASM: DPP.TokenTransferTransitionWASM
-    TokenUnFreezeTransitionWASM: DPP.TokenUnFreezeTransitionWASM
-    GroupStateTransitionInfoWASM: DPP.GroupStateTransitionInfoWASM
-    PrivateEncryptedNoteWASM: DPP.PrivateEncryptedNoteWASM
-    SharedEncryptedNoteWASM: DPP.SharedEncryptedNoteWASM
-    TokenConfigurationChangeItemWASM: DPP.TokenConfigurationChangeItemWASM
-    AuthorizedActionTakersWASM: DPP.AuthorizedActionTakersWASM
-    DistributionFunctionWASM: DPP.DistributionFunctionWASM
-    TokenDistributionRecipientWASM: DPP.TokenDistributionRecipientWASM
-    DistributionFixedAmountWASM: DPP.DistributionFixedAmountWASM
-    DistributionRandomWASM: DPP.DistributionRandomWASM
-    DistributionStepDecreasingAmountWASM: DPP.DistributionStepDecreasingAmountWASM
-    DistributionLinearWASM: DPP.DistributionLinearWASM
-    DistributionPolynomialWASM: DPP.DistributionPolynomialWASM
-    DistributionExponentialWASM: DPP.DistributionExponentialWASM
-    DistributionLogarithmicWASM: DPP.DistributionLogarithmicWASM
-    DistributionInvertedLogarithmicWASM: DPP.DistributionInvertedLogarithmicWASM
-    TokenConfigurationLocalizationWASM: DPP.TokenConfigurationLocalizationWASM
-    TokenPerpetualDistributionWASM: DPP.TokenPerpetualDistributionWASM
-    RewardDistributionTypeWASM: DPP.RewardDistributionTypeWASM
-    TokenConfigurationConventionWASM: DPP.TokenConfigurationConventionWASM
-    TokenTradeModeWASM: DPP.TokenTradeModeWASM
-    TokenConfigurationWASM: DPP.TokenConfigurationWASM
-    ActionTakerWASM: DPP.ActionTakerWASM
-    ChangeControlRulesWASM: DPP.ChangeControlRulesWASM
-    TokenDistributionRulesWASM: DPP.TokenDistributionRulesWASM
-    GroupWASM: DPP.GroupWASM
-    TokenKeepsHistoryRulesWASM: DPP.TokenKeepsHistoryRulesWASM
-    TokenMarketplaceRulesWASM: DPP.TokenMarketplaceRulesWASM
-    TokenPreProgrammedDistributionWASM: DPP.TokenPreProgrammedDistributionWASM
-    IdentifierWASM: DPP.IdentifierWASM
-    IdentityCreateTransitionWASM: DPP.IdentityCreateTransitionWASM
-    IdentityCreditTransferWASM: DPP.IdentityCreditTransferWASM
-    IdentityCreditWithdrawalTransitionWASM: DPP.IdentityCreditWithdrawalTransitionWASM
-    IdentityPublicKeyInCreationWASM: DPP.IdentityPublicKeyInCreationWASM
-    IdentityPublicKeyWASM: DPP.IdentityPublicKeyWASM
-    ContractBoundsWASM: DPP.ContractBoundsWASM
-    IdentityTopUpTransitionWASM: DPP.IdentityTopUpTransitionWASM
-    IdentityUpdateTransitionWASM: DPP.IdentityUpdateTransitionWASM
-    IdentityWASM: DPP.IdentityWASM
-    InstantAssetLockProofWASM: DPP.InstantAssetLockProofWASM
-    InstantLockWASM: DPP.InstantLockWASM
-    OutPointWASM: DPP.OutPointWASM
-    PrefundedVotingBalanceWASM: DPP.PrefundedVotingBalanceWASM
-    PrivateKeyWASM: DPP.PrivateKeyWASM
-    StateTransitionWASM: DPP.StateTransitionWASM
-    TxOutWASM: DPP.TxOutWASM
-    TxInWASM: DPP.TxInWASM
-    WitnessWASM: DPP.WitnessWASM
-    TransactionWASM: DPP.TransactionWASM
-    MasternodeVoteTransitionWASM: DPP.MasternodeVoteTransitionWASM
-    VoteWASM: DPP.VoteWASM
-    VotePollWASM: DPP.VotePollWASM
-    ResourceVoteChoiceWASM: DPP.ResourceVoteChoiceWASM
-    // ENUMS
-    AssetLockProofTypeWASM: DPP.AssetLockProofTypeWASM
-    BatchType: DPP.BatchType
-    KeyType: DPP.KeyType
-    NetworkWASM: DPP.NetworkWASM
-    PlatformVersionWASM: DPP.PlatformVersionWASM
-    PoolingWASM: DPP.PoolingWASM
-    Purpose: DPP.Purpose
-    SecurityLevel: DPP.SecurityLevel
-    ActionGoalWASM: DPP.ActionGoalWASM
-    GroupActionStatusWASM: DPP.GroupActionStatusWASM
-    // METHODS
-    initSync: Function
-    verifyVotePollVoteStateProof: Function
-    verifyContract: Function
-    verifyDocumentsProof: Function
-    verifyIdentifierByNonUniquePublicKeyHash: Function
-    verifyIdentityBalance: Function
-    verifyIdentityByIdentifier: Function
-    verifyIdentityByUniqueKeyHash: Function
-    verifyIdentityContractNonce: Function
-    verifyIdentityKeysByIdentifier: Function
-    verifyIdentityNonce: Function
-    verifySignatureDigest: Function
-    verifyEpochsInfo: Function
-    verifyTotalCredits: Function
-    verifyTokenBalancesForIdentities: Function
-    verifyTokenContractInfo: Function
-    verifyTokenTotalSupply: Function
-    verifyTokensBalancesForIdentity: Function
-    verifyTokenDirectPurchasePrices: Function
-    verifyStateTransitionResult: Function
-}

package/dist/wasm/index.js

@@ -1,13 +0,0 @@
-import * as DPP from './pshenmic_dpp.js'
-import { bytes as 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(decode(wasmBytes))
-
-DPP.initSync({ module: decompressSync(bytes) })
-
-export default DPP

package/dist/wasm/initAsync.d.ts

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

package/dist/wasm/initAsync.js

@@ -1,20 +0,0 @@
-import {initWASM} from './initWASM.js'
-import {initInterface} 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 initInterface()
-
-  dpp = wasmInterface.initSync(wasm)
-
-  return wasmInterface
-}
-
-export {initModule}

package/dist/wasm/initInterface.d.ts

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

package/dist/wasm/initInterface.js

@@ -1,46 +0,0 @@
-import {bytes as 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,
-      TextEncoder
-    })
-    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 { initInterface }

package/dist/wasm/initWASM.d.ts

@@ -1 +0,0 @@
-export function initWASM(): Promise<ArrayBuffer>;

package/dist/wasm/initWASM.js

@@ -1,28 +0,0 @@
-import {bytes as 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 {initWASM}