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

package/dist/cjs/providers/storage/fs-storage-provider.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import stream from 'stream';
+import StorageObject from '../../types/storage/StorageObject.js';
+import IStorageProvider, { DownloadConfig } from './IStorageProvider.js';
+import { FSCredentials } from '@super-protocol/dto-js';
+export declare class FSStorageProvider implements IStorageProvider {
+    private readonly bucket;
+    private readonly prefix;
+    constructor(credentials: FSCredentials);
+    private getFullPath;
+    private writeWithProgress;
+    uploadFile(inputStream: stream.Readable, remotePath: string, contentLength: number, progressListener?: ((total: number, current: number) => void) | undefined): Promise<void>;
+    downloadFile(remotePath: string, config: DownloadConfig, progressListener?: ((total: number, current: number) => void) | undefined): Promise<stream.Readable>;
+    deleteObject(remotePath: string): Promise<void>;
+    private ensureDirectoryExists;
+    listObjects(remotePath: string): Promise<StorageObject[]>;
+    getObjectSize(remotePath: string): Promise<number>;
+    getLastModified(remotePath: string): Promise<Date | null>;
+}

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

@@ -0,0 +1,162 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FSStorageProvider = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path = __importStar(require("path"));
+const index_js_1 = require("../../errors/index.js");
+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_1.default.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_1.default.promises.stat(filePath);
+        }
+        catch {
+            throw new index_js_1.NotFoundError(`File does not exist: ${filePath}`);
+        }
+        const total = offset + (config.length ?? 0) || stats.size;
+        let current = offset;
+        const readStream = fs_1.default.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_1.default.promises.rm(this.getFullPath(remotePath), { force: true });
+    }
+    async ensureDirectoryExists(directory, createIfNotExists = true) {
+        try {
+            await fs_1.default.promises.access(directory, fs_1.default.promises.constants.F_OK);
+        }
+        catch (error) {
+            if (createIfNotExists) {
+                await fs_1.default.promises.mkdir(directory, { recursive: true });
+            }
+            else {
+                throw new index_js_1.NotFoundError(`Directory does not exist: ${directory}`);
+            }
+        }
+    }
+    async listObjects(remotePath) {
+        const fullPath = this.getFullPath(remotePath);
+        await this.ensureDirectoryExists(fullPath);
+        const dirents = await fs_1.default.promises.readdir(fullPath, { withFileTypes: true });
+        return Promise.all(dirents.map(async (dirent) => {
+            const direntPath = path.join(fullPath, dirent.name);
+            const direntStat = await fs_1.default.promises.stat(direntPath);
+            return {
+                name: dirent.name,
+                size: direntStat.size,
+                isFolder: dirent.isDirectory(),
+                createdAt: direntStat.birthtime,
+                ...(dirent.isDirectory() && {
+                    childrenCount: (await fs_1.default.promises.readdir(direntPath)).length,
+                }),
+            };
+        }));
+    }
+    async getObjectSize(remotePath) {
+        const fileStat = await fs_1.default.promises.stat(this.getFullPath(remotePath));
+        return fileStat.size;
+    }
+    async getLastModified(remotePath) {
+        const fileStat = await fs_1.default.promises.stat(this.getFullPath(remotePath));
+        return fileStat.mtime;
+    }
+}
+exports.FSStorageProvider = FSStorageProvider;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/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/cjs/providers/storage/getStorageProvider.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dto_js_1 = require("@super-protocol/dto-js");
+const StorjStorageProvider_js_1 = __importDefault(require("./StorjStorageProvider.js"));
+const S3StorageProvider_js_1 = require("./S3StorageProvider.js");
+const fs_storage_provider_js_1 = require("./fs-storage-provider.js");
+exports.default = (storageAccess) => {
+    const key = storageAccess.storageType;
+    switch (key) {
+        case dto_js_1.StorageType.StorJ:
+            return new StorjStorageProvider_js_1.default(storageAccess.credentials, storageAccess.maximumConcurrent);
+        case dto_js_1.StorageType.S3:
+            return new S3StorageProvider_js_1.S3StorageProvider(storageAccess.credentials);
+        case dto_js_1.StorageType.FS:
+            return new fs_storage_provider_js_1.FSStorageProvider(storageAccess.credentials);
+        default:
+            throw Error(`Unsupported storageType ${key}`);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0U3RvcmFnZVByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3Byb3ZpZGVycy9zdG9yYWdlL2dldFN0b3JhZ2VQcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLG1EQUtnQztBQUdoQyx3RkFBNkQ7QUFDN0QsaUVBQTJEO0FBQzNELHFFQUE2RDtBQUU3RCxrQkFBZSxDQUFDLGFBQTRCLEVBQW9CLEVBQUU7SUFDaEUsTUFBTSxHQUFHLEdBQUcsYUFBYSxDQUFDLFdBQTBCLENBQUM7SUFDckQsUUFBUSxHQUFHLEVBQUUsQ0FBQztRQUNaLEtBQUssb0JBQVcsQ0FBQyxLQUFLO1lBQ3BCLE9BQU8sSUFBSSxpQ0FBb0IsQ0FDN0IsYUFBYSxDQUFDLFdBQStCLEVBQzdDLGFBQWEsQ0FBQyxpQkFBaUIsQ0FDaEMsQ0FBQztRQUNKLEtBQUssb0JBQVcsQ0FBQyxFQUFFO1lBQ2pCLE9BQU8sSUFBSSx3Q0FBaUIsQ0FBQyxhQUFhLENBQUMsV0FBNEIsQ0FBQyxDQUFDO1FBQzNFLEtBQUssb0JBQVcsQ0FBQyxFQUFFO1lBQ2pCLE9BQU8sSUFBSSwwQ0FBaUIsQ0FBQyxhQUFhLENBQUMsV0FBNEIsQ0FBQyxDQUFDO1FBQzNFO1lBQ0UsTUFBTSxLQUFLLENBQUMsMkJBQTJCLEdBQUcsRUFBRSxDQUFDLENBQUM7SUFDbEQsQ0FBQztBQUNILENBQUMsQ0FBQyJ9

package/dist/cjs/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/cjs/providers/storage/parseStorageCredentials.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStorageCredentials = void 0;
+const tryParseJson = (probablyJson) => {
+    try {
+        return JSON.parse(probablyJson);
+    }
+    catch {
+        return probablyJson;
+    }
+};
+const parseStorageCredentials = (decryptedCredentials) => {
+    const credentials = JSON.parse(decryptedCredentials);
+    return {
+        storageType: credentials.storageType,
+        downloadCredentials: tryParseJson(credentials.downloadCredentials),
+        uploadCredentials: tryParseJson(credentials.uploadCredentials),
+    };
+};
+exports.parseStorageCredentials = parseStorageCredentials;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2VTdG9yYWdlQ3JlZGVudGlhbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3N0b3JhZ2UvcGFyc2VTdG9yYWdlQ3JlZGVudGlhbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBY0EsTUFBTSxZQUFZLEdBQUcsQ0FBQyxZQUFvQixFQUFpQyxFQUFFO0lBQzNFLElBQUksQ0FBQztRQUNILE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBQUMsTUFBTyxDQUFDO1FBQ1IsT0FBTyxZQUFZLENBQUM7SUFDdEIsQ0FBQztBQUNILENBQUMsQ0FBQztBQUVLLE1BQU0sdUJBQXVCLEdBQUcsQ0FDckMsb0JBQTRCLEVBQ0QsRUFBRTtJQUM3QixNQUFNLFdBQVcsR0FBK0IsSUFBSSxDQUFDLEtBQUssQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDO0lBRWpGLE9BQU87UUFDTCxXQUFXLEVBQUUsV0FBVyxDQUFDLFdBQVc7UUFDcEMsbUJBQW1CLEVBQUUsWUFBWSxDQUFDLFdBQVcsQ0FBQyxtQkFBbUIsQ0FBQztRQUNsRSxpQkFBaUIsRUFBRSxZQUFZLENBQUMsV0FBVyxDQUFDLGlCQUFpQixDQUFDO0tBQ2xDLENBQUM7QUFDakMsQ0FBQyxDQUFDO0FBVlcsUUFBQSx1QkFBdUIsMkJBVWxDIn0=

package/dist/cjs/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/cjs/providers/storage/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3N0b3JhZ2UvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/cjs/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/cjs/staticModels/Deposits.js

@@ -0,0 +1,268 @@
+"use strict";
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_js_1 = __importDefault(require("../logger.js"));
+const Superpro_js_1 = __importDefault(require("./Superpro.js"));
+const TxManager_js_1 = __importDefault(require("../utils/TxManager.js"));
+const helper_js_1 = require("../utils/helper.js");
+const index_js_1 = require("../connectors/index.js");
+class Deposits {
+    static logger = logger_js_1.default.child({ className: 'Deposits' });
+    static get address() {
+        return Superpro_js_1.default.address;
+    }
+    static getTokenAddress() {
+        return index_js_1.BlockchainConnector.getInstance().getTokenAddress();
+    }
+    /**
+     * Function for fetching deposit info
+     * @param depositOwner - Deposit owner
+     */
+    static async getDepositInfo(depositOwner, tokenAddress = Deposits.getTokenAddress()) {
+        const contract = index_js_1.BlockchainConnector.getInstance().getContract();
+        return (0, helper_js_1.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 = index_js_1.BlockchainConnector.getInstance().getContract();
+        return (0, helper_js_1.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 = index_js_1.BlockchainConnector.getInstance().getContract();
+        (0, helper_js_1.checkIfActionAccountInitialized)(transactionOptions);
+        const tx = await contract.replenish.populateTransaction(tokenAddress, amount);
+        await TxManager_js_1.default.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 = index_js_1.BlockchainConnector.getInstance().getContract();
+        (0, helper_js_1.checkIfActionAccountInitialized)(transactionOptions);
+        const tx = await contract.replenishFor.populateTransaction(tokenAddress, beneficiary, amount);
+        await TxManager_js_1.default.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 = index_js_1.BlockchainConnector.getInstance().getContract();
+        (0, helper_js_1.checkIfActionAccountInitialized)(transactionOptions);
+        const tx = await contract.withdrawDeposit.populateTransaction(tokenAddress, amount);
+        await TxManager_js_1.default.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 = index_js_1.BlockchainConnector.getInstance().getContract();
+        (0, helper_js_1.checkIfActionAccountInitialized)(transactionOptions);
+        const tx = await contract.withdrawProfit.populateTransaction(tokenAddress);
+        await TxManager_js_1.default.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 = index_js_1.BlockchainEventsListener.getInstance();
+        const contract = listener.getContract();
+        const eventName = 'DepositReplenished';
+        const logger = this.logger.child({ method: 'onDepositReplenished' });
+        const onData = (0, helper_js_1.makeOnData)(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (owner && eventArgs.owner.toLowerCase() !== owner.toLowerCase()) {
+                return;
+            }
+            (0, helper_js_1.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 = index_js_1.BlockchainEventsListener.getInstance();
+        const contract = listener.getContract();
+        const eventName = 'DepositWithdrawn';
+        const logger = this.logger.child({ method: 'onDepositWithdrawn' });
+        const onData = (0, helper_js_1.makeOnData)(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (owner && eventArgs.owner.toLowerCase() !== owner.toLowerCase()) {
+                return;
+            }
+            (0, helper_js_1.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 = index_js_1.BlockchainEventsListener.getInstance();
+        const contract = listener.getContract();
+        const eventName = 'DepositPartLocked';
+        const logger = this.logger.child({ method: 'onDepositPartLocked' });
+        const onData = (0, helper_js_1.makeOnData)(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (owner && eventArgs.owner.toLowerCase() !== owner.toLowerCase()) {
+                return;
+            }
+            (0, helper_js_1.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 = index_js_1.BlockchainEventsListener.getInstance();
+        const contract = listener.getContract();
+        const eventName = 'DepositPartUnlocked';
+        const logger = this.logger.child({ method: 'onDepositPartUnlocked' });
+        const onData = (0, helper_js_1.makeOnData)(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (owner && eventArgs.owner.toLowerCase() !== owner.toLowerCase()) {
+                return;
+            }
+            (0, helper_js_1.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 = index_js_1.BlockchainEventsListener.getInstance();
+        const contract = listener.getContract();
+        const eventName = 'ProfitWithdrawn';
+        const logger = this.logger.child({ method: 'onProfitWithdrawn' });
+        const onData = (0, helper_js_1.makeOnData)(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (owner && eventArgs.owner.toLowerCase() !== owner.toLowerCase()) {
+                return;
+            }
+            (0, helper_js_1.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([
+    (0, helper_js_1.incrementMethodCall)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], Deposits, "replenish", null);
+__decorate([
+    (0, helper_js_1.incrementMethodCall)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, Object]),
+    __metadata("design:returntype", Promise)
+], Deposits, "replenishFor", null);
+__decorate([
+    (0, helper_js_1.incrementMethodCall)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], Deposits, "withdrawDeposit", null);
+__decorate([
+    (0, helper_js_1.incrementMethodCall)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], Deposits, "withdrawProfit", null);
+exports.default = Deposits;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Deposits.js","sourceRoot":"","sources":["../../../src/staticModels/Deposits.ts"],"names":[],"mappings":"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"}