core-3nweb-client-lib 0.26.1 → 0.27.3

package/build/lib-common/mid-sigs-NaCl-Ed.js

@@ -132,7 +132,7 @@ var idProvider;
     idProvider.KID_BYTES_LENGTH = 9;
     idProvider.MAX_USER_CERT_VALIDITY = 24 * 60 * 60;
     function makeSelfSignedCert(address, validityPeriod, sjkey, arrFactory) {
-        const skey = jwkeys_1.keyFromJson(sjkey, exports.KEY_USE.ROOT, ecma_nacl_1.signing.JWK_ALG_NAME, ecma_nacl_1.signing.SECRET_KEY_LENGTH);
+        const skey = (0, jwkeys_1.keyFromJson)(sjkey, exports.KEY_USE.ROOT, ecma_nacl_1.signing.JWK_ALG_NAME, ecma_nacl_1.signing.SECRET_KEY_LENGTH);
         const pkey = {
             use: sjkey.use,
             alg: sjkey.alg,
@@ -161,7 +161,7 @@ var idProvider;
         const rootPair = genSignKeyPair(exports.KEY_USE.ROOT, idProvider.KID_BYTES_LENGTH, random, arrFactory);
         const now = Math.floor(Date.now() / 1000);
         const rootCert = makeCert(rootPair.pkey, address, address, now, now + validityPeriod, rootPair.skey, arrFactory);
-        return { cert: rootCert, skey: jwkeys_1.keyToJson(rootPair.skey) };
+        return { cert: rootCert, skey: (0, jwkeys_1.keyToJson)(rootPair.skey) };
     }
     idProvider.generateRootKey = generateRootKey;
     /**
@@ -178,11 +178,11 @@ var idProvider;
         if (validityPeriod < 1) {
             throw new Error(`Illegal validity period: ${validityPeriod}`);
         }
-        const rootKey = jwkeys_1.keyFromJson(rootJKey, exports.KEY_USE.ROOT, ecma_nacl_1.signing.JWK_ALG_NAME, ecma_nacl_1.signing.SECRET_KEY_LENGTH);
+        const rootKey = (0, jwkeys_1.keyFromJson)(rootJKey, exports.KEY_USE.ROOT, ecma_nacl_1.signing.JWK_ALG_NAME, ecma_nacl_1.signing.SECRET_KEY_LENGTH);
         const provPair = genSignKeyPair(exports.KEY_USE.PROVIDER, idProvider.KID_BYTES_LENGTH, random, arrFactory);
         const now = Math.floor(Date.now() / 1000);
         const rootCert = makeCert(provPair.pkey, address, address, now, now + validityPeriod, rootKey, arrFactory);
-        return { cert: rootCert, skey: jwkeys_1.keyToJson(provPair.skey) };
+        return { cert: rootCert, skey: (0, jwkeys_1.keyToJson)(provPair.skey) };
     }
     idProvider.generateProviderKey = generateProviderKey;
     /**
@@ -202,7 +202,7 @@ var idProvider;
         if ((validityPeriod < 1) || (validityPeriod > idProvider.MAX_USER_CERT_VALIDITY)) {
             throw new Error(`Given certificate validity is illegal: ${validityPeriod}`);
         }
-        let signKey = jwkeys_1.keyFromJson(signJKey, exports.KEY_USE.PROVIDER, ecma_nacl_1.signing.JWK_ALG_NAME, ecma_nacl_1.signing.SECRET_KEY_LENGTH);
+        let signKey = (0, jwkeys_1.keyFromJson)(signJKey, exports.KEY_USE.PROVIDER, ecma_nacl_1.signing.JWK_ALG_NAME, ecma_nacl_1.signing.SECRET_KEY_LENGTH);
         signJKey = undefined;
         if (!arrFactory) {
             arrFactory = ecma_nacl_1.arrays.makeFactory();
@@ -247,7 +247,7 @@ var relyingParty;
 (function (relyingParty) {
     const minValidityPeriodForCert = 20 * 60;
     function verifyCertAndGetPubKey(signedCert, use, validAt, arrFactory, issuer, issuerPKey) {
-        const cert = jwkeys_1.getKeyCert(signedCert);
+        const cert = (0, jwkeys_1.getKeyCert)(signedCert);
         if ((validAt < (cert.issuedAt - minValidityPeriodForCert))
             || (cert.expiresAt <= validAt)) {
             throw makeTimeMismatchException(`Certificate is not valid at a given moment ${validAt}, cause it is issued at ${cert.issuedAt}, and expires at ${cert.expiresAt}`);
@@ -265,7 +265,7 @@ var relyingParty;
         let sig;
         let load;
         try {
-            pkey = jwkeys_1.keyFromJson(cert.cert.publicKey, use, ecma_nacl_1.signing.JWK_ALG_NAME, ecma_nacl_1.signing.PUBLIC_KEY_LENGTH);
+            pkey = (0, jwkeys_1.keyFromJson)(cert.cert.publicKey, use, ecma_nacl_1.signing.JWK_ALG_NAME, ecma_nacl_1.signing.PUBLIC_KEY_LENGTH);
             sig = buffer_utils_1.base64.open(signedCert.sig);
             load = buffer_utils_1.base64.open(signedCert.load);
         }
@@ -292,7 +292,7 @@ var relyingParty;
         // root certificate must be valid when provider's certificate was issued
         let rootValidityMoment;
         try {
-            rootValidityMoment = jwkeys_1.getKeyCert(certs.prov).issuedAt;
+            rootValidityMoment = (0, jwkeys_1.getKeyCert)(certs.prov).issuedAt;
         }
         catch (err) {
             throw makeMalformedCertsException(`Provider's certificate is malformed`, err);
@@ -305,7 +305,7 @@ var relyingParty;
         // provider's certificate must be valid when user's certificate was issued
         let provValidityMoment;
         try {
-            provValidityMoment = jwkeys_1.getKeyCert(certs.user).issuedAt;
+            provValidityMoment = (0, jwkeys_1.getKeyCert)(certs.user).issuedAt;
         }
         catch (err) {
             throw makeMalformedCertsException(`User's certificate is malformed`, err);
@@ -389,7 +389,7 @@ var relyingParty;
         }
         let cert;
         try {
-            cert = jwkeys_1.getKeyCert(keyCert);
+            cert = (0, jwkeys_1.getKeyCert)(keyCert);
         }
         catch (err) {
             throw makeMalformedCertsException(`Cannot read certificate`, err);
@@ -428,7 +428,7 @@ var relyingParty;
         // time moment, for which user's certificate chain must be valid
         let chainValidityMoment;
         try {
-            chainValidityMoment = jwkeys_1.getKeyCert(pubKeyCert).issuedAt;
+            chainValidityMoment = (0, jwkeys_1.getKeyCert)(pubKeyCert).issuedAt;
         }
         catch (err) {
             throw makeMalformedCertsException(`Cannot read certificate`, err);
@@ -443,11 +443,11 @@ var relyingParty;
 })(relyingParty = exports.relyingParty || (exports.relyingParty = {}));
 Object.freeze(relyingParty);
 function correlateSKeyWithItsCert(skey, cert) {
-    const pkey = jwkeys_1.keyFromJson(cert.cert.publicKey, skey.use, ecma_nacl_1.signing.JWK_ALG_NAME, ecma_nacl_1.signing.PUBLIC_KEY_LENGTH);
+    const pkey = (0, jwkeys_1.keyFromJson)(cert.cert.publicKey, skey.use, ecma_nacl_1.signing.JWK_ALG_NAME, ecma_nacl_1.signing.PUBLIC_KEY_LENGTH);
     if (!((pkey.kid === skey.kid)
         && (pkey.use === skey.use)
         && (pkey.alg === skey.alg)
-        && ecma_nacl_1.compareVectors(ecma_nacl_1.signing.extract_pkey(skey.k), pkey.k))) {
+        && (0, ecma_nacl_1.compareVectors)(ecma_nacl_1.signing.extract_pkey(skey.k), pkey.k))) {
         throw new Error("Key does not correspond to certificate.");
     }
 }
@@ -471,7 +471,7 @@ var user;
      * keys.
      */
     function makeMailerIdSigner(signKey, userCert, provCert, assertionValidity = user.MAX_SIG_VALIDITY, arrFactory) {
-        const certificate = jwkeys_1.getKeyCert(userCert);
+        const certificate = (0, jwkeys_1.getKeyCert)(userCert);
         if (signKey.use !== exports.KEY_USE.SIGN) {
             throw new Error(`Given key ${signKey.kid} has incorrect use: ${signKey.use}`);
         }

package/build/lib-common/objs-on-disk/file-layout.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { Layout } from "xsp-files";
+import { DiffInfo } from "../service-api/3nstorage/owner";
 export interface HeaderChunkInfo {
     len: number;
     fileOfs: number;
@@ -60,4 +61,22 @@ export declare class ObjVersionBytesLayout {
     addSegsOnFile(thisVerOfs: number, len: number, fileOfs: number): void;
     addBaseSegsOnFile(thisVerOfs: number, baseVerOfs: number, len: number, fileOfs: number): void;
     getBaseVersion(): number | undefined;
+    calcBaseAbsorptionParams(baseLayout: ObjVersionBytesLayout): BaseAbsorptionParams;
+    applyAbsorptionParams(params: BaseAbsorptionParams): void;
+    diffFromBase(): {
+        diff: DiffInfo;
+        newSegsPackOrder: FiniteChunk[];
+    };
 }
+interface ChunkCopyOp {
+    ofsInSrcFile: number;
+    len: number;
+    ofsInDstFile: number;
+}
+export interface BaseAbsorptionParams {
+    newBytesEnd: number;
+    newBase: number | undefined;
+    chunkReplacements: Map<number, (NewSegsChunkOnDisk | BaseSegsChunk)[]>;
+    copyOps: ChunkCopyOp[];
+}
+export {};

package/build/lib-common/objs-on-disk/file-layout.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2019 3NSoft Inc.
+ Copyright (C) 2019,  2022 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -81,7 +81,12 @@ class ObjVersionBytesLayout {
         return this.segsLayoutFrozen;
     }
     isFileComplete() {
-        return !this.segsChunks.find(chunk => ((chunk.type === 'new') || (chunk.type === 'new-endless')));
+        for (const chunk of this.segsChunks) {
+            if ((chunk.type === 'new') || (chunk.type === 'new-endless')) {
+                return true;
+            }
+        }
+        return true;
     }
     getLayoutOfs() {
         return this.bytesEnd;
@@ -90,8 +95,8 @@ class ObjVersionBytesLayout {
         return this.headerChunk;
     }
     segsLocations(thisVerOfs, len) {
-        assert_1.assert(Number.isInteger(thisVerOfs) && (thisVerOfs >= 0));
-        assert_1.assert(Number.isInteger(len) && (len >= 0));
+        (0, assert_1.assert)(Number.isInteger(thisVerOfs) && (thisVerOfs >= 0));
+        (0, assert_1.assert)(Number.isInteger(len) && (len >= 0));
         const segInfos = [];
         const end = thisVerOfs + len;
         for (let i = 0; (i < this.segsChunks.length) && (len > 0); i += 1) {
@@ -118,7 +123,7 @@ class ObjVersionBytesLayout {
                 len -= chop.len;
             }
             else {
-                const chop = json_utils_1.copy(chunk);
+                const chop = (0, json_utils_1.copy)(chunk);
                 chop.thisVerOfs = thisVerOfs;
                 if (chunk.type === 'new-endless') {
                     chop.type = 'new';
@@ -178,7 +183,7 @@ class ObjVersionBytesLayout {
     }
     addHeader(len, fileOfs) {
         this.ensureExpectedFileOfs(fileOfs);
-        assert_1.assert(Number.isInteger(len) && (len >= 0));
+        (0, assert_1.assert)(Number.isInteger(len) && (len >= 0));
         if (this.headerChunk) {
             throw new Error(`Header added second time to obj version bytes layout`);
         }
@@ -188,8 +193,8 @@ class ObjVersionBytesLayout {
     }
     addSegsOnFile(thisVerOfs, len, fileOfs) {
         this.ensureExpectedFileOfs(fileOfs);
-        assert_1.assert(Number.isInteger(thisVerOfs) && (thisVerOfs >= 0));
-        assert_1.assert(Number.isInteger(len) && (len >= 0));
+        (0, assert_1.assert)(Number.isInteger(thisVerOfs) && (thisVerOfs >= 0));
+        (0, assert_1.assert)(Number.isInteger(len) && (len >= 0));
         const s = {
             type: 'new-on-disk', thisVerOfs, len, fileOfs
         };
@@ -198,9 +203,9 @@ class ObjVersionBytesLayout {
     }
     addBaseSegsOnFile(thisVerOfs, baseVerOfs, len, fileOfs) {
         this.ensureExpectedFileOfs(fileOfs);
-        assert_1.assert(Number.isInteger(thisVerOfs) && (thisVerOfs >= 0));
-        assert_1.assert(Number.isInteger(baseVerOfs) && (baseVerOfs >= 0));
-        assert_1.assert(Number.isInteger(len) && (len >= 0));
+        (0, assert_1.assert)(Number.isInteger(thisVerOfs) && (thisVerOfs >= 0));
+        (0, assert_1.assert)(Number.isInteger(baseVerOfs) && (baseVerOfs >= 0));
+        (0, assert_1.assert)(Number.isInteger(len) && (len >= 0));
         const s = {
             type: 'base-on-disk', thisVerOfs, baseVerOfs, len, fileOfs
         };
@@ -210,6 +215,119 @@ class ObjVersionBytesLayout {
     getBaseVersion() {
         return this.baseVersion;
     }
+    calcBaseAbsorptionParams(baseLayout) {
+        (0, assert_1.assert)(this.isFileComplete() && baseLayout.isFileComplete());
+        const chunkReplacements = new Map();
+        const copyOps = [];
+        let newBytesEnd = this.bytesEnd;
+        for (let i = 0; i < this.segsChunks.length; i += 1) {
+            const chunk = this.segsChunks[i];
+            if (chunk.type === 'new-on-disk') {
+                continue;
+            }
+            if (chunk.type !== 'base') {
+                throw new Error(`Absorbing base is not implemented on chunk type ${chunk.type}.`);
+            }
+            const replacements = [];
+            // start in base version offset
+            let start = chunk.baseVerOfs;
+            const end = start + chunk.len;
+            for (let j = 0; j < baseLayout.segsChunks.length; j += 1) {
+                const bChunk = baseLayout.segsChunks[j];
+                if ((bChunk.type !== 'new-on-disk')
+                    && (bChunk.type !== 'base')) {
+                    throw new Error(`Absorbing base is not implemented on chunk type ${chunk.type}.`);
+                }
+                const bEnd = bChunk.thisVerOfs + bChunk.len;
+                if (bEnd <= start) {
+                    continue;
+                }
+                const cut = Math.min(end, bEnd);
+                const len = cut - start;
+                const thisVerOfs = chunk.thisVerOfs + (start - chunk.baseVerOfs);
+                const ofsIntoBChunk = start - bChunk.thisVerOfs;
+                if (bChunk.type === 'new-on-disk') {
+                    const op = {
+                        ofsInSrcFile: bChunk.fileOfs + ofsIntoBChunk,
+                        len,
+                        ofsInDstFile: newBytesEnd
+                    };
+                    copyOps.push(op);
+                    const replacementChunk = {
+                        type: 'new-on-disk',
+                        fileOfs: newBytesEnd,
+                        len,
+                        thisVerOfs
+                    };
+                    replacements.push(replacementChunk);
+                    newBytesEnd += len;
+                }
+                else if (bChunk.type === 'base') {
+                    const replacementChunk = {
+                        type: 'base',
+                        len,
+                        thisVerOfs,
+                        baseVerOfs: bChunk.baseVerOfs + ofsIntoBChunk
+                    };
+                    replacements.push(replacementChunk);
+                }
+                else {
+                    throw new Error(`This shouldn't be unreachable. Unimplemented chunk type?`);
+                }
+                start = cut;
+                if (start === end) {
+                    break;
+                }
+            }
+            (0, assert_1.assert)(start === end);
+            chunkReplacements.set(i, replacements);
+        }
+        return {
+            chunkReplacements, copyOps, newBytesEnd,
+            newBase: baseLayout.baseVersion
+        };
+    }
+    applyAbsorptionParams(params) {
+        this.bytesEnd = params.newBytesEnd;
+        this.baseVersion = params.newBase;
+        const changes = [];
+        for (const [segInd, newSegs] of params.chunkReplacements.entries()) {
+            const initSeg = this.segsChunks[segInd];
+            changes.push([initSeg, newSegs]);
+        }
+        for (const [initSeg, newSegs] of changes) {
+            const ind = this.segsChunks.indexOf(initSeg);
+            this.segsChunks.splice(ind, 1, ...newSegs);
+        }
+    }
+    diffFromBase() {
+        (0, assert_1.assert)(!!this.baseVersion && this.isFileComplete());
+        const sections = [];
+        const newSegsPackOrder = [];
+        let segsSize = 0;
+        let ofsInNewSegsPack = 0;
+        for (let i = 0; i < this.segsChunks.length; i += 1) {
+            const seg = this.segsChunks[i];
+            if ((seg.type === 'base') || (seg.type === 'base-on-disk')) {
+                sections.push([0, seg.baseVerOfs, seg.len]);
+            }
+            else {
+                // XXX with simplification second element (bizarre 0) will be gone
+                sections.push([1, 0, seg.len]);
+                newSegsPackOrder.push({
+                    thisVerOfs: seg.thisVerOfs, len: seg.len,
+                });
+                ofsInNewSegsPack += seg.len;
+            }
+            segsSize += seg.len;
+        }
+        const diff = {
+            baseVersion: this.baseVersion,
+            sections,
+            segsSize
+        };
+        return { diff, newSegsPackOrder };
+    }
 }
 exports.ObjVersionBytesLayout = ObjVersionBytesLayout;
 Object.freeze(ObjVersionBytesLayout.prototype);
@@ -223,7 +341,7 @@ function layoutSectionsToSegsChunks(sections) {
         }
         const chunk = layoutSectionToSegsChunk(section);
         if (chunk.type === 'new-endless') {
-            assert_1.assert(sections[sections.length - 1] === section, `Infinite layout section must be the last section`);
+            (0, assert_1.assert)(sections[sections.length - 1] === section, `Infinite layout section must be the last section`);
         }
         else {
             chunks.push(chunk);

package/build/lib-common/objs-on-disk/obj-file.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { Layout } from 'xsp-files';
-import { FiniteSegsChunk } from './file-layout';
+import { FiniteSegsChunk, FiniteChunk } from './file-layout';
+import { DiffInfo } from '../service-api/3nstorage/owner';
 export declare class ObjVersionFile {
     private path;
     private readonly layout;
@@ -9,9 +10,14 @@ export declare class ObjVersionFile {
     static forExisting(path: string): Promise<ObjVersionFile>;
     static createNew(path: string): Promise<ObjVersionFile>;
     private startCreatingFileOnDisk;
-    moveFile(newPath: string): Promise<void>;
+    moveFile(newPath: string, newHeader: Uint8Array | undefined): Promise<void>;
     removeFile(): Promise<void>;
     saveLayout(): Promise<void>;
+    /**
+     * @param fd already openned file descriptor
+     * @param ofs is an optional offset at which layout is written, when we need
+     * value different from current one in layout.
+     */
     private recordLayout;
     private withRWFile;
     getTotalSegsLen(): number;
@@ -29,6 +35,11 @@ export declare class ObjVersionFile {
     setSegsLayout(layout: Layout, saveLayout: boolean): Promise<void>;
     truncateEndlessLayout(): void;
     isFileComplete(): boolean;
+    absorbImmediateBaseVersion(baseVer: number, path: string): Promise<void>;
+    diffFromBase(): {
+        diff: DiffInfo;
+        newSegsPackOrder: FiniteChunk[];
+    };
 }
 export interface ObjFileParsingException extends web3n.RuntimeException {
     type: 'obj-file-parsing';

package/build/lib-common/objs-on-disk/obj-file.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2019 - 2020 3NSoft Inc.
+ Copyright (C) 2019 - 2020, 2022 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -27,6 +27,7 @@ const v1_obj_file_format_1 = require("./v1-obj-file-format");
 const fs_1 = require("fs");
 const file_layout_1 = require("./file-layout");
 const big_endian_1 = require("../big-endian");
+const assert_1 = require("../assert");
 class ObjVersionFile {
     constructor(path, layout) {
         this.path = path;
@@ -35,20 +36,8 @@ class ObjVersionFile {
         Object.seal(this);
     }
     static async forExisting(path) {
-        const fd = await fs.open(path, 'r');
-        try {
-            const layout = await parseObjVersionBytesLayout(fd)
-                .catch((err) => {
-                if (err.type === 'obj-file-parsing') {
-                    err.path = path;
-                }
-                throw err;
-            });
-            return new ObjVersionFile(path, layout);
-        }
-        finally {
-            await fs.close(fd).catch(noop);
-        }
+        const layout = await readLayoutFrom(path);
+        return new ObjVersionFile(path, layout);
     }
     static async createNew(path) {
         const layout = file_layout_1.ObjVersionBytesLayout.forNewFile();
@@ -59,10 +48,22 @@ class ObjVersionFile {
     startCreatingFileOnDisk() {
         this.writeProc.addStarted(createNewV1File(this.path));
     }
-    moveFile(newPath) {
+    moveFile(newPath, newHeader) {
         return this.writeProc.startOrChain(async () => {
+            var _a;
             await fs.rename(this.path, newPath);
             this.path = newPath;
+            if (newHeader) {
+                (0, assert_1.assert)(newHeader.length === ((_a = this.layout.headerLocation()) === null || _a === void 0 ? void 0 : _a.len));
+                const headerOfs = this.layout.headerLocation().fileOfs;
+                const fd = await fs.open(this.path, 'r+');
+                try {
+                    await fs.write(fd, headerOfs, (0, buffer_utils_1.toBuffer)(newHeader));
+                }
+                finally {
+                    await fs.close(fd).catch(noop);
+                }
+            }
         });
     }
     removeFile() {
@@ -71,9 +72,16 @@ class ObjVersionFile {
     saveLayout() {
         return this.withRWFile(fd => this.recordLayout(fd));
     }
-    async recordLayout(fd) {
+    /**
+     * @param fd already openned file descriptor
+     * @param ofs is an optional offset at which layout is written, when we need
+     * value different from current one in layout.
+     */
+    async recordLayout(fd, ofs) {
         const layoutBytes = this.layout.toBytes();
-        const ofs = this.layout.getLayoutOfs();
+        if (!ofs) {
+            ofs = this.layout.getLayoutOfs();
+        }
         await fs.writeFromBuf(fd, ofs, layoutBytes);
         await recordLayoutOffsetInV1(fd, ofs);
         await fs.ftruncate(fd, ofs + layoutBytes.length);
@@ -82,7 +90,7 @@ class ObjVersionFile {
         return this.writeProc.startOrChain(async () => {
             const fd = await fs.open(this.path, 'r+')
                 .catch(exc => {
-                throw error_1.errWithCause(exc, `Can't open for writing obj-version file ${this.path}`);
+                throw (0, error_1.errWithCause)(exc, `Can't open for writing obj-version file ${this.path}`);
             });
             try {
                 return await action(fd);
@@ -101,7 +109,7 @@ class ObjVersionFile {
     saveHeader(header, saveLayout) {
         return this.withRWFile(async (fd) => {
             const ofs = this.layout.getLayoutOfs();
-            await fs.writeFromBuf(fd, ofs, buffer_utils_1.toBuffer(header));
+            await fs.writeFromBuf(fd, ofs, (0, buffer_utils_1.toBuffer)(header));
             this.layout.addHeader(header.length, ofs);
             if (saveLayout) {
                 await this.recordLayout(fd);
@@ -111,7 +119,7 @@ class ObjVersionFile {
     saveSegs(segsChunks, thisVerOfs, baseVerOfs, saveLayout) {
         return this.withRWFile(async (fd) => {
             const ofs = this.layout.getLayoutOfs();
-            await fs.writeFromBuf(fd, ofs, buffer_utils_1.toBuffer(segsChunks));
+            await fs.writeFromBuf(fd, ofs, (0, buffer_utils_1.toBuffer)(segsChunks));
             if (baseVerOfs === undefined) {
                 this.layout.addSegsOnFile(thisVerOfs, segsChunks.length, ofs);
             }
@@ -128,18 +136,25 @@ class ObjVersionFile {
     }
     async withROFile(action) {
         const path = this.path;
-        const fd = await fs.open(path, 'r')
-            .catch((exc) => {
+        let fd;
+        try {
+            fd = await fs.open(path, 'r');
+        }
+        catch (exc) {
+            // in some use cases version file can be moved, and for this reason
+            // we make second attempt if path is newer
             if (exc.notFound && (path !== this.path)) {
-                return fs.open(this.path, 'r');
+                try {
+                    fd = await fs.open(this.path, 'r');
+                }
+                catch (exc) {
+                    throw (0, error_1.errWithCause)(exc, `Can't open for reading obj version file ${this.path}`);
+                }
             }
             else {
                 throw exc;
             }
-        })
-            .catch(exc => {
-            throw error_1.errWithCause(exc, `Can't open for reading obj version file ${this.path}`);
-        });
+        }
         try {
             return await action(fd);
         }
@@ -171,7 +186,7 @@ class ObjVersionFile {
             return;
         }
         await this.withROFile(async (fd) => {
-            const src = fs_1.createReadStream('', {
+            const src = (0, fs_1.createReadStream)('', {
                 fd,
                 autoClose: false,
                 start: chunkInfo.fileOfs,
@@ -204,7 +219,7 @@ class ObjVersionFile {
             for (const chunk of chunks) {
                 if ((chunk.type === 'new-on-disk')
                     || (chunk.type === 'base-on-disk')) {
-                    const src = fs_1.createReadStream('', {
+                    const src = (0, fs_1.createReadStream)('', {
                         fd,
                         autoClose: false,
                         start: chunk.fileOfs,
@@ -235,13 +250,43 @@ class ObjVersionFile {
     isFileComplete() {
         return this.layout.isFileComplete();
     }
+    async absorbImmediateBaseVersion(baseVer, path) {
+        (0, assert_1.assert)(baseVer === this.layout.getBaseVersion());
+        const baseLayout = await readLayoutFrom(path);
+        const absorptionParams = this.layout.calcBaseAbsorptionParams(baseLayout);
+        const src = await fs.open(path, 'r');
+        await this.withRWFile(async (fd) => {
+            if (absorptionParams.copyOps.length > 0) {
+                await this.recordLayout(fd, absorptionParams.newBytesEnd);
+                let buf = Buffer.allocUnsafe(absorptionParams.copyOps[0].len);
+                for (const op of absorptionParams.copyOps) {
+                    if (buf.length < op.len) {
+                        buf = Buffer.allocUnsafe(op.len);
+                    }
+                    const chunk = ((op.len < buf.length) ?
+                        buf.slice(0, op.len) : buf);
+                    await fs.readToBuf(src, op.ofsInSrcFile, chunk);
+                    await fs.writeFromBuf(fd, op.ofsInDstFile, chunk);
+                }
+            }
+            this.layout.applyAbsorptionParams(absorptionParams);
+            await this.recordLayout(fd);
+        })
+            .then(() => fs.close(src).catch(noop), async (exc) => {
+            await fs.close(src).catch(noop);
+            throw exc;
+        });
+    }
+    diffFromBase() {
+        return this.layout.diffFromBase();
+    }
 }
 exports.ObjVersionFile = ObjVersionFile;
 Object.freeze(ObjVersionFile.prototype);
 Object.freeze(ObjVersionFile);
 function noop() { }
 async function pipeBytes(src, sink) {
-    const deferred = deferred_1.defer();
+    const deferred = (0, deferred_1.defer)();
     src.pipe(sink, { end: false });
     src.on('error', (err) => {
         deferred.reject(err);
@@ -274,8 +319,8 @@ async function parseObjVersionBytesLayout(fd) {
         throw exc;
     });
     const fileStart = fstBytes.slice(0, 4);
-    if (bytes_equal_1.bytesEqual(fileStart, v1_obj_file_format_1.V1_FILE_START)) {
-        const layoutOfs = big_endian_1.uintFrom8Bytes(fstBytes, 4);
+    if ((0, bytes_equal_1.bytesEqual)(fileStart, v1_obj_file_format_1.V1_FILE_START)) {
+        const layoutOfs = (0, big_endian_1.uintFrom8Bytes)(fstBytes, 4);
         if (layoutOfs === 0) {
             throw parsingException(`Obj version file is in incomplete state`);
         }
@@ -302,10 +347,26 @@ async function createNewV1File(path) {
 }
 async function recordLayoutOffsetInV1(fd, ofs) {
     const ofsInBytes = Buffer.allocUnsafe(8);
-    big_endian_1.packUintTo8Bytes(ofs, ofsInBytes, 0);
+    (0, big_endian_1.packUintTo8Bytes)(ofs, ofsInBytes, 0);
     await fs.writeFromBuf(fd, v1_obj_file_format_1.V1_FILE_START.length, ofsInBytes)
         .catch(exc => {
-        throw error_1.errWithCause(exc, `Can't record layout offset in obj file`);
+        throw (0, error_1.errWithCause)(exc, `Can't record layout offset in obj file`);
     });
 }
+async function readLayoutFrom(path) {
+    const fd = await fs.open(path, 'r');
+    try {
+        const layout = await parseObjVersionBytesLayout(fd)
+            .catch((err) => {
+            if (err.type === 'obj-file-parsing') {
+                err.path = path;
+            }
+            throw err;
+        });
+        return layout;
+    }
+    finally {
+        await fs.close(fd).catch(noop);
+    }
+}
 Object.freeze(exports);

package/build/lib-common/objs-on-disk/utils.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Layout } from 'xsp-files';
 import { DiffInfo } from '../service-api/3nstorage/owner';
 import { ObjVersionFile } from './obj-file';

package/build/lib-common/objs-on-disk/utils.js

@@ -42,7 +42,7 @@ function diffToLayout(diff) {
 }
 exports.diffToLayout = diffToLayout;
 async function streamToObjFile(file, content, src, maxBufferLen) {
-    let deferred = deferred_1.defer();
+    let deferred = (0, deferred_1.defer)();
     const contentIter = content.values();
     let chunk = undefined;
     let buf = new bytes_fifo_buffer_1.BytesFIFOBuffer();
@@ -111,7 +111,7 @@ async function streamToObjFile(file, content, src, maxBufferLen) {
     });
     src.on('end', () => {
         if (chunk) {
-            complete(file_1.makeFileException(file_1.Code.endOfFile, '<input stream>'));
+            complete((0, file_1.makeFileException)('endOfFile', '<input stream>'));
         }
         else {
             complete();
@@ -125,7 +125,7 @@ exports.streamToObjFile = streamToObjFile;
 function chunksInOrderedStream(len, headerLen, segsOfs) {
     const chunks = [];
     if (typeof headerLen === 'number') {
-        assert_1.assert(len >= headerLen);
+        (0, assert_1.assert)(len >= headerLen);
         chunks.push({ type: 'header', len: headerLen });
         len -= headerLen;
     }