@super-protocol/swarm-contracts-sdk 0.0.1-beta.1

package/dist/mjs/providers/storage/fs-storage-provider.js

@@ -0,0 +1,132 @@
+import fs from 'fs';
+import * as path from 'path';
+import { NotFoundError } from '../../errors/index.js';
+export class FSStorageProvider {
+    bucket;
+    prefix;
+    constructor(credentials) {
+        this.bucket = credentials.bucket;
+        this.prefix = credentials.prefix;
+    }
+    getFullPath(remotePath) {
+        return path.join(this.bucket, this.prefix, remotePath);
+    }
+    writeWithProgress(inputStream, outputStream, contentLength, progressListener) {
+        let bytesWritten = 0;
+        let failed = false;
+        return new Promise((resolve, reject) => {
+            outputStream.once('finish', resolve).once('error', (err) => {
+                failed = true;
+                if (!inputStream.destroyed)
+                    inputStream.destroy(err);
+                reject(err);
+            });
+            outputStream.on('drain', () => {
+                if (!inputStream.destroyed && inputStream.isPaused && inputStream.isPaused()) {
+                    inputStream.resume();
+                }
+            });
+            inputStream.on('data', (chunk) => {
+                if (failed || outputStream.destroyed || outputStream.writableEnded)
+                    return;
+                let canContinue = true;
+                try {
+                    canContinue = outputStream.write(chunk);
+                }
+                catch (err) {
+                    failed = true;
+                    if (!inputStream.destroyed)
+                        inputStream.destroy(err);
+                    return;
+                }
+                bytesWritten += chunk.length;
+                if (progressListener) {
+                    progressListener(contentLength, bytesWritten);
+                }
+                if (!canContinue && !inputStream.destroyed)
+                    inputStream.pause();
+            });
+            inputStream
+                .once('end', () => {
+                outputStream.end();
+            })
+                .once('error', (err) => outputStream.destroy(err));
+        });
+    }
+    async uploadFile(inputStream, remotePath, contentLength, progressListener) {
+        if (!inputStream) {
+            throw new Error('Input stream is undefined');
+        }
+        const fullPath = this.getFullPath(remotePath);
+        await this.ensureDirectoryExists(path.dirname(fullPath));
+        const outputStream = fs.createWriteStream(fullPath);
+        await this.writeWithProgress(inputStream, outputStream, contentLength, progressListener);
+    }
+    async downloadFile(remotePath, config, progressListener) {
+        const offset = config.offset ?? 0;
+        const filePath = this.getFullPath(remotePath);
+        let stats;
+        try {
+            stats = await fs.promises.stat(filePath);
+        }
+        catch {
+            throw new NotFoundError(`File does not exist: ${filePath}`);
+        }
+        const total = offset + (config.length ?? 0) || stats.size;
+        let current = offset;
+        const readStream = fs.createReadStream(filePath, {
+            start: offset,
+            end: total,
+        });
+        readStream.on('data', (chunk) => {
+            current += chunk.length;
+            if (progressListener) {
+                progressListener(total, current);
+            }
+        });
+        return readStream;
+    }
+    async deleteObject(remotePath) {
+        await fs.promises.rm(this.getFullPath(remotePath), { force: true });
+    }
+    async ensureDirectoryExists(directory, createIfNotExists = true) {
+        try {
+            await fs.promises.access(directory, fs.promises.constants.F_OK);
+        }
+        catch (error) {
+            if (createIfNotExists) {
+                await fs.promises.mkdir(directory, { recursive: true });
+            }
+            else {
+                throw new NotFoundError(`Directory does not exist: ${directory}`);
+            }
+        }
+    }
+    async listObjects(remotePath) {
+        const fullPath = this.getFullPath(remotePath);
+        await this.ensureDirectoryExists(fullPath);
+        const dirents = await fs.promises.readdir(fullPath, { withFileTypes: true });
+        return Promise.all(dirents.map(async (dirent) => {
+            const direntPath = path.join(fullPath, dirent.name);
+            const direntStat = await fs.promises.stat(direntPath);
+            return {
+                name: dirent.name,
+                size: direntStat.size,
+                isFolder: dirent.isDirectory(),
+                createdAt: direntStat.birthtime,
+                ...(dirent.isDirectory() && {
+                    childrenCount: (await fs.promises.readdir(direntPath)).length,
+                }),
+            };
+        }));
+    }
+    async getObjectSize(remotePath) {
+        const fileStat = await fs.promises.stat(this.getFullPath(remotePath));
+        return fileStat.size;
+    }
+    async getLastModified(remotePath) {
+        const fileStat = await fs.promises.stat(this.getFullPath(remotePath));
+        return fileStat.mtime;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnMtc3RvcmFnZS1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvc3RvcmFnZS9mcy1zdG9yYWdlLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxNQUFNLElBQUksQ0FBQztBQUNwQixPQUFPLEtBQUssSUFBSSxNQUFNLE1BQU0sQ0FBQztBQUk3QixPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFdEQsTUFBTSxPQUFPLGlCQUFpQjtJQUNYLE1BQU0sQ0FBUztJQUNmLE1BQU0sQ0FBUztJQUVoQyxZQUFZLFdBQTBCO1FBQ3BDLElBQUksQ0FBQyxNQUFNLEdBQUcsV0FBVyxDQUFDLE1BQU0sQ0FBQztRQUNqQyxJQUFJLENBQUMsTUFBTSxHQUFHLFdBQVcsQ0FBQyxNQUFNLENBQUM7SUFDbkMsQ0FBQztJQUVPLFdBQVcsQ0FBQyxVQUFrQjtRQUNwQyxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsTUFBTSxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ3pELENBQUM7SUFFTyxpQkFBaUIsQ0FDdkIsV0FBNEIsRUFDNUIsWUFBNkIsRUFDN0IsYUFBcUIsRUFDckIsZ0JBQTJEO1FBRTNELElBQUksWUFBWSxHQUFHLENBQUMsQ0FBQztRQUNyQixJQUFJLE1BQU0sR0FBRyxLQUFLLENBQUM7UUFFbkIsT0FBTyxJQUFJLE9BQU8sQ0FBTyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRTtZQUMzQyxZQUFZLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxPQUFPLENBQUMsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUMsR0FBVSxFQUFFLEVBQUU7Z0JBQ2hFLE1BQU0sR0FBRyxJQUFJLENBQUM7Z0JBQ2QsSUFBSSxDQUFDLFdBQVcsQ0FBQyxTQUFTO29CQUFFLFdBQVcsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUM7Z0JBQ3JELE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUNkLENBQUMsQ0FBQyxDQUFDO1lBRUgsWUFBWSxDQUFDLEVBQUUsQ0FBQyxPQUFPLEVBQUUsR0FBRyxFQUFFO2dCQUM1QixJQUFJLENBQUMsV0FBVyxDQUFDLFNBQVMsSUFBSSxXQUFXLENBQUMsUUFBUSxJQUFJLFdBQVcsQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUFDO29CQUM3RSxXQUFXLENBQUMsTUFBTSxFQUFFLENBQUM7Z0JBQ3ZCLENBQUM7WUFDSCxDQUFDLENBQUMsQ0FBQztZQUVILFdBQVcsQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsS0FBSyxFQUFFLEVBQUU7Z0JBQy9CLElBQUksTUFBTSxJQUFJLFlBQVksQ0FBQyxTQUFTLElBQUksWUFBWSxDQUFDLGFBQWE7b0JBQUUsT0FBTztnQkFDM0UsSUFBSSxXQUFXLEdBQUcsSUFBSSxDQUFDO2dCQUN2QixJQUFJLENBQUM7b0JBQ0gsV0FBVyxHQUFHLFlBQVksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUM7Z0JBQzFDLENBQUM7Z0JBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztvQkFDYixNQUFNLEdBQUcsSUFBSSxDQUFDO29CQUNkLElBQUksQ0FBQyxXQUFXLENBQUMsU0FBUzt3QkFBRSxXQUFXLENBQUMsT0FBTyxDQUFDLEdBQVksQ0FBQyxDQUFDO29CQUM5RCxPQUFPO2dCQUNULENBQUM7Z0JBRUQsWUFBWSxJQUFJLEtBQUssQ0FBQyxNQUFNLENBQUM7Z0JBQzdCLElBQUksZ0JBQWdCLEVBQUUsQ0FBQztvQkFDckIsZ0JBQWdCLENBQUMsYUFBYSxFQUFFLFlBQVksQ0FBQyxDQUFDO2dCQUNoRCxDQUFDO2dCQUVELElBQUksQ0FBQyxXQUFXLElBQUksQ0FBQyxXQUFXLENBQUMsU0FBUztvQkFBRSxXQUFXLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDbEUsQ0FBQyxDQUFDLENBQUM7WUFDSCxXQUFXO2lCQUNSLElBQUksQ0FBQyxLQUFLLEVBQUUsR0FBRyxFQUFFO2dCQUNoQixZQUFZLENBQUMsR0FBRyxFQUFFLENBQUM7WUFDckIsQ0FBQyxDQUFDO2lCQUNELElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQyxHQUFVLEVBQUUsRUFBRSxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztRQUM5RCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRCxLQUFLLENBQUMsVUFBVSxDQUNkLFdBQTRCLEVBQzVCLFVBQWtCLEVBQ2xCLGFBQXFCLEVBQ3JCLGdCQUF5RTtRQUV6RSxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUM7WUFDakIsTUFBTSxJQUFJLEtBQUssQ0FBQywyQkFBMkIsQ0FBQyxDQUFDO1FBQy9DLENBQUM7UUFFRCxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQzlDLE1BQU0sSUFBSSxDQUFDLHFCQUFxQixDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQztRQUV6RCxNQUFNLFlBQVksR0FBRyxFQUFFLENBQUMsaUJBQWlCLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDcEQsTUFBTSxJQUFJLENBQUMsaUJBQWlCLENBQUMsV0FBVyxFQUFFLFlBQVksRUFBRSxhQUFhLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQztJQUMzRixDQUFDO0lBRUQsS0FBSyxDQUFDLFlBQVksQ0FDaEIsVUFBa0IsRUFDbEIsTUFBc0IsRUFDdEIsZ0JBQXlFO1FBRXpFLE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxNQUFNLElBQUksQ0FBQyxDQUFDO1FBQ2xDLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDOUMsSUFBSSxLQUFlLENBQUM7UUFDcEIsSUFBSSxDQUFDO1lBQ0gsS0FBSyxHQUFHLE1BQU0sRUFBRSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDM0MsQ0FBQztRQUFDLE1BQU0sQ0FBQztZQUNQLE1BQU0sSUFBSSxhQUFhLENBQUMsd0JBQXdCLFFBQVEsRUFBRSxDQUFDLENBQUM7UUFDOUQsQ0FBQztRQUNELE1BQU0sS0FBSyxHQUFHLE1BQU0sR0FBRyxDQUFDLE1BQU0sQ0FBQyxNQUFNLElBQUksQ0FBQyxDQUFDLElBQUksS0FBSyxDQUFDLElBQUksQ0FBQztRQUMxRCxJQUFJLE9BQU8sR0FBRyxNQUFNLENBQUM7UUFDckIsTUFBTSxVQUFVLEdBQUcsRUFBRSxDQUFDLGdCQUFnQixDQUFDLFFBQVEsRUFBRTtZQUMvQyxLQUFLLEVBQUUsTUFBTTtZQUNiLEdBQUcsRUFBRSxLQUFLO1NBQ1gsQ0FBQyxDQUFDO1FBRUgsVUFBVSxDQUFDLEVBQUUsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxLQUFLLEVBQUUsRUFBRTtZQUM5QixPQUFPLElBQUksS0FBSyxDQUFDLE1BQU0sQ0FBQztZQUN4QixJQUFJLGdCQUFnQixFQUFFLENBQUM7Z0JBQ3JCLGdCQUFnQixDQUFDLEtBQUssRUFBRSxPQUFPLENBQUMsQ0FBQztZQUNuQyxDQUFDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7UUFFSCxPQUFPLFVBQVUsQ0FBQztJQUNwQixDQUFDO0lBRUQsS0FBSyxDQUFDLFlBQVksQ0FBQyxVQUFrQjtRQUNuQyxNQUFNLEVBQUUsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsVUFBVSxDQUFDLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUN0RSxDQUFDO0lBRU8sS0FBSyxDQUFDLHFCQUFxQixDQUFDLFNBQWlCLEVBQUUsaUJBQWlCLEdBQUcsSUFBSTtRQUM3RSxJQUFJLENBQUM7WUFDSCxNQUFNLEVBQUUsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLFNBQVMsRUFBRSxFQUFFLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNsRSxDQUFDO1FBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztZQUNmLElBQUksaUJBQWlCLEVBQUUsQ0FBQztnQkFDdEIsTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxTQUFTLEVBQUUsRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztZQUMxRCxDQUFDO2lCQUFNLENBQUM7Z0JBQ04sTUFBTSxJQUFJLGFBQWEsQ0FBQyw2QkFBNkIsU0FBUyxFQUFFLENBQUMsQ0FBQztZQUNwRSxDQUFDO1FBQ0gsQ0FBQztJQUNILENBQUM7SUFFRCxLQUFLLENBQUMsV0FBVyxDQUFDLFVBQWtCO1FBQ2xDLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDOUMsTUFBTSxJQUFJLENBQUMscUJBQXFCLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDM0MsTUFBTSxPQUFPLEdBQUcsTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxRQUFRLEVBQUUsRUFBRSxhQUFhLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUU3RSxPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQ2hCLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxFQUFFO1lBQzNCLE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUNwRCxNQUFNLFVBQVUsR0FBRyxNQUFNLEVBQUUsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1lBQ3RELE9BQU87Z0JBQ0wsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFJO2dCQUNqQixJQUFJLEVBQUUsVUFBVSxDQUFDLElBQUk7Z0JBQ3JCLFFBQVEsRUFBRSxNQUFNLENBQUMsV0FBVyxFQUFFO2dCQUM5QixTQUFTLEVBQUUsVUFBVSxDQUFDLFNBQVM7Z0JBQy9CLEdBQUcsQ0FBQyxNQUFNLENBQUMsV0FBVyxFQUFFLElBQUk7b0JBQzFCLGFBQWEsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxNQUFNO2lCQUM5RCxDQUFDO2FBQ0gsQ0FBQztRQUNKLENBQUMsQ0FBQyxDQUNILENBQUM7SUFDSixDQUFDO0lBRUQsS0FBSyxDQUFDLGFBQWEsQ0FBQyxVQUFrQjtRQUNwQyxNQUFNLFFBQVEsR0FBRyxNQUFNLEVBQUUsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQztRQUV0RSxPQUFPLFFBQVEsQ0FBQyxJQUFJLENBQUM7SUFDdkIsQ0FBQztJQUVELEtBQUssQ0FBQyxlQUFlLENBQUMsVUFBa0I7UUFDdEMsTUFBTSxRQUFRLEdBQUcsTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUM7UUFFdEUsT0FBTyxRQUFRLENBQUMsS0FBSyxDQUFDO0lBQ3hCLENBQUM7Q0FDRiJ9

package/dist/mjs/providers/storage/getStorageProvider.d.ts

@@ -0,0 +1,4 @@
+import StorageAccess from '../../types/storage/StorageAccess.js';
+import IStorageProvider from './IStorageProvider.js';
+declare const _default: (storageAccess: StorageAccess) => IStorageProvider;
+export default _default;

package/dist/mjs/providers/storage/getStorageProvider.js

@@ -0,0 +1,18 @@
+import { StorageType, } from '@super-protocol/dto-js';
+import StorjStorageProvider from './StorjStorageProvider.js';
+import { S3StorageProvider } from './S3StorageProvider.js';
+import { FSStorageProvider } from './fs-storage-provider.js';
+export default (storageAccess) => {
+    const key = storageAccess.storageType;
+    switch (key) {
+        case StorageType.StorJ:
+            return new StorjStorageProvider(storageAccess.credentials, storageAccess.maximumConcurrent);
+        case StorageType.S3:
+            return new S3StorageProvider(storageAccess.credentials);
+        case StorageType.FS:
+            return new FSStorageProvider(storageAccess.credentials);
+        default:
+            throw Error(`Unsupported storageType ${key}`);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0U3RvcmFnZVByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3Byb3ZpZGVycy9zdG9yYWdlL2dldFN0b3JhZ2VQcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBR0wsV0FBVyxHQUVaLE1BQU0sd0JBQXdCLENBQUM7QUFHaEMsT0FBTyxvQkFBb0IsTUFBTSwyQkFBMkIsQ0FBQztBQUM3RCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUMzRCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUU3RCxlQUFlLENBQUMsYUFBNEIsRUFBb0IsRUFBRTtJQUNoRSxNQUFNLEdBQUcsR0FBRyxhQUFhLENBQUMsV0FBMEIsQ0FBQztJQUNyRCxRQUFRLEdBQUcsRUFBRSxDQUFDO1FBQ1osS0FBSyxXQUFXLENBQUMsS0FBSztZQUNwQixPQUFPLElBQUksb0JBQW9CLENBQzdCLGFBQWEsQ0FBQyxXQUErQixFQUM3QyxhQUFhLENBQUMsaUJBQWlCLENBQ2hDLENBQUM7UUFDSixLQUFLLFdBQVcsQ0FBQyxFQUFFO1lBQ2pCLE9BQU8sSUFBSSxpQkFBaUIsQ0FBQyxhQUFhLENBQUMsV0FBNEIsQ0FBQyxDQUFDO1FBQzNFLEtBQUssV0FBVyxDQUFDLEVBQUU7WUFDakIsT0FBTyxJQUFJLGlCQUFpQixDQUFDLGFBQWEsQ0FBQyxXQUE0QixDQUFDLENBQUM7UUFDM0U7WUFDRSxNQUFNLEtBQUssQ0FBQywyQkFBMkIsR0FBRyxFQUFFLENBQUMsQ0FBQztJQUNsRCxDQUFDO0FBQ0gsQ0FBQyxDQUFDIn0=

package/dist/mjs/providers/storage/parseStorageCredentials.d.ts

@@ -0,0 +1,4 @@
+import { StorageAccessCredentials } from '@super-protocol/dto-js';
+import { S3Credentials, StorageCredentials, StorageType, StorjCredentials } from '@super-protocol/dto-js';
+export type StorageCredentialsType<T extends StorageType | unknown> = T extends StorageType.StorJ ? StorageCredentials<StorjCredentials> : T extends StorageType.S3 ? StorageCredentials<S3Credentials> : StorageCredentials<StorageAccessCredentials>;
+export declare const parseStorageCredentials: <T extends unknown = unknown>(decryptedCredentials: string) => StorageCredentialsType<T>;

package/dist/mjs/providers/storage/parseStorageCredentials.js

@@ -0,0 +1,17 @@
+const tryParseJson = (probablyJson) => {
+    try {
+        return JSON.parse(probablyJson);
+    }
+    catch {
+        return probablyJson;
+    }
+};
+export const parseStorageCredentials = (decryptedCredentials) => {
+    const credentials = JSON.parse(decryptedCredentials);
+    return {
+        storageType: credentials.storageType,
+        downloadCredentials: tryParseJson(credentials.downloadCredentials),
+        uploadCredentials: tryParseJson(credentials.uploadCredentials),
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2VTdG9yYWdlQ3JlZGVudGlhbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3N0b3JhZ2UvcGFyc2VTdG9yYWdlQ3JlZGVudGlhbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBY0EsTUFBTSxZQUFZLEdBQUcsQ0FBQyxZQUFvQixFQUFpQyxFQUFFO0lBQzNFLElBQUksQ0FBQztRQUNILE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBQUMsTUFBTyxDQUFDO1FBQ1IsT0FBTyxZQUFZLENBQUM7SUFDdEIsQ0FBQztBQUNILENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHLENBQ3JDLG9CQUE0QixFQUNELEVBQUU7SUFDN0IsTUFBTSxXQUFXLEdBQStCLElBQUksQ0FBQyxLQUFLLENBQUMsb0JBQW9CLENBQUMsQ0FBQztJQUVqRixPQUFPO1FBQ0wsV0FBVyxFQUFFLFdBQVcsQ0FBQyxXQUFXO1FBQ3BDLG1CQUFtQixFQUFFLFlBQVksQ0FBQyxXQUFXLENBQUMsbUJBQW1CLENBQUM7UUFDbEUsaUJBQWlCLEVBQUUsWUFBWSxDQUFDLFdBQVcsQ0FBQyxpQkFBaUIsQ0FBQztLQUNsQyxDQUFDO0FBQ2pDLENBQUMsQ0FBQyJ9

package/dist/mjs/providers/storage/types.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { CacheEvents, StorageObject } from '../../index.js';
+export interface CacheRecord<V> {
+    value: V | null;
+    modifiedTs: number;
+}
+export interface Performance {
+    now(): number;
+}
+export interface IStorageKeyValueAdapter<V extends object> {
+    set(key: string, value: V | null, privateKey?: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    get(key: string, privateKey?: string): Promise<V | null>;
+    listFiles(key: string): Promise<StorageObject[]>;
+}
+export interface IStorageAdapter<V extends object> {
+    has(key: string): Promise<boolean>;
+    set(key: string, value: V, encryptionKeyBuffer?: Buffer): void;
+    delete(key: string): void;
+    run(): void;
+    clear(): void;
+    get(key: string, encryptionKeyBuffer?: Buffer): Promise<(V | null)[] | null>;
+    stop(): void;
+    subscribe(cb: (props: {
+        type: CacheEvents;
+        message: unknown;
+    }) => void): () => void;
+    shutdown(): Promise<void>;
+}

package/dist/mjs/providers/storage/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3N0b3JhZ2UvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/mjs/staticModels/Deposits.d.ts

@@ -0,0 +1,85 @@
+import { DepositInfo, BlockInfo, TransactionOptions, TokenAmount } from '../types/index.js';
+declare class Deposits {
+    private static readonly logger;
+    static get address(): string;
+    private static getTokenAddress;
+    /**
+     * Function for fetching deposit info
+     * @param depositOwner - Deposit owner
+     */
+    static getDepositInfo(depositOwner: string, tokenAddress?: string): Promise<DepositInfo>;
+    /**
+     * Function for fetching amount of locked tokens
+     * @param depositOwner - Deposit owner
+     */
+    static getLockedTokensAmount(depositOwner: string, tokenAddress?: string): Promise<TokenAmount>;
+    /**
+     * Function for replenish deposit
+     * @param amount - replenish amount
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     * @returns Promise<void> - Does not return id of created order!
+     */
+    static replenish(amount: TokenAmount, tokenAddress?: string, transactionOptions?: TransactionOptions): Promise<void>;
+    /**
+     * Function for replenish deposit of given account
+     * @param beneficiary - account
+     * @param amount - replenish amount
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     * @returns Promise<void> - Does not return id of created order!
+     */
+    static replenishFor(beneficiary: string, amount: TokenAmount, tokenAddress?: string, transactionOptions?: TransactionOptions): Promise<void>;
+    /**
+     * Function for withdraw deposit
+     * @param amount - withdraw amount
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     * @returns Promise<void> - Does not return id of created order!
+     */
+    static withdrawDeposit(amount: TokenAmount, tokenAddress?: string, transactionOptions?: TransactionOptions): Promise<void>;
+    /**
+     * Function for withdraw profit
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     * @returns Promise<void> - Does not return id of created order!
+     */
+    static withdrawProfit(tokenAddress?: string, transactionOptions?: TransactionOptions): Promise<void>;
+    /**
+     * Function for adding event listeners on DepositReplenished event in contract
+     * @param owner - owner address
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onDepositReplenished(callback: onDepositReplenishedCallback, owner?: string): () => void;
+    /**
+     * Function for adding event listeners on DepositWithdrawn event in contract
+     * @param owner - owner address
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onDepositWithdrawn(callback: onDepositWithdrawnCallback, owner?: string): () => void;
+    /**
+     * Function for adding event listeners on DepositPartLocked event in contract
+     * @param owner - owner address
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onDepositPartLocked(callback: onDepositPartLockedCallback, owner?: string): () => void;
+    /**
+     * Function for adding event listeners on DepositPartUnlocked event in contract
+     * @param owner - owner address
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onDepositPartUnlocked(callback: onDepositPartUnlockedCallback, owner?: string): () => void;
+    /**
+     * Function for adding event listeners on ProfitWithdrawn event in contract
+     * @param owner - owner address
+     * @param callback - function for processing event
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onProfitWithdrawn(callback: onProfitWithdrawnCallback, owner?: string): () => void;
+}
+export type onDepositReplenishedCallback = (token: string, owner: string, amount: TokenAmount, totalLocked: TokenAmount, block?: BlockInfo) => void;
+export type onDepositWithdrawnCallback = (token: string, owner: string, amount: TokenAmount, totalLocked: TokenAmount, block?: BlockInfo) => void;
+export type onDepositPartLockedCallback = (token: string, owner: string, amount: TokenAmount, totalLocked: TokenAmount, block?: BlockInfo) => void;
+export type onDepositPartUnlockedCallback = (token: string, owner: string, amount: TokenAmount, totalLocked: TokenAmount, block?: BlockInfo) => void;
+export type onProfitWithdrawnCallback = (owner: string, amount: TokenAmount, block?: BlockInfo) => void;
+export default Deposits;

package/dist/mjs/staticModels/Deposits.js

@@ -0,0 +1,263 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import rootLogger from '../logger.js';
+import Superpro from './Superpro.js';
+import TxManager from '../utils/TxManager.js';
+import { checkIfActionAccountInitialized, cleanWeb3Data, convertBigIntToString, incrementMethodCall, makeOnData, withCleanArgs, } from '../utils/helper.js';
+import { BlockchainConnector, BlockchainEventsListener } from '../connectors/index.js';
+class Deposits {
+    static logger = rootLogger.child({ className: 'Deposits' });
+    static get address() {
+        return Superpro.address;
+    }
+    static getTokenAddress() {
+        return BlockchainConnector.getInstance().getTokenAddress();
+    }
+    /**
+     * Function for fetching deposit info
+     * @param depositOwner - Deposit owner
+     */
+    static async getDepositInfo(depositOwner, tokenAddress = Deposits.getTokenAddress()) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return cleanWeb3Data(await contract.getDepositInfo(tokenAddress, depositOwner));
+    }
+    /**
+     * Function for fetching amount of locked tokens
+     * @param depositOwner - Deposit owner
+     */
+    static async getLockedTokensAmount(depositOwner, tokenAddress = Deposits.getTokenAddress()) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return convertBigIntToString(await contract.getLockedTokensAmount(tokenAddress, depositOwner));
+    }
+    /**
+     * Function for replenish deposit
+     * @param amount - replenish amount
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     * @returns Promise<void> - Does not return id of created order!
+     */
+    static async replenish(amount, tokenAddress = Deposits.getTokenAddress(), transactionOptions) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        checkIfActionAccountInitialized(transactionOptions);
+        const tx = await contract.replenish.populateTransaction(tokenAddress, amount);
+        await TxManager.execute(tx, transactionOptions);
+    }
+    /**
+     * Function for replenish deposit of given account
+     * @param beneficiary - account
+     * @param amount - replenish amount
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     * @returns Promise<void> - Does not return id of created order!
+     */
+    static async replenishFor(beneficiary, amount, tokenAddress = Deposits.getTokenAddress(), transactionOptions) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        checkIfActionAccountInitialized(transactionOptions);
+        const tx = await contract.replenishFor.populateTransaction(tokenAddress, beneficiary, amount);
+        await TxManager.execute(tx, transactionOptions);
+    }
+    /**
+     * Function for withdraw deposit
+     * @param amount - withdraw amount
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     * @returns Promise<void> - Does not return id of created order!
+     */
+    static async withdrawDeposit(amount, tokenAddress = Deposits.getTokenAddress(), transactionOptions) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        checkIfActionAccountInitialized(transactionOptions);
+        const tx = await contract.withdrawDeposit.populateTransaction(tokenAddress, amount);
+        await TxManager.execute(tx, transactionOptions);
+    }
+    /**
+     * Function for withdraw profit
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     * @returns Promise<void> - Does not return id of created order!
+     */
+    static async withdrawProfit(tokenAddress = Deposits.getTokenAddress(), transactionOptions) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        checkIfActionAccountInitialized(transactionOptions);
+        const tx = await contract.withdrawProfit.populateTransaction(tokenAddress);
+        await TxManager.execute(tx, transactionOptions);
+    }
+    /**
+     * Function for adding event listeners on DepositReplenished event in contract
+     * @param owner - owner address
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onDepositReplenished(callback, owner) {
+        const listener = BlockchainEventsListener.getInstance();
+        const contract = listener.getContract();
+        const eventName = 'DepositReplenished';
+        const logger = this.logger.child({ method: 'onDepositReplenished' });
+        const onData = makeOnData(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (owner && eventArgs.owner.toLowerCase() !== owner.toLowerCase()) {
+                return;
+            }
+            withCleanArgs(callback)(eventArgs.token, eventArgs.owner, eventArgs.amount, eventArgs.totalAmount, {
+                index: eventLog.blockNumber,
+                hash: eventLog.blockHash,
+            });
+        });
+        const onError = (error) => {
+            logger.warn(error);
+        };
+        return listener.subscribeEvent({
+            onError,
+            onData,
+            event: eventName,
+        });
+    }
+    /**
+     * Function for adding event listeners on DepositWithdrawn event in contract
+     * @param owner - owner address
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onDepositWithdrawn(callback, owner) {
+        const listener = BlockchainEventsListener.getInstance();
+        const contract = listener.getContract();
+        const eventName = 'DepositWithdrawn';
+        const logger = this.logger.child({ method: 'onDepositWithdrawn' });
+        const onData = makeOnData(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (owner && eventArgs.owner.toLowerCase() !== owner.toLowerCase()) {
+                return;
+            }
+            withCleanArgs(callback)(eventArgs.token, eventArgs.owner, eventArgs.amount, eventArgs.totalAmount, {
+                index: eventLog.blockNumber,
+                hash: eventLog.blockHash,
+            });
+        });
+        const onError = (error) => {
+            logger.warn(error);
+        };
+        return listener.subscribeEvent({
+            onError,
+            onData,
+            event: eventName,
+        });
+    }
+    /**
+     * Function for adding event listeners on DepositPartLocked event in contract
+     * @param owner - owner address
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onDepositPartLocked(callback, owner) {
+        const listener = BlockchainEventsListener.getInstance();
+        const contract = listener.getContract();
+        const eventName = 'DepositPartLocked';
+        const logger = this.logger.child({ method: 'onDepositPartLocked' });
+        const onData = makeOnData(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (owner && eventArgs.owner.toLowerCase() !== owner.toLowerCase()) {
+                return;
+            }
+            withCleanArgs(callback)(eventArgs.token, eventArgs.owner, eventArgs.amount, eventArgs.totalLocked, {
+                index: eventLog.blockNumber,
+                hash: eventLog.blockHash,
+            });
+        });
+        const onError = (error) => {
+            logger.warn(error);
+        };
+        return listener.subscribeEvent({
+            onError,
+            onData,
+            event: eventName,
+        });
+    }
+    /**
+     * Function for adding event listeners on DepositPartUnlocked event in contract
+     * @param owner - owner address
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onDepositPartUnlocked(callback, owner) {
+        const listener = BlockchainEventsListener.getInstance();
+        const contract = listener.getContract();
+        const eventName = 'DepositPartUnlocked';
+        const logger = this.logger.child({ method: 'onDepositPartUnlocked' });
+        const onData = makeOnData(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (owner && eventArgs.owner.toLowerCase() !== owner.toLowerCase()) {
+                return;
+            }
+            withCleanArgs(callback)(eventArgs.token, eventArgs.owner, eventArgs.amount, eventArgs.totalLocked, {
+                index: eventLog.blockNumber,
+                hash: eventLog.blockHash,
+            });
+        });
+        const onError = (error) => {
+            logger.warn(error);
+        };
+        return listener.subscribeEvent({
+            onError,
+            onData,
+            event: 'DepositPartUnlocked',
+        });
+    }
+    /**
+     * Function for adding event listeners on ProfitWithdrawn event in contract
+     * @param owner - owner address
+     * @param callback - function for processing event
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onProfitWithdrawn(callback, owner) {
+        const listener = BlockchainEventsListener.getInstance();
+        const contract = listener.getContract();
+        const eventName = 'ProfitWithdrawn';
+        const logger = this.logger.child({ method: 'onProfitWithdrawn' });
+        const onData = makeOnData(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (owner && eventArgs.owner.toLowerCase() !== owner.toLowerCase()) {
+                return;
+            }
+            withCleanArgs(callback)(eventArgs.owner, eventArgs.amount, {
+                index: eventLog.blockNumber,
+                hash: eventLog.blockHash,
+            });
+        });
+        const onError = (error) => {
+            logger.warn(error);
+        };
+        return listener.subscribeEvent({
+            onError,
+            onData,
+            event: 'ProfitWithdrawn',
+        });
+    }
+}
+__decorate([
+    incrementMethodCall(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], Deposits, "replenish", null);
+__decorate([
+    incrementMethodCall(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, Object]),
+    __metadata("design:returntype", Promise)
+], Deposits, "replenishFor", null);
+__decorate([
+    incrementMethodCall(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], Deposits, "withdrawDeposit", null);
+__decorate([
+    incrementMethodCall(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], Deposits, "withdrawProfit", null);
+export default Deposits;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Deposits.js","sourceRoot":"","sources":["../../../src/staticModels/Deposits.ts"],"names":[],"mappings":"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"}

package/dist/mjs/staticModels/Diamond.d.ts

@@ -0,0 +1,6 @@
+declare class Diamond {
+    static get address(): string;
+    static getDeploymentBlockNumber(): Promise<number>;
+    static getDeployer(): Promise<string>;
+}
+export default Diamond;

package/dist/mjs/staticModels/Diamond.js

@@ -0,0 +1,17 @@
+import Superpro from './Superpro.js';
+import { BlockchainConnector } from '../connectors/index.js';
+class Diamond {
+    static get address() {
+        return Superpro.address;
+    }
+    static async getDeploymentBlockNumber() {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return Number(await contract.deploymentBlockNumber());
+    }
+    static async getDeployer() {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return await contract.deployer();
+    }
+}
+export default Diamond;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGlhbW9uZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdGF0aWNNb2RlbHMvRGlhbW9uZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLFFBQVEsTUFBTSxlQUFlLENBQUM7QUFDckMsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFN0QsTUFBTSxPQUFPO0lBQ0osTUFBTSxLQUFLLE9BQU87UUFDdkIsT0FBTyxRQUFRLENBQUMsT0FBTyxDQUFDO0lBQzFCLENBQUM7SUFFTSxNQUFNLENBQUMsS0FBSyxDQUFDLHdCQUF3QjtRQUMxQyxNQUFNLFFBQVEsR0FBRyxtQkFBbUIsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUVqRSxPQUFPLE1BQU0sQ0FBQyxNQUFNLFFBQVEsQ0FBQyxxQkFBcUIsRUFBRSxDQUFDLENBQUM7SUFDeEQsQ0FBQztJQUVNLE1BQU0sQ0FBQyxLQUFLLENBQUMsV0FBVztRQUM3QixNQUFNLFFBQVEsR0FBRyxtQkFBbUIsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUVqRSxPQUFPLE1BQU0sUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ25DLENBQUM7Q0FDRjtBQUVELGVBQWUsT0FBTyxDQUFDIn0=

package/dist/mjs/staticModels/ModelPackager.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+export declare class ModelPackager {
+    private static compressors;
+    /**
+     * Compressing message with best algorithm
+     *
+     * @param message - message
+     * @returns Compressed message in bytes representation
+     */
+    static pack<T = unknown>(message: T): Promise<Buffer>;
+    /**
+     * Uncompressing message
+     *
+     * @param message - message with bytes representation
+     * @returns original message
+     */
+    static unpack<T = unknown>(message: Buffer): Promise<T>;
+}