@dashevo/evo-sdk 2.1.0-dev.7 → 2.1.0-dev.8

package/dist/sdk.d.ts

@@ -62,4 +62,4 @@ export { SystemFacade } from './system/facade.js';
 export { GroupFacade } from './group/facade.js';
 export { VotingFacade } from './voting/facade.js';
 export { wallet } from './wallet/functions.js';
-export { verifyIdentityResponse, verifyDataContract, verifyDocuments, start } from './wasm.js';
+export * from './wasm.js';

package/dist/sdk.js

@@ -100,4 +100,4 @@ export { SystemFacade } from './system/facade.js';
 export { GroupFacade } from './group/facade.js';
 export { VotingFacade } from './voting/facade.js';
 export { wallet } from './wallet/functions.js';
-export { verifyIdentityResponse, verifyDataContract, verifyDocuments, start } from './wasm.js';
+export * from './wasm.js';

package/dist/tokens/facade.d.ts

@@ -2,7 +2,7 @@ import type { EvoSDK } from '../sdk.js';
 export declare class TokensFacade {
     private sdk;
     constructor(sdk: EvoSDK);
-    calculateId(contractId: string, tokenPosition: number): string;
+    calculateId(contractId: string, tokenPosition: number): Promise<string>;
     priceByContract(contractId: string, tokenPosition: number): Promise<any>;
     totalSupply(tokenId: string): Promise<any>;
     totalSupplyWithProof(tokenId: string): Promise<any>;

package/dist/tokens/facade.js

@@ -4,7 +4,8 @@ export class TokensFacade {
     constructor(sdk) {
         this.sdk = sdk;
     }
-    calculateId(contractId, tokenPosition) {
+    async calculateId(contractId, tokenPosition) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.calculateTokenIdFromContract(contractId, tokenPosition);
     }
     // Queries

package/dist/wallet/functions.d.ts

@@ -1,24 +1,24 @@
 export declare namespace wallet {
-    function generateMnemonic(wordCount?: number, languageCode?: string): string;
-    function validateMnemonic(mnemonic: string, languageCode?: string): boolean;
-    function mnemonicToSeed(mnemonic: string, passphrase?: string): Uint8Array;
-    function deriveKeyFromSeedPhrase(mnemonic: string, passphrase: string | null | undefined, network: string): any;
-    function deriveKeyFromSeedWithPath(mnemonic: string, passphrase: string | null | undefined, path: string, network: string): any;
-    function deriveKeyFromSeedWithExtendedPath(mnemonic: string, passphrase: string | null | undefined, path: string, network: string): any;
-    function deriveDashpayContactKey(mnemonic: string, passphrase: string | null | undefined, senderIdentityId: string, receiverIdentityId: string, account: number, addressIndex: number, network: string): any;
-    function derivationPathBip44Mainnet(account: number, change: number, index: number): any;
-    function derivationPathBip44Testnet(account: number, change: number, index: number): any;
-    function derivationPathDip9Mainnet(featureType: number, account: number, index: number): any;
-    function derivationPathDip9Testnet(featureType: number, account: number, index: number): any;
-    function derivationPathDip13Mainnet(account: number): any;
-    function derivationPathDip13Testnet(account: number): any;
-    function deriveChildPublicKey(xpub: string, index: number, hardened: boolean): string;
-    function xprvToXpub(xprv: string): string;
-    function generateKeyPair(network: string): any;
-    function generateKeyPairs(network: string, count: number): any[];
-    function keyPairFromWif(privateKeyWif: string): any;
-    function keyPairFromHex(privateKeyHex: string, network: string): any;
-    function pubkeyToAddress(pubkeyHex: string, network: string): string;
-    function validateAddress(address: string, network: string): boolean;
-    function signMessage(message: string, privateKeyWif: string): string;
+    function generateMnemonic(wordCount?: number, languageCode?: string): Promise<string>;
+    function validateMnemonic(mnemonic: string, languageCode?: string): Promise<boolean>;
+    function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;
+    function deriveKeyFromSeedPhrase(mnemonic: string, passphrase: string | null | undefined, network: string): Promise<any>;
+    function deriveKeyFromSeedWithPath(mnemonic: string, passphrase: string | null | undefined, path: string, network: string): Promise<any>;
+    function deriveKeyFromSeedWithExtendedPath(mnemonic: string, passphrase: string | null | undefined, path: string, network: string): Promise<any>;
+    function deriveDashpayContactKey(mnemonic: string, passphrase: string | null | undefined, senderIdentityId: string, receiverIdentityId: string, account: number, addressIndex: number, network: string): Promise<any>;
+    function derivationPathBip44Mainnet(account: number, change: number, index: number): Promise<any>;
+    function derivationPathBip44Testnet(account: number, change: number, index: number): Promise<any>;
+    function derivationPathDip9Mainnet(featureType: number, account: number, index: number): Promise<any>;
+    function derivationPathDip9Testnet(featureType: number, account: number, index: number): Promise<any>;
+    function derivationPathDip13Mainnet(account: number): Promise<any>;
+    function derivationPathDip13Testnet(account: number): Promise<any>;
+    function deriveChildPublicKey(xpub: string, index: number, hardened: boolean): Promise<string>;
+    function xprvToXpub(xprv: string): Promise<string>;
+    function generateKeyPair(network: string): Promise<any>;
+    function generateKeyPairs(network: string, count: number): Promise<any[]>;
+    function keyPairFromWif(privateKeyWif: string): Promise<any>;
+    function keyPairFromHex(privateKeyHex: string, network: string): Promise<any>;
+    function pubkeyToAddress(pubkeyHex: string, network: string): Promise<string>;
+    function validateAddress(address: string, network: string): Promise<boolean>;
+    function signMessage(message: string, privateKeyWif: string): Promise<string>;
 }

package/dist/wallet/functions.js

@@ -1,91 +1,113 @@
 import * as wasm from '../wasm.js';
 export var wallet;
 (function (wallet) {
-    function generateMnemonic(wordCount, languageCode) {
+    async function generateMnemonic(wordCount, languageCode) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.generateMnemonic(wordCount ?? null, languageCode ?? null);
     }
     wallet.generateMnemonic = generateMnemonic;
-    function validateMnemonic(mnemonic, languageCode) {
+    async function validateMnemonic(mnemonic, languageCode) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.validateMnemonic(mnemonic, languageCode ?? null);
     }
     wallet.validateMnemonic = validateMnemonic;
-    function mnemonicToSeed(mnemonic, passphrase) {
+    async function mnemonicToSeed(mnemonic, passphrase) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.mnemonicToSeed(mnemonic, passphrase ?? null);
     }
     wallet.mnemonicToSeed = mnemonicToSeed;
-    function deriveKeyFromSeedPhrase(mnemonic, passphrase, network) {
+    async function deriveKeyFromSeedPhrase(mnemonic, passphrase, network) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.deriveKeyFromSeedPhrase(mnemonic, passphrase ?? null, network);
     }
     wallet.deriveKeyFromSeedPhrase = deriveKeyFromSeedPhrase;
-    function deriveKeyFromSeedWithPath(mnemonic, passphrase, path, network) {
+    async function deriveKeyFromSeedWithPath(mnemonic, passphrase, path, network) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.deriveKeyFromSeedWithPath(mnemonic, passphrase ?? null, path, network);
     }
     wallet.deriveKeyFromSeedWithPath = deriveKeyFromSeedWithPath;
-    function deriveKeyFromSeedWithExtendedPath(mnemonic, passphrase, path, network) {
+    async function deriveKeyFromSeedWithExtendedPath(mnemonic, passphrase, path, network) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.deriveKeyFromSeedWithExtendedPath(mnemonic, passphrase ?? null, path, network);
     }
     wallet.deriveKeyFromSeedWithExtendedPath = deriveKeyFromSeedWithExtendedPath;
-    function deriveDashpayContactKey(mnemonic, passphrase, senderIdentityId, receiverIdentityId, account, addressIndex, network) {
+    async function deriveDashpayContactKey(mnemonic, passphrase, senderIdentityId, receiverIdentityId, account, addressIndex, network) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.deriveDashpayContactKey(mnemonic, passphrase ?? null, senderIdentityId, receiverIdentityId, account, addressIndex, network);
     }
     wallet.deriveDashpayContactKey = deriveDashpayContactKey;
-    function derivationPathBip44Mainnet(account, change, index) {
+    async function derivationPathBip44Mainnet(account, change, index) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.derivationPathBip44Mainnet(account, change, index);
     }
     wallet.derivationPathBip44Mainnet = derivationPathBip44Mainnet;
-    function derivationPathBip44Testnet(account, change, index) {
+    async function derivationPathBip44Testnet(account, change, index) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.derivationPathBip44Testnet(account, change, index);
     }
     wallet.derivationPathBip44Testnet = derivationPathBip44Testnet;
-    function derivationPathDip9Mainnet(featureType, account, index) {
+    async function derivationPathDip9Mainnet(featureType, account, index) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.derivationPathDip9Mainnet(featureType, account, index);
     }
     wallet.derivationPathDip9Mainnet = derivationPathDip9Mainnet;
-    function derivationPathDip9Testnet(featureType, account, index) {
+    async function derivationPathDip9Testnet(featureType, account, index) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.derivationPathDip9Testnet(featureType, account, index);
     }
     wallet.derivationPathDip9Testnet = derivationPathDip9Testnet;
-    function derivationPathDip13Mainnet(account) {
+    async function derivationPathDip13Mainnet(account) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.derivationPathDip13Mainnet(account);
     }
     wallet.derivationPathDip13Mainnet = derivationPathDip13Mainnet;
-    function derivationPathDip13Testnet(account) {
+    async function derivationPathDip13Testnet(account) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.derivationPathDip13Testnet(account);
     }
     wallet.derivationPathDip13Testnet = derivationPathDip13Testnet;
-    function deriveChildPublicKey(xpub, index, hardened) {
+    async function deriveChildPublicKey(xpub, index, hardened) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.deriveChildPublicKey(xpub, index, hardened);
     }
     wallet.deriveChildPublicKey = deriveChildPublicKey;
-    function xprvToXpub(xprv) {
+    async function xprvToXpub(xprv) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.xprvToXpub(xprv);
     }
     wallet.xprvToXpub = xprvToXpub;
-    function generateKeyPair(network) {
+    async function generateKeyPair(network) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.generateKeyPair(network);
     }
     wallet.generateKeyPair = generateKeyPair;
-    function generateKeyPairs(network, count) {
+    async function generateKeyPairs(network, count) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.generateKeyPairs(network, count);
     }
     wallet.generateKeyPairs = generateKeyPairs;
-    function keyPairFromWif(privateKeyWif) {
+    async function keyPairFromWif(privateKeyWif) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.keyPairFromWif(privateKeyWif);
     }
     wallet.keyPairFromWif = keyPairFromWif;
-    function keyPairFromHex(privateKeyHex, network) {
+    async function keyPairFromHex(privateKeyHex, network) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.keyPairFromHex(privateKeyHex, network);
     }
     wallet.keyPairFromHex = keyPairFromHex;
-    function pubkeyToAddress(pubkeyHex, network) {
+    async function pubkeyToAddress(pubkeyHex, network) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.pubkeyToAddress(pubkeyHex, network);
     }
     wallet.pubkeyToAddress = pubkeyToAddress;
-    function validateAddress(address, network) {
+    async function validateAddress(address, network) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.validateAddress(address, network);
     }
     wallet.validateAddress = validateAddress;
-    function signMessage(message, privateKeyWif) {
+    async function signMessage(message, privateKeyWif) {
+        await wasm.ensureInitialized();
         return wasm.WasmSdk.signMessage(message, privateKeyWif);
     }
     wallet.signMessage = signMessage;

package/dist/wasm.d.ts

@@ -1,3 +1,4 @@
 export declare function ensureInitialized(): Promise<void>;
 export * from '@dashevo/wasm-sdk/compressed';
 export { default } from '@dashevo/wasm-sdk/compressed';
+export type { DataContract } from '@dashevo/wasm-sdk/compressed';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/evo-sdk",
-  "version": "2.1.0-dev.7",
+  "version": "2.1.0-dev.8",
   "type": "module",
   "main": "./dist/evo-sdk.module.js",
   "types": "./dist/sdk.d.ts",
@@ -22,7 +22,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@dashevo/wasm-sdk": "2.1.0-dev.7"
+    "@dashevo/wasm-sdk": "2.1.0-dev.8"
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json && webpack --config webpack.config.cjs",