@super-protocol/sdk-js 2.1.2 → 2.1.3

package/dist/mjs/staticModels/Deposits.js

@@ -0,0 +1,190 @@
+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, } 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;
+    }
+    /**
+     * Function for fetching deposit info
+     * @param depositOwner - Deposit owner
+     */
+    static async getDepositInfo(depositOwner) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return cleanWeb3Data(await contract.methods.getDepositInfo(depositOwner).call());
+    }
+    /**
+     * Function for fetching amount of locked tokens
+     * @param depositOwner - Deposit owner
+     */
+    static async getLockedTokensAmount(depositOwner) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return convertBigIntToString(await contract.methods.getLockedTokensAmount(depositOwner).call());
+    }
+    /**
+     * 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, transactionOptions) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        checkIfActionAccountInitialized(transactionOptions);
+        await TxManager.execute(contract.methods.replenish(amount), 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, transactionOptions) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        checkIfActionAccountInitialized(transactionOptions);
+        await TxManager.execute(contract.methods.replenishFor(beneficiary, amount), 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 withdraw(amount, transactionOptions) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        checkIfActionAccountInitialized(transactionOptions);
+        await TxManager.execute(contract.methods.withdraw(amount), 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 contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onDepositReplenished' });
+        const subscription = contract.events.DepositReplenished();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            if (owner && event.returnValues.owner != owner) {
+                return;
+            }
+            callback(parsedEvent.owner, parsedEvent.amount, parsedEvent.totalLocked, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * 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 contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onDepositWithdrawn' });
+        const subscription = contract.events.DepositWithdrawn();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            if (owner && parsedEvent.owner != owner) {
+                return;
+            }
+            callback(parsedEvent.owner, parsedEvent.amount, parsedEvent.totalLocked, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * 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 contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onDepositPartLocked' });
+        const subscription = contract.events.DepositPartLocked();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            if (owner && parsedEvent.owner != owner) {
+                return;
+            }
+            callback(parsedEvent.owner, parsedEvent.amount, parsedEvent.totalLocked, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * 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 contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onDepositPartUnlocked' });
+        const subscription = contract.events.DepositPartUnlocked();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            if (owner && parsedEvent.owner != owner) {
+                return;
+            }
+            callback(parsedEvent.owner, parsedEvent.amount, parsedEvent.totalLocked, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+}
+__decorate([
+    incrementMethodCall(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], Deposits, "replenish", null);
+__decorate([
+    incrementMethodCall(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], Deposits, "replenishFor", null);
+__decorate([
+    incrementMethodCall(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], Deposits, "withdraw", null);
+export default Deposits;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,8 @@
+import { BlockchainId, Mark, ProviderMarksCount } from '../types/index.js';
+declare class Marks {
+    static get address(): string;
+    static getProviderMarks(providerId: string): Promise<ProviderMarksCount>;
+    static getOrderMark(orderId: BlockchainId): Promise<Mark>;
+    static setOrderMark(orderId: BlockchainId, mark: Mark): Promise<void>;
+}
+export default Marks;

package/dist/mjs/staticModels/Marks.js

@@ -0,0 +1,25 @@
+import { BlockchainConnector } from '../connectors/index.js';
+import Superpro from './Superpro.js';
+import { cleanWeb3Data } from '../utils/helper.js';
+class Marks {
+    static get address() {
+        return Superpro.address;
+    }
+    static getProviderMarks(providerId) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return contract.methods
+            .getProviderMarks(providerId)
+            .call()
+            .then((marks) => cleanWeb3Data(marks));
+    }
+    static async getOrderMark(orderId) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return (await contract.methods.getOrderMark(orderId).call());
+    }
+    static async setOrderMark(orderId, mark) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        await contract.methods.setOrderMark(orderId, mark).call();
+    }
+}
+export default Marks;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWFya3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RhdGljTW9kZWxzL01hcmtzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzdELE9BQU8sUUFBUSxNQUFNLGVBQWUsQ0FBQztBQUVyQyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFbkQsTUFBTSxLQUFLO0lBQ0YsTUFBTSxLQUFLLE9BQU87UUFDdkIsT0FBTyxRQUFRLENBQUMsT0FBTyxDQUFDO0lBQzFCLENBQUM7SUFFRCxNQUFNLENBQUMsZ0JBQWdCLENBQUMsVUFBa0I7UUFDeEMsTUFBTSxRQUFRLEdBQUcsbUJBQW1CLENBQUMsV0FBVyxFQUFFLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDakUsT0FBTyxRQUFRLENBQUMsT0FBTzthQUNwQixnQkFBZ0IsQ0FBQyxVQUFVLENBQUM7YUFDNUIsSUFBSSxFQUFFO2FBQ04sSUFBSSxDQUFDLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUF1QixDQUFDLENBQUM7SUFDakUsQ0FBQztJQUVELE1BQU0sQ0FBQyxLQUFLLENBQUMsWUFBWSxDQUFDLE9BQXFCO1FBQzdDLE1BQU0sUUFBUSxHQUFHLG1CQUFtQixDQUFDLFdBQVcsRUFBRSxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBRWpFLE9BQU8sQ0FBQyxNQUFNLFFBQVEsQ0FBQyxPQUFPLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFTLENBQUM7SUFDdkUsQ0FBQztJQUVELE1BQU0sQ0FBQyxLQUFLLENBQUMsWUFBWSxDQUFDLE9BQXFCLEVBQUUsSUFBVTtRQUN6RCxNQUFNLFFBQVEsR0FBRyxtQkFBbUIsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUVqRSxNQUFNLFFBQVEsQ0FBQyxPQUFPLENBQUMsWUFBWSxDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUM1RCxDQUFDO0NBQ0Y7QUFFRCxlQUFlLEtBQUssQ0FBQyJ9

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>;
+}

package/dist/mjs/staticModels/ModelPackager.js

@@ -0,0 +1,45 @@
+import { Compression } from '../proto/Compression.js';
+import { GzipCompressor, UncompressedCompressor } from '../utils/compressors/index.js';
+export class ModelPackager {
+    static compressors = [GzipCompressor, UncompressedCompressor];
+    /**
+     * Compressing message with best algorithm
+     *
+     * @param message - message
+     * @returns Compressed message in bytes representation
+     */
+    static async pack(message) {
+        const promises = ModelPackager.compressors.map(async (Compressor) => {
+            const compressorInstance = new Compressor();
+            const data = await compressorInstance.compress(message);
+            return {
+                compressionType: Compressor.type,
+                data,
+                size: data.byteLength,
+            };
+        });
+        const options = await Promise.all(promises);
+        options.sort((first, second) => first.size - second.size);
+        const minimal = options[0];
+        const encoded = Compression.encode({
+            type: minimal.compressionType,
+            data: minimal.data,
+        }).finish();
+        return Buffer.from(encoded);
+    }
+    /**
+     * Uncompressing message
+     *
+     * @param message - message with bytes representation
+     * @returns original message
+     */
+    static async unpack(message) {
+        const decoded = Compression.decode(message);
+        const Compressor = ModelPackager.compressors.find((CompressorClass) => CompressorClass.type === decoded.type);
+        if (!Compressor) {
+            throw new Error(`Cannot unpack message. Compressor ${decoded.type} isn't supported`);
+        }
+        return new Compressor().decompress(Buffer.from(decoded.data));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,65 @@
+import StaticModel from './StaticModel.js';
+import { OfferCreatedEvent, ValueSlotAddedEvent, BlockInfo, TransactionOptions, OfferInfo, OfferType, BlockchainId } from '../types/index.js';
+declare class Offers implements StaticModel {
+    private static readonly logger;
+    static offers?: BlockchainId[];
+    static get address(): string;
+    /**
+     * Function for fetching list of all offers ids
+     */
+    static getAll(): Promise<BlockchainId[]>;
+    /**
+     * Function for fetching total count of value offer slots
+     */
+    static getSlotsCount(): Promise<number>;
+    /**
+     * Creates new offer
+     * @param providerAuthorityAccount - address of authority account of provider
+     * @param offerInfo - data of new offer
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static create(providerAuthorityAccount: string, offerInfo: OfferInfo, externalId?: string, enabled?: boolean, transactionOptions?: TransactionOptions): Promise<void>;
+    static getByExternalId(filter: {
+        externalId: string;
+        creator?: string;
+    }, fromBlock?: number | string, toBlock?: number | string): Promise<OfferCreatedEvent | null>;
+    static getSlotByExternalId(filter: {
+        externalId: string;
+        creator?: string;
+        offerId?: BlockchainId;
+    }, fromBlock?: number | string, toBlock?: number | string): Promise<ValueSlotAddedEvent | null>;
+    /**
+     * Function for adding event listeners on onSlotAdded event in contract
+     * @param creator - creator address
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onSlotAdded(callback: onSlotAddedCallback, creator?: string): () => void;
+    /**
+     * Function for adding event listeners on onSlotUpdated event in contract
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onSlotUpdated(callback: onSlotUpdatedCallback): () => void;
+    /**
+     * Function for adding event listeners on onSlotDeleted event in contract
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onSlotDeleted(callback: onSlotDeletedCallback): () => void;
+    /**
+     * Function for adding event listeners on offer created event in offers factory contract
+     * @param callback - function for processing created offer
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onCreated(callback: onOfferCreatedCallback): () => void;
+    static onEnabled(callback: onOfferEnabledCallback): () => void;
+    static onDisabled(callback: onOfferDisbledCallback): () => void;
+}
+export type onOfferCreatedCallback = (id: BlockchainId, creator: string, externalId: string, block?: BlockInfo) => void;
+export type onOfferEnabledCallback = (providerAuth: string, id: BlockchainId, offerType: OfferType, block?: BlockInfo) => void;
+export type onOfferDisbledCallback = (providerAuth: string, id: BlockchainId, offerType: OfferType, block?: BlockInfo) => void;
+export type onSlotAddedCallback = (creator: string, offerId: BlockchainId, slotId: BlockchainId, externalId: string, block?: BlockInfo) => void;
+export type onSlotUpdatedCallback = (offerId: BlockchainId, slotId: BlockchainId, block?: BlockInfo) => void;
+export type onSlotDeletedCallback = (offerId: BlockchainId, slotId: BlockchainId, block?: BlockInfo) => void;
+export default Offers;

package/dist/mjs/staticModels/Offers.js

@@ -0,0 +1,184 @@
+import rootLogger from '../logger.js';
+import StaticModel from './StaticModel.js';
+import { checkIfActionAccountInitialized, cleanWeb3Data } from '../utils/helper.js';
+import { formatBytes32String, parseBytes32String } from 'ethers/lib/utils.js';
+import { OfferType, } from '../types/index.js';
+import Superpro from './Superpro.js';
+import TxManager from '../utils/TxManager.js';
+import { BlockchainConnector, BlockchainEventsListener } from '../connectors/index.js';
+class Offers {
+    static logger = rootLogger.child({ className: 'Offers' });
+    static offers;
+    static get address() {
+        return Superpro.address;
+    }
+    /**
+     * Function for fetching list of all offers ids
+     */
+    static async getAll() {
+        const contract = BlockchainConnector.getInstance().getContract();
+        const count = Number(await contract.methods.getOffersTotalCount().call());
+        this.offers = this.offers || [];
+        const offersSet = new Set(this.offers);
+        for (let offerId = offersSet.size + 1; offerId <= count; ++offerId) {
+            const offerType = (await contract.methods.getOfferType(offerId).call()).toString();
+            if (offerType !== OfferType.TeeOffer) {
+                offersSet.add(offerId.toString());
+            }
+        }
+        this.offers = Array.from(offersSet);
+        return this.offers;
+    }
+    /**
+     * Function for fetching total count of value offer slots
+     */
+    static async getSlotsCount() {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return Number(await contract.methods.getValueOffersSlotsCount().call());
+    }
+    /**
+     * Creates new offer
+     * @param providerAuthorityAccount - address of authority account of provider
+     * @param offerInfo - data of new offer
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async create(providerAuthorityAccount, offerInfo, externalId = 'default', enabled = true, transactionOptions) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        checkIfActionAccountInitialized(transactionOptions);
+        const formattedExternalId = formatBytes32String(externalId);
+        await TxManager.execute(contract.methods.createValueOffer(providerAuthorityAccount, offerInfo, offerInfo.restrictions, formattedExternalId, enabled), transactionOptions);
+    }
+    static async getByExternalId(filter, fromBlock, toBlock) {
+        const founded = await StaticModel.findItemsById('OfferCreated', filter, fromBlock, toBlock);
+        if (!founded)
+            return null;
+        return founded;
+    }
+    static async getSlotByExternalId(filter, fromBlock, toBlock) {
+        const found = await StaticModel.findItemsById('ValueSlotAdded', filter, fromBlock, toBlock);
+        if (!found)
+            return null;
+        return found;
+    }
+    /**
+     * Function for adding event listeners on onSlotAdded event in contract
+     * @param creator - creator address
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onSlotAdded(callback, creator) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onValueSlotAdded' });
+        const subscription = contract.events.ValueSlotAdded();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            if (creator && parsedEvent.creator != creator) {
+                return;
+            }
+            callback(parsedEvent.creator, parsedEvent.offerId, parsedEvent.slotId, parseBytes32String(parsedEvent.externalId), {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * Function for adding event listeners on onSlotUpdated event in contract
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onSlotUpdated(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onValueSlotUpdated' });
+        const subscription = contract.events.ValueSlotUpdated();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            callback(parsedEvent.offerId, parsedEvent.slotId, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * Function for adding event listeners on onSlotDeleted event in contract
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onSlotDeleted(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onValueSlotDeleted' });
+        const subscription = contract.events.ValueSlotDeleted();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            callback(parsedEvent.offerId, parsedEvent.slotId, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * Function for adding event listeners on offer created event in offers factory contract
+     * @param callback - function for processing created offer
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onCreated(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onOfferCreated' });
+        const subscription = contract.events.OfferCreated();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            callback(parsedEvent.offerId, parsedEvent.creator, parseBytes32String(parsedEvent.externalId), {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    static onEnabled(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onOfferEnabled' });
+        const subscription = contract.events.OfferEnabled();
+        subscription.on('data', (event) => {
+            callback(event.returnValues.providerAuth, event.returnValues.offerId, event.returnValues.offerType, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    static onDisabled(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onOfferDisabled' });
+        const subscription = contract.events.OfferDisabled();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            callback(parsedEvent.providerAuth, parsedEvent.offerId, parsedEvent.offerType, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+}
+export default Offers;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Offers.js","sourceRoot":"","sources":["../../../src/staticModels/Offers.ts"],"names":[],"mappings":"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"}