core-3nweb-client-lib 0.27.3 → 0.27.5

package/build/lib-client/3nstorage/xsp-fs/fs.js

@@ -32,6 +32,7 @@ const pipe_1 = require("../../../lib-common/byte-streaming/pipe");
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
+const node_in_fs_1 = require("./node-in-fs");
 const utils_for_observables_1 = require("../../../lib-common/utils-for-observables");
 function splitPathIntoParts(path) {
     return path_1.posix.resolve('/', path).split('/').filter(part => !!part);
@@ -550,38 +551,36 @@ class V {
         const node = await this.get(path);
         return node.updateXAttrs(changes);
     }
-    async getXAttr(path, xaName) {
+    async getXAttr(path, xaName, flags) {
         const node = await this.get(path);
-        const attr = node.getXAttr(xaName);
-        return { attr, version: node.version };
+        return await node.getXAttr(xaName, flags);
     }
-    async listXAttrs(path) {
+    async listXAttrs(path, flags) {
         const node = await this.get(path);
-        return {
-            lst: node.listXAttrs(),
-            version: node.version
-        };
+        return node.listXAttrs(flags);
     }
-    async listFolder(path) {
+    async listFolder(path, flags) {
         const root = this.getRootIfNotClosed(path);
         const folder = await root.getFolderInThisSubTree(splitPathIntoParts(path), false).catch(setExcPath(path));
-        return folder.list();
+        return ((0, node_in_fs_1.shouldReadCurrentVersion)(flags) ?
+            folder.list() :
+            folder.listNonCurrent(flags));
     }
     async writeBytes(path, bytes, flags = WRITE_NONEXCL_FLAGS) {
         this.ensureIsWritable();
         const f = await this.getOrCreateFile(path, flags);
         return f.save(bytes);
     }
-    async readBytes(path, start, end) {
+    async readBytes(path, start, end, flags) {
         const file = await this.getOrCreateFile(path, {});
-        return await file.readBytes(start, end);
+        return await file.readBytes(start, end, flags);
     }
     writeTxtFile(path, txt, flags = WRITE_NONEXCL_FLAGS) {
         const bytes = buffer_utils_1.utf8.pack(txt);
         return this.writeBytes(path, bytes, flags);
     }
-    async readTxtFile(path) {
-        const { bytes, version } = await this.readBytes(path);
+    async readTxtFile(path, flags) {
+        const { bytes, version } = await this.readBytes(path, undefined, undefined, flags);
         try {
             const txt = (bytes ? buffer_utils_1.utf8.open(bytes) : '');
             return { txt, version };
@@ -594,8 +593,8 @@ class V {
         const txt = JSON.stringify(json);
         return this.writeTxtFile(path, txt, flags);
     }
-    async readJSONFile(path) {
-        const { txt, version } = await this.readTxtFile(path);
+    async readJSONFile(path, flags) {
+        const { txt, version } = await this.readTxtFile(path, flags);
         try {
             const json = JSON.parse(txt);
             return { json, version };
@@ -609,9 +608,9 @@ class V {
         const f = await this.getOrCreateFile(path, flags);
         return f.writeSink(flags.truncate, flags.currentVersion);
     }
-    async getByteSource(path) {
+    async getByteSource(path, flags) {
         const f = await this.getOrCreateFile(path, {});
-        return f.readSrc();
+        return f.readSrc(flags);
     }
 }
 Object.freeze(V.prototype);
@@ -723,7 +722,7 @@ class S {
         this.n.ensureIsWritable();
         const node = await this.n.get(path);
         try {
-            await node.upload(opts);
+            return await node.upload(opts);
         }
         catch (exc) {
             throw (0, common_1.setPathInExc)(exc, path);

package/build/lib-client/3nstorage/xsp-fs/node-in-fs.d.ts

@@ -9,6 +9,7 @@ declare type XAttrsChanges = web3n.files.XAttrsChanges;
 declare type SyncStatus = web3n.files.SyncStatus;
 declare type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
 declare type OptionsToUploadLocal = web3n.files.OptionsToUploadLocal;
+declare type VersionedReadFlags = web3n.files.VersionedReadFlags;
 export declare abstract class NodeInFS<P extends NodePersistance> implements Node {
     protected readonly storage: Storage;
     readonly type: NodeType;
@@ -24,6 +25,7 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
     protected setCurrentVersion(newVersion: number): void;
     readonly isInSyncedStorage: boolean;
     protected constructor(storage: Storage, type: NodeType, name: string, objId: string, currentVersion: number, parentId: string | undefined);
+    protected getObjSrcOfVersion(flags: VersionedReadFlags | undefined): Promise<ObjSource>;
     private updatedXAttrs;
     protected setUpdatedParams(version: number, attrs: CommonAttrs | undefined, xattrs: XAttrs | undefined): void;
     protected getParamsForUpdate(changes: XAttrsChanges | undefined): {
@@ -32,8 +34,14 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
         xattrs?: XAttrs;
     };
     updateXAttrs(changes: XAttrsChanges): Promise<number>;
-    getXAttr(xaName: string): any;
-    listXAttrs(): string[];
+    getXAttr(xaName: string, flags: VersionedReadFlags | undefined): Promise<{
+        attr: any;
+        version: number;
+    }>;
+    listXAttrs(flags: VersionedReadFlags | undefined): Promise<{
+        lst: string[];
+        version: number;
+    }>;
     getAttrs(): CommonAttrs;
     listVersions(): Promise<{
         current?: number;
@@ -41,7 +49,7 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
     }>;
     archiveCurrent(version?: number): Promise<number>;
     removeNonFolderObj(src: FSChangeSrc): Promise<void>;
-    protected removeThisNodeAsLeaf(src: FSChangeSrc): Promise<void>;
+    protected removeThisFromStorageNodes(src: FSChangeSrc): Promise<void>;
     /**
      * This method runs node changing function in an exclusive manner.
      * Returned promise resolves to whatever change function returns.
@@ -74,7 +82,8 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
         uploadVersion: number;
         createOnRemote: boolean;
     } | undefined>;
-    upload(opts: OptionsToUploadLocal | undefined): Promise<void>;
+    upload(opts: OptionsToUploadLocal | undefined): Promise<number | undefined>;
     protected uploadHeaderChange(localVersion: number, uploadVersion: number): Promise<UploadHeaderChange | undefined>;
 }
+export declare function shouldReadCurrentVersion(flags: VersionedReadFlags | undefined): boolean;
 export {};

package/build/lib-client/3nstorage/xsp-fs/node-in-fs.js

@@ -16,7 +16,7 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeInFS = void 0;
+exports.shouldReadCurrentVersion = exports.NodeInFS = void 0;
 /**
  * Everything in this module is assumed to be inside of a file system
  * reliance set.
@@ -58,6 +58,19 @@ class NodeInFS {
         }
         this.currentVersion = newVersion;
     }
+    getObjSrcOfVersion(flags) {
+        if (flags) {
+            const { remoteVersion, archivedVersion } = flags;
+            if (remoteVersion) {
+                const store = this.syncedStorage();
+                return store.getObjSrcOfRemoteVersion(this.objId, remoteVersion);
+            }
+            else if (archivedVersion) {
+                return this.storage.getObjSrc(this.objId, archivedVersion, true);
+            }
+        }
+        return this.storage.getObjSrc(this.objId);
+    }
     updatedXAttrs(changes) {
         return (this.xattrs ?
             (changes ? this.xattrs.makeUpdated(changes) : this.xattrs) :
@@ -90,11 +103,39 @@ class NodeInFS {
             return this.version;
         });
     }
-    getXAttr(xaName) {
-        return (this.xattrs ? this.xattrs.get(xaName) : undefined);
+    async getXAttr(xaName, flags) {
+        if (shouldReadCurrentVersion(flags)) {
+            return {
+                attr: (this.xattrs ? this.xattrs.get(xaName) : undefined),
+                version: this.version
+            };
+        }
+        else {
+            const src = await this.getObjSrcOfVersion(flags);
+            const payload = await this.crypto.readonlyPayload(src);
+            const xattrs = await payload.getXAttrs();
+            return {
+                attr: xattrs.get(xaName),
+                version: src.version
+            };
+        }
     }
-    listXAttrs() {
-        return (this.xattrs ? this.xattrs.list() : []);
+    async listXAttrs(flags) {
+        if (shouldReadCurrentVersion(flags)) {
+            return {
+                lst: (this.xattrs ? this.xattrs.list() : []),
+                version: this.version
+            };
+        }
+        else {
+            const src = await this.getObjSrcOfVersion(flags);
+            const payload = await this.crypto.readonlyPayload(src);
+            const xattrs = await payload.getXAttrs();
+            return {
+                lst: xattrs.list(),
+                version: src.version
+            };
+        }
     }
     getAttrs() {
         return this.attrs;
@@ -138,9 +179,12 @@ class NodeInFS {
     }
     removeNonFolderObj(src) {
         (0, assert_1.assert)(this.type !== 'folder');
-        return this.doChange(true, () => this.removeThisNodeAsLeaf(src));
+        return this.doChange(true, () => this.removeThisFromStorageNodes(src));
     }
-    async removeThisNodeAsLeaf(src) {
+    async removeThisFromStorageNodes(src) {
+        if (this.currentVersion < 0) {
+            return;
+        }
         await this.storage.removeObj(this.objId);
         this.storage.nodes.delete(this);
         this.currentVersion = -1;
@@ -350,11 +394,12 @@ class NodeInFS {
             const uploadHeader = await this.uploadHeaderChange(localVersion, uploadVersion);
             const storage = this.syncedStorage();
             await storage.upload(this.objId, localVersion, uploadVersion, uploadHeader, createOnRemote);
-            await this.doChange(true, async () => {
+            return await this.doChange(true, async () => {
                 storage.dropCachedLocalObjVersionsLessOrEqual(this.objId, localVersion);
                 if (this.currentVersion === localVersion) {
                     this.currentVersion = uploadVersion;
                 }
+                return uploadVersion;
             });
         }
         catch (exc) {
@@ -388,4 +433,14 @@ function copyWithPathIfRemoteEvent(e, path) {
             return e;
     }
 }
+function shouldReadCurrentVersion(flags) {
+    if (flags) {
+        const { archivedVersion, remoteVersion } = flags;
+        if (archivedVersion || remoteVersion) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.shouldReadCurrentVersion = shouldReadCurrentVersion;
 Object.freeze(exports);

package/build/lib-client/3nstorage/xsp-fs/node-persistence.d.ts

@@ -12,6 +12,7 @@ export declare abstract class NodePersistance {
     private zerothHeaderNonce;
     private key;
     private cryptor;
+    private workLabel;
     protected constructor(zerothHeaderNonce: Uint8Array, key: Uint8Array, cryptor: AsyncSBoxCryptor);
     wipe(): void;
     compareKey(keyB64: string): boolean;

package/build/lib-client/3nstorage/xsp-fs/node-persistence.js

@@ -25,6 +25,7 @@ const xsp_files_1 = require("xsp-files");
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const deferred_1 = require("../../../lib-common/processes/deferred");
 const random = require("../../../lib-common/random-node");
+const cryptor_work_labels_1 = require("../../cryptor-work-labels");
 const pv1 = require("./xsp-payload-v1");
 const pv2 = require("./xsp-payload-v2");
 const SEG_SIZE = 16; // in 256-byte blocks = 4K in bytes
@@ -37,6 +38,7 @@ class NodePersistance {
         this.zerothHeaderNonce = zerothHeaderNonce;
         this.key = key;
         this.cryptor = cryptor;
+        this.workLabel = cryptor_work_labels_1.cryptoWorkLabels.makeForNonce('storage', this.zerothHeaderNonce);
     }
     wipe() {
         if (this.key) {
@@ -60,13 +62,13 @@ class NodePersistance {
         if (!this.key) {
             throw new Error("Cannot use wiped object.");
         }
-        return (0, xsp_files_1.makeSegmentsWriter)(this.key, this.zerothHeaderNonce, version, { type: 'new', segSize: SEG_SIZE, payloadFormat: 2 }, random.bytes, this.cryptor);
+        return (0, xsp_files_1.makeSegmentsWriter)(this.key, this.zerothHeaderNonce, version, { type: 'new', segSize: SEG_SIZE, payloadFormat: 2 }, random.bytes, this.cryptor, this.workLabel);
     }
     async segWriterWithBase(newVersion, base) {
         if (!this.key) {
             throw new Error("Cannot use wiped object.");
         }
-        return (0, xsp_files_1.makeSegmentsWriter)(this.key, this.zerothHeaderNonce, newVersion, { type: 'update', base, payloadFormat: 2 }, random.bytes, this.cryptor);
+        return (0, xsp_files_1.makeSegmentsWriter)(this.key, this.zerothHeaderNonce, newVersion, { type: 'update', base, payloadFormat: 2 }, random.bytes, this.cryptor, this.workLabel);
     }
     async decryptedByteSrc(src) {
         if (!this.key) {
@@ -74,7 +76,7 @@ class NodePersistance {
         }
         const version = src.version;
         const header = await src.readHeader();
-        const segReader = await (0, xsp_files_1.makeSegmentsReader)(this.key, this.zerothHeaderNonce, version, header, this.cryptor);
+        const segReader = await (0, xsp_files_1.makeSegmentsReader)(this.key, this.zerothHeaderNonce, version, header, this.cryptor, this.workLabel);
         return {
             version,
             byteSrc: (0, xsp_files_1.makeDecryptedByteSource)(src.segSrc, segReader),
@@ -169,9 +171,9 @@ class NodePersistance {
         if (!this.key) {
             throw new Error("Cannot use wiped object.");
         }
-        const headerContent = await this.cryptor.formatWN.open(initHeader, this.key);
+        const headerContent = await this.cryptor.formatWN.open(initHeader, this.key, this.workLabel);
         const n = (0, xsp_files_1.calculateNonce)(this.zerothHeaderNonce, newVersion);
-        return this.cryptor.formatWN.pack(headerContent, n, this.key);
+        return this.cryptor.formatWN.pack(headerContent, n, this.key, this.workLabel);
     }
 }
 exports.NodePersistance = NodePersistance;

package/build/lib-client/3nstorage/xsp-fs/xsp-payload-v1.js

@@ -67,14 +67,13 @@ class ReadonlyPayloadV1 {
             return;
         }
         return await this.syncProc.startOrChain(async () => {
-            await this.src.seek(start);
-            return await this.src.read(end - start);
+            return await this.src.readAt(start, end - start);
         });
     }
     makeFileByteSource() {
-        const { getPosition, seek, read } = this.src;
+        const { getPosition, seek, readNext, readAt } = this.src;
         return {
-            seek, getPosition, read,
+            seek, getPosition, readNext, readAt,
             getSize: async () => this.size,
         };
     }

package/build/lib-client/3nstorage/xsp-fs/xsp-payload-v2.js

@@ -140,22 +140,28 @@ class ReadonlyPayloadV2 {
     }
     makeFileByteSource() {
         let pos = 0;
+        const seek = async (ofs) => {
+            (0, assert_1.assert)(Number.isInteger(ofs) && (ofs >= 0) && (ofs <= this.size), `Offset must be an integer from 0 to size value, inclusive`);
+            pos = ofs;
+        };
+        const readNext = async (len) => {
+            if (len === undefined) {
+                len = this.size - pos;
+            }
+            const bytes = await this.readSomeContentBytes(pos, pos + len);
+            if (bytes) {
+                pos += bytes.length;
+            }
+            return bytes;
+        };
         return (0, wrapping_1.wrapAndSyncFileSource)({
-            seek: async (ofs) => {
-                (0, assert_1.assert)(Number.isInteger(ofs) && (ofs >= 0) && (ofs <= this.size), `Offset must be an integer from 0 to size value, inclusive`);
-                pos = ofs;
-            },
+            seek,
             getSize: async () => this.size,
             getPosition: async () => pos,
-            read: async (len) => {
-                if (len === undefined) {
-                    len = this.size - pos;
-                }
-                const bytes = await this.readSomeContentBytes(pos, pos + len);
-                if (bytes) {
-                    pos += bytes.length;
-                }
-                return bytes;
+            readNext,
+            readAt: async (pos, len) => {
+                await seek(pos);
+                return await readNext(len);
             }
         });
     }
@@ -784,8 +790,7 @@ function payloadLayoutException(msg, cause) {
     };
 }
 async function sureReadOfBytesFrom(src, ofs, len) {
-    await src.seek(ofs);
-    const bytes = await src.read(len);
+    const bytes = await src.readAt(ofs, len);
     (0, assert_1.assert)(!!bytes && (bytes.length === len));
     return bytes;
 }

package/build/lib-client/cryptor/cryptor-in-worker.js

@@ -22,9 +22,9 @@ const os_1 = require("os");
 const deferred_1 = require("../../lib-common/processes/deferred");
 const error_1 = require("../../lib-common/exceptions/error");
 const path_1 = require("path");
-const protobuf_type_1 = require("../protobuf-type");
-const cryptor_proto_1 = require("../../protos/cryptor.proto");
 const assert_1 = require("../../lib-common/assert");
+const serialization_for_wasm_1 = require("./serialization-for-wasm");
+const cryptor_work_labels_1 = require("../cryptor-work-labels");
 const MAX_IDLE_MILLIS = 60 * 1000;
 const jsWorkerFName = 'worker-js.js';
 const wasmWorkerFName = 'worker-wasm.js';
@@ -73,6 +73,10 @@ class Workers {
         this.maxThreads = Math.max(1, ((typeof maxThreads === 'number') ?
             maxThreads : (0, os_1.cpus)().length - 1));
     }
+    numOfIdle() {
+        return this.idleWorkers.length +
+            Math.max(this.maxThreads - this.allWorkers.size, 0);
+    }
     async getIdleWorker() {
         const idle = this.idleWorkers.pop();
         if (idle) {
@@ -90,7 +94,7 @@ class Workers {
     }
     async doRequest(request, trans, d) {
         if (this.isClosed) {
-            new Error(`Async cryptor is already closed`);
+            throw new Error(`Async cryptor is already closed`);
         }
         const worker = await this.getIdleWorker();
         this.replySinks.set(worker, d);
@@ -240,6 +244,7 @@ const makeInWorkerCryptor = (logErr, logWarning, maxThreads) => {
     (0, assert_1.assert)(typeof logWarning === 'function');
     const workers = new JsWorkers(logErr, logWarning, maxThreads);
     const close = workers.close.bind(workers);
+    const execCounter = new cryptor_work_labels_1.ExecCounter(() => workers.numOfIdle());
     const cryptor = {
         scrypt: (passwd, salt, logN, r, p, dkLen, progressCB) => workers.call('scrypt', [passwd, salt, logN, r, p, dkLen], undefined, progressCB),
         box: {
@@ -247,11 +252,12 @@ const makeInWorkerCryptor = (logErr, logWarning, maxThreads) => {
             generate_pubkey: (sk) => workers.call('box.generate_pubkey', [sk])
         },
         sbox: {
-            open: (c, n, k) => workers.call('sbox.open', [c, n, k]),
-            pack: (m, n, k) => workers.call('sbox.pack', [m, n, k]),
+            canStartUnderWorkLabel: l => execCounter.canStartUnderWorkLabel(l),
+            open: (c, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call('sbox.open', [c, n, k])),
+            pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call('sbox.pack', [m, n, k])),
             formatWN: {
-                open: (cn, k) => workers.call('sbox.formatWN.open', [cn, k]),
-                pack: (m, n, k) => workers.call('sbox.formatWN.pack', [m, n, k])
+                open: (cn, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call('sbox.formatWN.open', [cn, k])),
+                pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call('sbox.formatWN.pack', [m, n, k]))
             }
         },
         signing: {
@@ -266,45 +272,28 @@ exports.makeInWorkerCryptor = makeInWorkerCryptor;
 class WasmWorkers extends Workers {
     constructor(logErr, logWarning, maxThreads) {
         super(workerScriptFor('wasm'), logErr, logWarning, maxThreads);
-        this.reqType = protobuf_type_1.ProtoType.for(cryptor_proto_1.cryptor.Request);
-        this.replyType = protobuf_type_1.ProtoType.for(cryptor_proto_1.cryptor.Reply);
     }
     call(req, interim) {
-        const msg = this.reqType.pack(req);
+        const msg = (0, serialization_for_wasm_1.packRequestToWASM)(req);
         return this.doRequest(msg, undefined, { res: (0, deferred_1.defer)(), interim });
     }
     processReply(replyBytes) {
-        const { res, interim, err } = this.replyType.unpack(replyBytes);
+        const { res, interim, err } = (0, serialization_for_wasm_1.unpackReplyFromWASM)(replyBytes);
         return {
             res: res ? res.val : undefined,
             interim: interim ? interim.val : undefined,
-            err: err ? toLocalErr(err) : undefined,
+            err: err ? (0, serialization_for_wasm_1.toLocalErr)(err) : undefined,
         };
     }
 }
 Object.freeze(WasmWorkers.prototype);
 Object.freeze(WasmWorkers);
-function toArgs(...args) {
-    return args.map(val => ({ val }));
-}
-function toLocalErr(replyErr) {
-    if (replyErr.condition === 'cipher-verification') {
-        return { failedCipherVerification: true };
-    }
-    else if (replyErr.condition === 'signature-verification') {
-        return { failedSignatureVerification: true };
-    }
-    else {
-        return new Error(`WASM cryptor ${replyErr.condition}: ${replyErr.message}`);
-    }
-}
 const makeInWorkerWasmCryptor = (logErr, logWarning, maxThreads) => {
     (0, assert_1.assert)(typeof logErr === 'function');
     (0, assert_1.assert)(typeof logWarning === 'function');
     const workers = new WasmWorkers(logErr, logWarning, maxThreads);
     const close = workers.close.bind(workers);
-    const boolValType = protobuf_type_1.ProtoType.for(cryptor_proto_1.cryptor.BoolVal);
-    const kpairType = protobuf_type_1.ProtoType.for(cryptor_proto_1.cryptor.Keypair);
+    const execCounter = new cryptor_work_labels_1.ExecCounter(() => workers.numOfIdle());
     const cryptor = {
         scrypt: (passwd, salt, logN, r, p, dkLen, progressCB) => workers.call({
             func: 1,
@@ -313,51 +302,52 @@ const makeInWorkerWasmCryptor = (logErr, logWarning, maxThreads) => {
         box: {
             calc_dhshared_key: (pk, sk) => workers.call({
                 func: 2,
-                byteArgs: toArgs(pk, sk)
+                byteArgs: (0, serialization_for_wasm_1.toArgs)(pk, sk)
             }),
             generate_pubkey: (sk) => workers.call({
                 func: 3,
-                byteArgs: toArgs(sk)
+                byteArgs: (0, serialization_for_wasm_1.toArgs)(sk)
             })
         },
         sbox: {
-            open: (c, n, k) => workers.call({
+            canStartUnderWorkLabel: l => execCounter.canStartUnderWorkLabel(l),
+            open: (c, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call({
                 func: 4,
-                byteArgs: toArgs(c, n, k)
-            }),
-            pack: (m, n, k) => workers.call({
+                byteArgs: (0, serialization_for_wasm_1.toArgs)(c, n, k)
+            })),
+            pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call({
                 func: 5,
-                byteArgs: toArgs(m, n, k)
-            }),
+                byteArgs: (0, serialization_for_wasm_1.toArgs)(m, n, k)
+            })),
             formatWN: {
-                open: (cn, k) => workers.call({
+                open: (cn, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call({
                     func: 6,
-                    byteArgs: toArgs(cn, k)
-                }),
-                pack: (m, n, k) => workers.call({
+                    byteArgs: (0, serialization_for_wasm_1.toArgs)(cn, k)
+                })),
+                pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call({
                     func: 7,
-                    byteArgs: toArgs(m, n, k)
-                })
+                    byteArgs: (0, serialization_for_wasm_1.toArgs)(m, n, k)
+                }))
             }
         },
         signing: {
             generate_keypair: async (seed) => {
                 const rep = await workers.call({
                     func: 8,
-                    byteArgs: toArgs(seed)
+                    byteArgs: (0, serialization_for_wasm_1.toArgs)(seed)
                 });
-                return kpairType.unpack(rep);
+                return (0, serialization_for_wasm_1.unpackSigningKeyPair)(rep);
             },
             signature: (m, sk) => workers.call({
                 func: 9,
-                byteArgs: toArgs(m, sk)
+                byteArgs: (0, serialization_for_wasm_1.toArgs)(m, sk)
             }),
             verify: async (sig, m, pk) => {
                 const rep = await workers.call({
                     func: 10,
-                    byteArgs: toArgs(sig, m, pk)
+                    byteArgs: (0, serialization_for_wasm_1.toArgs)(sig, m, pk)
                 });
-                return boolValType.unpack(rep).val;
+                return (0, serialization_for_wasm_1.unpackBoolVal)(rep);
             }
         }
     };