@simplito/privmx-webendpoint 2.2.9 → 2.3.0

package/FinalizationHelper.d.ts

@@ -0,0 +1,18 @@
+interface NativeObjInfo {
+    ptr: number;
+    onFree: () => Promise<void>;
+}
+export declare class FinalizationHelper {
+    private wasmLib;
+    private static instance;
+    private static wasmLib;
+    static init(wasmLib: any): void;
+    static getInstance(): FinalizationHelper;
+    private finalizationRegistry;
+    private finalizationQueue;
+    private scheduler;
+    private constructor();
+    private scheduleCleanup;
+    register(target: WeakKey, info: NativeObjInfo): void;
+}
+export {};

package/FinalizationHelper.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinalizationHelper = void 0;
+const ApiStatic_1 = require("./api/ApiStatic");
+class FinalizationHelper {
+    wasmLib;
+    static instance;
+    static wasmLib;
+    static init(wasmLib) {
+        FinalizationHelper.wasmLib = wasmLib;
+    }
+    static getInstance() {
+        if (!FinalizationHelper.wasmLib) {
+            throw new Error("Initialize first with the WASM Library object");
+        }
+        if (!this.instance) {
+            this.instance = new FinalizationHelper(FinalizationHelper.wasmLib);
+        }
+        return this.instance;
+    }
+    finalizationRegistry;
+    finalizationQueue = [];
+    scheduler = null;
+    constructor(wasmLib) {
+        this.wasmLib = wasmLib;
+        this.finalizationRegistry = new FinalizationRegistry(onCleanup => {
+            const api = ApiStatic_1.ApiStatic.getInstance();
+            this.finalizationQueue.push(onCleanup.onFree);
+            this.scheduleCleanup();
+        });
+    }
+    scheduleCleanup() {
+        if (this.scheduler) {
+            return;
+        }
+        this.scheduler = setTimeout(async () => {
+            for (const freeCall of this.finalizationQueue) {
+                await freeCall();
+            }
+            this.finalizationQueue = [];
+            clearTimeout(this.scheduler);
+            this.scheduler = null;
+        }, 1000);
+    }
+    register(target, info) {
+        this.finalizationRegistry.register(target, info, target);
+    }
+}
+exports.FinalizationHelper = FinalizationHelper;

package/Types.d.ts

@@ -8,6 +8,7 @@ This software is Licensed under the PrivMX Free License.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
+import { ExtKey } from "./service/ExtKey";
 export type SortOrder = "desc" | "asc";
 /**
  * Holds Event details
@@ -32,15 +33,16 @@ export interface Event {
  *
  * @param {number} skip number of elements to skip from result
  * @param {number} limit limit of elements to return for query
- * @param {SortOrder} sortOrder Order of elements in result. Use "asc" for ascending, "desc" for descening.
+ * @param {SortOrder} sortOrder Order of elements in result. Use "asc" for ascending, "desc" for descending.
  * @param {string} [lastId] id of the element from which query results should start
- *
+ * @param {string} [queryAsJson] extra query parameters in serialized JSON
  */
 export interface PagingQuery {
     skip: number;
     limit: number;
     sortOrder: SortOrder;
     lastId?: string;
+    queryAsJson?: string;
 }
 /**
 * Contains results of listing methods
@@ -81,6 +83,19 @@ export interface UserWithPubKey {
     userId: string;
     pubKey: string;
 }
+/**
+ * Contains Information about user
+ *
+ * @type {UserInfo}
+ *
+ * @param {UserWithPubKey} user User publicKey and userId
+ * @param {boolean} isActive is user connected to the Bridge
+ *
+ */
+export interface UserInfo {
+    user: UserWithPubKey;
+    isActive: boolean;
+}
 /**
  * Holds all available information about a Thread.
  *
@@ -96,11 +111,11 @@ export interface UserWithPubKey {
  * @param {string[]} managers list of users (their IDs) with management rights
  * @param {number} version version number (changes on updates)
  * @param {number} lastMsgDate timestamp of last posted message
- * @param {Uint8Array} publicMeta Thread's public meta data
- * @param {Uint8Array} privateMeta Thread's private mata data
+ * @param {Uint8Array} publicMeta Thread's public metadata
+ * @param {Uint8Array} privateMeta Thread's private metadata
  * @param {ContainerPolicy} policy Thread's policies
  * @param {number} messagesCount total number of messages in the Thread
- * @param {number} statusCode status code of retrival and decryption of the Thread
+ * @param {number} statusCode status code of retrieval and decryption of the Thread
  *
  */
 export interface Thread {
@@ -126,11 +141,11 @@ export interface Thread {
  * @type {Message}
  *
  * @param {ServerMessageInfo} info message's information created by server
- * @param {Uint8Array} publicMeta message's public meta data
- * @param {Uint8Array} privateMeta message's private mata data
+ * @param {Uint8Array} publicMeta message's public metadata
+ * @param {Uint8Array} privateMeta message's private metadata
  * @param {Uint8Array} data message's data
  * @param {string} authorPubKey public key of an author of the message
- * @param {number} statusCode status code of retrival and decryption of the message
+ * @param {number} statusCode status code of retrieval and decryption of the message
  *
  */
 export interface Message {
@@ -173,11 +188,11 @@ export interface ServerMessageInfo {
  * @param {string[]} users list of users (their IDs) with access to the Store
  * @param {string[]} managers list of users (their IDs) with management rights
  * @param {number} version version number (changes on updates)
- * @param {Uint8Array} publicMeta Store's public meta data
- * @param {Uint8Array} privateMeta Store's private mata data
+ * @param {Uint8Array} publicMeta Store's public metadata
+ * @param {Uint8Array} privateMeta Store's private metadata
  * @param {ContainerPolicy} policy Store's policies
  * @param {number} filesCount total number of files in the Store
- * @param {number} statusCode status code of retrival and decryption of the Store
+ * @param {number} statusCode status code of retrieval and decryption of the Store
  *
  */
 export interface Store {
@@ -203,11 +218,11 @@ export interface Store {
  * @type {File}
  *
  * @param {ServerFileInfo} info file's information created by server
- * @param {Uint8Array} publicMeta file's public meta data
- * @param {Uint8Array} privateMeta file's private mata data
+ * @param {Uint8Array} publicMeta file's public metadata
+ * @param {Uint8Array} privateMeta file's private metadata
  * @param {number} size file's size
  * @param {string} authorPubKey public key of an author of the file
- * @param {number} tatusCode status code of retrival and decryption of the file
+ * @param {number} tatusCode status code of retrieval and decryption of the file
  *
  */
 export interface File {
@@ -249,11 +264,11 @@ export interface ServerFileInfo {
  * @param {string[]} users list of users (their IDs) with access to the Inbox
  * @param {string[]} managers list of users (their IDs) with management rights
  * @param {number} version version number (changes on updates)
- * @param {Uint8Array} publicMeta Inbox' public meta data
- * @param {Uint8Array} privateMeta Inbox' private mata data
+ * @param {Uint8Array} publicMeta Inbox' public metadata
+ * @param {Uint8Array} privateMeta Inbox' private metadata
  * @param {FilesConfig} filesConfig Inbox' files configuration
  * @param {ContainerWithoutItemPolicy} policy Inbox' policies
- * @param {number} statusCode status code of retrival and decryption of the Inbox
+ * @param {number} statusCode status code of retrieval and decryption of the Inbox
  *
  */
 export interface Inbox {
@@ -279,7 +294,7 @@ export interface Inbox {
  *
  * @param {string} inboxId ID of the Inbox
  * @param {number} version version of the Inbox
- * @param {Uint8Array} publicMeta Inbox' public meta data
+ * @param {Uint8Array} publicMeta Inbox' public metadata
  *
  */
 export interface InboxPublicView {
@@ -298,7 +313,7 @@ export interface InboxPublicView {
  * @param {File[]} files list of files attached to the entry
  * @param {string} authorPubKey public key of the author of an entry
  * @param {number} createDate Inbox entry creation timestamp
- * @param {number} statusCode status code of retrival and decryption of the Inbox entry
+ * @param {number} statusCode status code of retrieval and decryption of the Inbox entry
  */
 export interface InboxEntry {
     entryId: string;
@@ -314,8 +329,8 @@ export interface InboxEntry {
  *
  * @type {FilesConfig}
  *
- * @param {int64_t} minCount minimum numer of files required when sending inbox entry
- * @param {int64_t} maxCount maximum numer of files allowed when sending inbox entry
+ * @param {int64_t} minCount minimum number of files required when sending inbox entry
+ * @param {int64_t} maxCount maximum number of files allowed when sending inbox entry
  * @param {int64_t} maxFileSize maximum file size allowed when sending inbox entry
  * @param {int64_t} maxWholeUploadSize maximum size of all files in total allowed when sending inbox entry
  *
@@ -405,3 +420,44 @@ export interface Error {
     description: string;
     full: string;
 }
+/**
+ * @param {string} mnemonic BIP-39 mnemonic
+ * @param {ExtKey} extKey Ecc Key
+ * @param {Uint8Array} entropy BIP-39 entropy
+*/
+export interface BIP39 {
+    mnemonic: string;
+    entropy: Uint8Array;
+    extKey: ExtKey;
+}
+/**
+ *
+ * @type {VerificationRequest}
+ *
+ * @param {string} contextId Id of the Context
+ * @param {string} senderId Id of the sender
+ * @param {string} senderPubKey Public key of the sender
+ * @param {number} date The data creation date
+ * @param {BridgeIdentity} bridgeIdentity Bridge Identity
+ */
+export interface VerificationRequest {
+    contextId: string;
+    senderId: string;
+    senderPubKey: string;
+    date: number;
+    bridgeIdentity?: BridgeIdentity;
+}
+/**
+ * Bridge server identification details.
+ *
+ * @type {BridgeIdentity}
+ *
+ * @param {string} url Bridge URL
+ * @param {string} pubKey Bridge public Key
+ * @param {string} instanceId Bridge instance Id given by PKI
+ */
+export interface BridgeIdentity {
+    url: string;
+    pubKey?: string;
+    instanceId?: string;
+}

package/Types.js

@@ -25,3 +25,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 ;
 ;
 ;
+;
+;
+;

package/api/ApiStatic.d.ts

@@ -0,0 +1,16 @@
+/*!
+PrivMX Web Endpoint.
+Copyright © 2024 Simplito sp. z o.o.
+
+This file is part of the PrivMX Platform (https://privmx.dev).
+This software is Licensed under the PrivMX Free License.
+
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { Api } from "./Api";
+export declare class ApiStatic {
+    private static instance;
+    static init(api: Api): void;
+    static getInstance(): Api;
+}

package/api/ApiStatic.js

@@ -0,0 +1,26 @@
+"use strict";
+/*!
+PrivMX Web Endpoint.
+Copyright © 2024 Simplito sp. z o.o.
+
+This file is part of the PrivMX Platform (https://privmx.dev).
+This software is Licensed under the PrivMX Free License.
+
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiStatic = void 0;
+class ApiStatic {
+    static instance;
+    static init(api) {
+        this.instance = api;
+    }
+    static getInstance() {
+        if (!this.instance) {
+            throw new Error("API Static not initialized");
+        }
+        return this.instance;
+    }
+}
+exports.ApiStatic = ApiStatic;

package/api/ConnectionNative.d.ts

@@ -8,10 +8,12 @@ This software is Licensed under the PrivMX Free License.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
-import { PagingQuery, PagingList, Context } from "../Types";
+import { UserVerifierInterface } from "../service/UserVerifierInterface";
+import { PagingQuery, PagingList, Context, UserInfo } from "../Types";
 import { BaseNative } from "./BaseNative";
 export declare class ConnectionNative extends BaseNative {
     protected lastConnectionId: number;
+    protected userVerifierPtr: number;
     protected newApi(_connectionPtr: number): Promise<number>;
     deleteApi(ptr: number): Promise<void>;
     newConnection(): Promise<number>;
@@ -20,5 +22,9 @@ export declare class ConnectionNative extends BaseNative {
     connectPublic(ptr: number, args: [string, string]): Promise<void>;
     getConnectionId(ptr: number, args: []): Promise<number>;
     listContexts(ptr: number, args: [PagingQuery]): Promise<PagingList<Context>>;
+    getContextUsers(ptr: number, args: [string]): Promise<UserInfo[]>;
     disconnect(ptr: number, args: []): Promise<void>;
+    setUserVerifier(_ptr: number, args: [number, UserVerifierInterface]): Promise<void>;
+    protected newUserVerifierInterface(connectionPtr: number): Promise<number>;
+    protected deleteUserVerifierInterface(ptr: number): Promise<void>;
 }

package/api/ConnectionNative.js

@@ -14,6 +14,7 @@ exports.ConnectionNative = void 0;
 const BaseNative_1 = require("./BaseNative");
 class ConnectionNative extends BaseNative_1.BaseNative {
     lastConnectionId = -1;
+    userVerifierPtr = -1;
     async newApi(_connectionPtr) {
         throw new Error("Use the newConnection() - specialized version of method instead.");
     }
@@ -44,8 +45,31 @@ class ConnectionNative extends BaseNative_1.BaseNative {
     async listContexts(ptr, args) {
         return this.runAsync((taskId) => this.api.lib.Connection_listContexts(taskId, ptr, args));
     }
+    async getContextUsers(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.Connection_getContextUsers(taskId, ptr, args));
+    }
     async disconnect(ptr, args) {
         await this.runAsync((taskId) => this.api.lib.Connection_disconnect(taskId, ptr, args));
     }
+    async setUserVerifier(_ptr, args) {
+        if (this.userVerifierPtr > -1) {
+            await this.deleteUserVerifierInterface(this.userVerifierPtr);
+            this.userVerifierPtr = -1;
+        }
+        const [connectionPtr, verifierInterface] = args;
+        window.userVierifier_verify = async (request) => {
+            if (verifierInterface && typeof verifierInterface.verify === "function") {
+                return verifierInterface.verify(request);
+            }
+            throw new Error("Call on UserVerifierInterface with missing implementation");
+        };
+        this.userVerifierPtr = await this.runAsync((taskId) => this.api.lib.Connection_newUserVerifierInterface(taskId, connectionPtr));
+    }
+    async newUserVerifierInterface(connectionPtr) {
+        return this.runAsync((taskId) => this.api.lib.Connection_newUserVerifierInterface(taskId, connectionPtr));
+    }
+    async deleteUserVerifierInterface(ptr) {
+        await this.runAsync((taskId) => this.api.lib.Connection_deleteUserVerifierInterface(taskId, ptr));
+    }
 }
 exports.ConnectionNative = ConnectionNative;

package/api/CryptoApiNative.d.ts

@@ -8,7 +8,14 @@ This software is Licensed under the PrivMX Free License.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
+import { BIP39 } from "../Types";
 import { BaseNative } from "./BaseNative";
+import { ExtKeyNativePtr } from "./ExtKeyNative";
+export interface BIP39Native {
+    mnemonic: string;
+    extKey: ExtKeyNativePtr;
+    entropy: Uint8Array;
+}
 export declare class CryptoApiNative extends BaseNative {
     newApi(): Promise<number>;
     deleteApi(ptr: number): Promise<void>;
@@ -23,4 +30,11 @@ export declare class CryptoApiNative extends BaseNative {
     encryptDataSymmetric(ptr: number, args: [Uint8Array, Uint8Array]): Promise<Uint8Array>;
     decryptDataSymmetric(ptr: number, args: [Uint8Array, Uint8Array]): Promise<Uint8Array>;
     convertPEMKeytoWIFKey(ptr: number, args: [string]): Promise<string>;
+    generateBip39(ptr: number, args: [number, string]): Promise<BIP39>;
+    fromMnemonic(ptr: number, args: [string, string]): Promise<BIP39>;
+    fromEntropy(ptr: number, args: [Uint8Array, string]): Promise<BIP39>;
+    entropyToMnemonic(ptr: number, args: [Uint8Array]): Promise<string>;
+    mnemonicToEntropy(ptr: number, args: [string]): Promise<Uint8Array>;
+    mnemonicToSeed(ptr: number, args: [string, string]): Promise<Uint8Array>;
+    private convertBIP;
 }

package/api/CryptoApiNative.js

@@ -11,7 +11,9 @@ limitations under the License.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CryptoApiNative = void 0;
+const ExtKey_1 = require("../service/ExtKey");
 const BaseNative_1 = require("./BaseNative");
+;
 class CryptoApiNative extends BaseNative_1.BaseNative {
     async newApi() {
         return this.runAsync((taskId) => this.api.lib.CryptoApi_newCryptoApi(taskId));
@@ -53,5 +55,33 @@ class CryptoApiNative extends BaseNative_1.BaseNative {
     async convertPEMKeytoWIFKey(ptr, args) {
         return this.runAsync((taskId) => this.api.lib.CryptoApi_convertPEMKeytoWIFKey(taskId, ptr, args));
     }
+    async generateBip39(ptr, args) {
+        const bipNative = await this.runAsync((taskId) => this.api.lib.CryptoApi_generateBip39(taskId, ptr, args));
+        return this.convertBIP(bipNative);
+    }
+    async fromMnemonic(ptr, args) {
+        const bipNative = await this.runAsync((taskId) => this.api.lib.CryptoApi_fromMnemonic(taskId, ptr, args));
+        return this.convertBIP(bipNative);
+    }
+    async fromEntropy(ptr, args) {
+        const bipNative = await this.runAsync((taskId) => this.api.lib.CryptoApi_fromEntropy(taskId, ptr, args));
+        return this.convertBIP(bipNative);
+    }
+    async entropyToMnemonic(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.CryptoApi_entropyToMnemonic(taskId, ptr, args));
+    }
+    async mnemonicToEntropy(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.CryptoApi_mnemonicToEntropy(taskId, ptr, args));
+    }
+    async mnemonicToSeed(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.CryptoApi_mnemonicToSeed(taskId, ptr, args));
+    }
+    convertBIP(bipNative) {
+        return {
+            mnemonic: bipNative.mnemonic,
+            entropy: bipNative.entropy,
+            extKey: ExtKey_1.ExtKey.fromPtr(bipNative.extKey)
+        };
+    }
 }
 exports.CryptoApiNative = CryptoApiNative;

package/api/EventApiNative.d.ts

@@ -0,0 +1,20 @@
+/*!
+PrivMX Web Endpoint.
+Copyright © 2024 Simplito sp. z o.o.
+
+This file is part of the PrivMX Platform (https://privmx.dev).
+This software is Licensed under the PrivMX Free License.
+
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { UserWithPubKey } from "../Types";
+import { BaseNative } from "./BaseNative";
+export declare class EventApiNative extends BaseNative {
+    newApi(connectionPtr: number): Promise<number>;
+    deleteApi(ptr: number): Promise<void>;
+    create(ptr: number, args: []): Promise<void>;
+    emitEvent(ptr: number, args: [string, string, Uint8Array, UserWithPubKey[]]): Promise<void>;
+    subscribeForCustomEvents(ptr: number, args: [string, string]): Promise<void>;
+    unsubscribeFromCustomEvents(ptr: number, args: [string, string]): Promise<void>;
+}

package/api/EventApiNative.js

@@ -0,0 +1,36 @@
+"use strict";
+/*!
+PrivMX Web Endpoint.
+Copyright © 2024 Simplito sp. z o.o.
+
+This file is part of the PrivMX Platform (https://privmx.dev).
+This software is Licensed under the PrivMX Free License.
+
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventApiNative = void 0;
+const BaseNative_1 = require("./BaseNative");
+class EventApiNative extends BaseNative_1.BaseNative {
+    async newApi(connectionPtr) {
+        return this.runAsync((taskId) => this.api.lib.EventApi_newEventApi(taskId, connectionPtr));
+    }
+    async deleteApi(ptr) {
+        await this.runAsync((taskId) => this.api.lib.EventApi_deleteEventApi(taskId, ptr));
+        this.deleteApiRef();
+    }
+    async create(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.EventApi_create(taskId, ptr, args));
+    }
+    async emitEvent(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.EventApi_emitEvent(taskId, ptr, args));
+    }
+    async subscribeForCustomEvents(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.EventApi_subscribeForCustomEvents(taskId, ptr, args));
+    }
+    async unsubscribeFromCustomEvents(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.EventApi_unsubscribeFromCustomEvents(taskId, ptr, args));
+    }
+}
+exports.EventApiNative = EventApiNative;

package/api/ExtKeyNative.d.ts

@@ -0,0 +1,23 @@
+import { BaseNative } from "./BaseNative";
+export type ExtKeyNativePtr = number & {
+    __extKeyNativePtr: never;
+};
+export declare class ExtKeyNative extends BaseNative {
+    protected newApi(): Promise<number>;
+    deleteApi(ptr: number): Promise<void>;
+    deleteExtKey(ptr: number): Promise<void>;
+    static fromSeed(args: [Uint8Array]): Promise<ExtKeyNativePtr>;
+    static fromBase58(args: [string]): Promise<ExtKeyNativePtr>;
+    static generateRandom(args: []): Promise<ExtKeyNativePtr>;
+    derive(ptr: number, args: [number]): Promise<ExtKeyNativePtr>;
+    deriveHardened(ptr: number, args: [number]): Promise<ExtKeyNativePtr>;
+    getPrivatePartAsBase58(ptr: number, args: []): Promise<string>;
+    getPublicPartAsBase58(ptr: number, args: []): Promise<string>;
+    getPrivateKey(ptr: number, args: []): Promise<string>;
+    getPublicKey(ptr: number, args: []): Promise<string>;
+    getPrivateEncKey(ptr: number, args: []): Promise<Uint8Array>;
+    getPublicKeyAsBase58Address(ptr: number, args: []): Promise<string>;
+    getChainCode(ptr: number, args: []): Promise<Uint8Array>;
+    verifyCompactSignatureWithHash(ptr: number, args: [Uint8Array, Uint8Array]): Promise<boolean>;
+    isPrivate(ptr: number, args: []): Promise<boolean>;
+}

package/api/ExtKeyNative.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtKeyNative = void 0;
+const ApiStatic_1 = require("./ApiStatic");
+const BaseNative_1 = require("./BaseNative");
+class ExtKeyNative extends BaseNative_1.BaseNative {
+    async newApi() {
+        throw new Error("Use the specialized version of method instead.");
+    }
+    async deleteApi(ptr) {
+        return this.runAsync((taskId) => this.api.lib.ExtKey_deleteExtKey(taskId, ptr));
+    }
+    async deleteExtKey(ptr) {
+        return this.runAsync((taskId) => this.api.lib.ExtKey_deleteExtKey(taskId, ptr));
+    }
+    static async fromSeed(args) {
+        const api = ApiStatic_1.ApiStatic.getInstance();
+        return api.runAsync((taskId) => api.lib.ExtKey_fromSeed(taskId, args));
+    }
+    static async fromBase58(args) {
+        // base58: string
+        const api = ApiStatic_1.ApiStatic.getInstance();
+        return api.runAsync((taskId) => api.lib.ExtKey_fromBase58(taskId, args));
+    }
+    static async generateRandom(args) {
+        const api = ApiStatic_1.ApiStatic.getInstance();
+        return api.runAsync((taskId) => api.lib.ExtKey_generateRandom(taskId, args));
+    }
+    async derive(ptr, args) {
+        // index: number
+        return this.runAsync((taskId) => this.api.lib.ExtKey_derive(taskId, ptr, args));
+    }
+    async deriveHardened(ptr, args) {
+        // index: number
+        return this.runAsync((taskId) => this.api.lib.ExtKey_deriveHardened(taskId, ptr, args));
+    }
+    getPrivatePartAsBase58(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.ExtKey_getPrivatePartAsBase58(taskId, ptr, args));
+    }
+    getPublicPartAsBase58(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.ExtKey_getPublicPartAsBase58(taskId, ptr, args));
+    }
+    getPrivateKey(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.ExtKey_getPrivateKey(taskId, ptr, args));
+    }
+    getPublicKey(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.ExtKey_getPublicKey(taskId, ptr, args));
+    }
+    getPrivateEncKey(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.ExtKey_getPrivateEncKey(taskId, ptr, args));
+    }
+    getPublicKeyAsBase58Address(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.ExtKey_getPublicKeyAsBase58Address(taskId, ptr, args));
+    }
+    getChainCode(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.ExtKey_getChainCode(taskId, ptr, args));
+    }
+    verifyCompactSignatureWithHash(ptr, args) {
+        // message: Uint8Array, signature: Uint8Array
+        return this.runAsync((taskId) => this.api.lib.ExtKey_verifyCompactSignatureWithHash(taskId, ptr, args));
+    }
+    isPrivate(ptr, args) {
+        return this.runAsync((taskId) => this.api.lib.ExtKey_isPrivate(taskId, ptr, args));
+    }
+}
+exports.ExtKeyNative = ExtKeyNative;