@super-protocol/sdk-js 2.1.2 → 2.1.3

package/dist/mjs/staticModels/ProviderRegistry.js

@@ -0,0 +1,169 @@
+import rootLogger from '../logger.js';
+import { checkIfActionAccountInitialized, cleanWeb3Data } from '../utils/helper.js';
+import { BlockchainConnector, BlockchainEventsListener } from '../connectors/index.js';
+import TxManager from '../utils/TxManager.js';
+class ProviderRegistry {
+    static logger = rootLogger.child({ className: 'ProviderRegistry' });
+    static providers;
+    /**
+     * Function for fetching list of all providers addresses
+     */
+    static async getAllProviders() {
+        const contract = BlockchainConnector.getInstance().getContract();
+        this.providers = await contract.methods.getProvidersAuths().call();
+        return this.providers;
+    }
+    static isProviderRegistered(providerAuthority) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return contract.methods.isProviderRegistered(providerAuthority).call();
+    }
+    /**
+     * Refills security provider deposit
+     * Call this function with provider authority account (in transactionOptions)
+     * @param amount - amount of additional tokens
+     * @param recipient - target provider authority address
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async refillSecurityDepositFor(amount, recipient, transactionOptions) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        checkIfActionAccountInitialized(transactionOptions);
+        await TxManager.execute(contract.methods.refillProviderSecurityDepoFor(recipient, amount), transactionOptions);
+    }
+    /**
+     * Reg new provider
+     * @param providerInfo - data of new provider
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async registerProvider(providerInfo, transactionOptions) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        checkIfActionAccountInitialized(transactionOptions);
+        await TxManager.execute(contract.methods.registerProvider(providerInfo), transactionOptions);
+    }
+    /**
+     * Refills security deposit for provider
+     * Call this function with provider authority account (in transactionOptions)
+     * @param amount - amount of additional tokens
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async refillSecurityDeposit(amount, transactionOptions) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        checkIfActionAccountInitialized(transactionOptions);
+        await TxManager.execute(contract.methods.refillProviderSecurityDepo(amount), transactionOptions);
+    }
+    /**
+     * Return security deposit for provider
+     * Call this function with provider authority account (in transactionOptions)
+     * @param amount - amount of tokens to return
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async returnSecurityDeposit(amount, transactionOptions) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        checkIfActionAccountInitialized(transactionOptions);
+        await TxManager.execute(contract.methods.returnProviderSecurityDepo(amount), transactionOptions);
+    }
+    /**
+     * Function for adding event listeners on provider registered event in provider registry
+     * @param callback - function for processing new provider
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onProviderRegistered(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onProviderRegistered' });
+        const subscription = contract.events.ProviderRegistered();
+        subscription.on('data', (event) => {
+            callback(event.returnValues.auth, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * Function for adding event listeners on provider modified event in provider registry
+     * @param callback - function for processing modified provider
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onProviderModified(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onProviderModified' });
+        const subscription = contract.events.ProviderModified();
+        subscription.on('data', (event) => {
+            callback(event.returnValues.auth, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * Function for adding event listeners on provider violation rate incremented event in provider registry
+     * @param callback - function for processing new violation rate
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onProviderViolationRateIncremented(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onProviderViolationRateIncremented' });
+        const subscription = contract.events.ProviderViolationRateIncremented();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            callback(parsedEvent.auth, parsedEvent.newViolationRate, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * Function for adding event listeners on provider security deposit refilled event in provider registry
+     * @param callback - function for processing refilled security deposit
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onProviderSecurityDepoRefilled(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onProviderSecurityDepoRefilled' });
+        const subscription = contract.events.ProviderSecurityDepoRefilled();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            callback(parsedEvent.auth, parsedEvent.amount, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * Function for adding event listeners on provider security deposit unlocked event in provider registry
+     * @param callback - function for processing unlocked security deposit
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onProviderSecurityDepoUnlocked(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onProviderSecurityDepoUnlocked' });
+        const subscription = contract.events.ProviderSecurityDepoUnlocked();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            callback(parsedEvent.auth, parsedEvent.amount, {
+                index: Number(event.blockNumber),
+                hash: parsedEvent.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+}
+export default ProviderRegistry;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,8 @@
+import { ContractEvents } from 'web3';
+import { FilterWithExternalId } from '../types/index.js';
+import abi from '../contracts/abi.js';
+declare class StaticModel {
+    private static readonly logger;
+    static findItemsById(eventName: keyof ContractEvents<typeof abi>, filter: FilterWithExternalId, fromBlock?: number | string, toBlock?: number | string): Promise<unknown>;
+}
+export default StaticModel;

package/dist/mjs/staticModels/StaticModel.js

@@ -0,0 +1,30 @@
+import { formatBytes32String, parseBytes32String } from 'ethers/lib/utils.js';
+import BlockchainConnector from '../connectors/BlockchainConnector.js';
+import rootLogger from '../logger.js';
+import { cleanWeb3Data, isValidBytes32Hex } from '../utils/helper.js';
+class StaticModel {
+    static logger = rootLogger.child({ className: 'Offers' });
+    static async findItemsById(eventName, filter, fromBlock, toBlock) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        const options = { filter };
+        if (!isValidBytes32Hex(filter.externalId)) {
+            options.filter.externalId = formatBytes32String(filter.externalId);
+        }
+        if (fromBlock)
+            options.fromBlock = fromBlock;
+        if (toBlock)
+            options.toBlock = toBlock;
+        const foundIds = await contract.getPastEvents(eventName, options);
+        if (!foundIds.length) {
+            return null;
+        }
+        if (foundIds.length > 1) {
+            StaticModel.logger.warn({ eventName, foundIds }, `More than one item found, please refine your filters!`);
+        }
+        const parsedEvent = cleanWeb3Data(foundIds[0].returnValues);
+        parsedEvent.externalId = parseBytes32String(parsedEvent.externalId);
+        return parsedEvent;
+    }
+}
+export default StaticModel;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3RhdGljTW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RhdGljTW9kZWxzL1N0YXRpY01vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRTlFLE9BQU8sbUJBQW1CLE1BQU0sc0NBQXNDLENBQUM7QUFFdkUsT0FBTyxVQUFVLE1BQU0sY0FBYyxDQUFDO0FBQ3RDLE9BQU8sRUFBRSxhQUFhLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQVF0RSxNQUFNLFdBQVc7SUFDUCxNQUFNLENBQVUsTUFBTSxHQUFHLFVBQVUsQ0FBQyxLQUFLLENBQUMsRUFBRSxTQUFTLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQztJQUVwRSxNQUFNLENBQUMsS0FBSyxDQUFDLGFBQWEsQ0FDL0IsU0FBMkMsRUFDM0MsTUFBNEIsRUFDNUIsU0FBMkIsRUFDM0IsT0FBeUI7UUFFekIsTUFBTSxRQUFRLEdBQUcsbUJBQW1CLENBQUMsV0FBVyxFQUFFLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDakUsTUFBTSxPQUFPLEdBQWlCLEVBQUUsTUFBTSxFQUFFLENBQUM7UUFDekMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsRUFBRSxDQUFDO1lBQzFDLE9BQU8sQ0FBQyxNQUFPLENBQUMsVUFBVSxHQUFHLG1CQUFtQixDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUN0RSxDQUFDO1FBQ0QsSUFBSSxTQUFTO1lBQUUsT0FBTyxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7UUFDN0MsSUFBSSxPQUFPO1lBQUUsT0FBTyxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFFdkMsTUFBTSxRQUFRLEdBQUcsTUFBTSxRQUFRLENBQUMsYUFBYSxDQUFDLFNBQVMsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUNsRSxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ3JCLE9BQU8sSUFBSSxDQUFDO1FBQ2QsQ0FBQztRQUNELElBQUksUUFBUSxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUN4QixXQUFXLENBQUMsTUFBTSxDQUFDLElBQUksQ0FDckIsRUFBRSxTQUFTLEVBQUUsUUFBUSxFQUFFLEVBQ3ZCLHVEQUF1RCxDQUN4RCxDQUFDO1FBQ0osQ0FBQztRQUVELE1BQU0sV0FBVyxHQUFHLGFBQWEsQ0FDOUIsUUFBUSxDQUFDLENBQUMsQ0FBYyxDQUFDLFlBQTZCLENBQ3BCLENBQUM7UUFDdEMsV0FBVyxDQUFDLFVBQVUsR0FBRyxrQkFBa0IsQ0FBQyxXQUFXLENBQUMsVUFBVSxDQUFDLENBQUM7UUFFcEUsT0FBTyxXQUFXLENBQUM7SUFDckIsQ0FBQzs7QUFHSCxlQUFlLFdBQVcsQ0FBQyJ9

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

@@ -0,0 +1,16 @@
+import { ParamName } from '../types/index.js';
+import { Contract } from 'web3';
+import abi from '../contracts/abi.js';
+declare class Superpro {
+    static address: string;
+    /**
+     * Fetching address of contract by name
+     */
+    static getContractAddress(): string;
+    static getTokenAddress(contractInstance?: Contract<typeof abi>): Promise<string>;
+    /**
+     * Fetching config parameter value by name
+     */
+    static getParam(name: ParamName): Promise<string>;
+}
+export default Superpro;

package/dist/mjs/staticModels/Superpro.js

@@ -0,0 +1,23 @@
+import { BlockchainConnector } from '../connectors/index.js';
+class Superpro {
+    static address;
+    /**
+     * Fetching address of contract by name
+     */
+    static getContractAddress() {
+        return this.address;
+    }
+    static getTokenAddress(contractInstance) {
+        const contract = contractInstance || BlockchainConnector.getInstance().getContract();
+        return contract.methods.getToken().call();
+    }
+    /**
+     * Fetching config parameter value by name
+     */
+    static getParam(name) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return contract.methods.getConfigParam(name).call();
+    }
+}
+export default Superpro;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3VwZXJwcm8uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RhdGljTW9kZWxzL1N1cGVycHJvLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBSTdELE1BQU0sUUFBUTtJQUNMLE1BQU0sQ0FBQyxPQUFPLENBQVM7SUFFOUI7O09BRUc7SUFDSSxNQUFNLENBQUMsa0JBQWtCO1FBQzlCLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN0QixDQUFDO0lBRU0sTUFBTSxDQUFDLGVBQWUsQ0FBQyxnQkFBdUM7UUFDbkUsTUFBTSxRQUFRLEdBQUcsZ0JBQWdCLElBQUksbUJBQW1CLENBQUMsV0FBVyxFQUFFLENBQUMsV0FBVyxFQUFFLENBQUM7UUFFckYsT0FBTyxRQUFRLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQzVDLENBQUM7SUFFRDs7T0FFRztJQUNJLE1BQU0sQ0FBQyxRQUFRLENBQUMsSUFBZTtRQUNwQyxNQUFNLFFBQVEsR0FBRyxtQkFBbUIsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUVqRSxPQUFPLFFBQVEsQ0FBQyxPQUFPLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3RELENBQUM7Q0FDRjtBQUVELGVBQWUsUUFBUSxDQUFDIn0=

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

@@ -0,0 +1,48 @@
+import { Transaction } from 'web3';
+import { TransactionOptions, BlockInfo, TokenAmount } from '../types/index.js';
+declare class SuperproToken {
+    private static _addressHttps;
+    private static _addressWss;
+    private static contractHttps?;
+    private static contractWss?;
+    private static readonly logger;
+    static get addressHttps(): string;
+    static set addressHttps(newAddress: string);
+    static get addressWss(): string;
+    static set addressWss(newAddress: string);
+    /**
+     * Checks if contract has been initialized, if not - initialize contract
+     */
+    private static checkInit;
+    /**
+     * Checks if contract has been initialized with socket support
+     */
+    private static checkWssInit;
+    /**
+     * Fetching balance of SuperProtocol tokens on address
+     */
+    static balanceOf(address: string): Promise<TokenAmount>;
+    /**
+     * Fetching allowance of SuperProtocol tokens on address
+     */
+    static allowance(from: string, to: string): Promise<TokenAmount>;
+    /**
+     * Transfers specific amount of SP tokens to specific address
+     * @param to - address to revive tokens
+     * @param amount - amount of tokens to transfer
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static transfer(to: string, amount: TokenAmount, transactionOptions?: TransactionOptions, checkTxBeforeSend?: boolean): Promise<Transaction>;
+    /**
+     * Approve tokens for specific address
+     * @param address - address for approval
+     * @param amount - number of tokens to be approved
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static approve(address: string, amount: TokenAmount, transactionOptions?: TransactionOptions, checkTxBeforeSend?: boolean): Promise<void>;
+    static onTokenApprove(callback: onTokenApproveCallback, owner?: string, spender?: string): () => void;
+    static onTokenTransfer(callback: onTokenTransferCallback, from?: string, to?: string): () => void;
+}
+export type onTokenApproveCallback = (owner: string, spender: string, value: TokenAmount, block?: BlockInfo) => void;
+export type onTokenTransferCallback = (from: string, to: string, value: TokenAmount, block?: BlockInfo) => void;
+export default SuperproToken;

package/dist/mjs/staticModels/SuperproToken.js

@@ -0,0 +1,136 @@
+import rootLogger from '../logger.js';
+import { abi } from '../contracts/abi.js';
+import store from '../store.js';
+import { checkIfActionAccountInitialized, cleanWeb3Data, convertBigIntToString, } from '../utils/helper.js';
+import TxManager from '../utils/TxManager.js';
+class SuperproToken {
+    static _addressHttps;
+    static _addressWss;
+    static contractHttps;
+    static contractWss;
+    static logger = rootLogger.child({ className: 'SuperproToken' });
+    static get addressHttps() {
+        return SuperproToken._addressHttps;
+    }
+    static set addressHttps(newAddress) {
+        SuperproToken._addressHttps = newAddress;
+        SuperproToken.contractHttps = new store.web3Https.eth.Contract(abi, newAddress, {
+            provider: store.web3Https.currentProvider,
+            config: { contractDataInputFill: 'data' },
+        });
+    }
+    static get addressWss() {
+        return SuperproToken._addressWss;
+    }
+    static set addressWss(newAddress) {
+        SuperproToken._addressWss = newAddress;
+        SuperproToken.contractWss = new store.web3Wss.eth.Contract(abi, newAddress, {
+            provider: store.web3Wss.currentProvider,
+            config: { contractDataInputFill: 'data' },
+        });
+    }
+    /**
+     * Checks if contract has been initialized, if not - initialize contract
+     */
+    static checkInit() {
+        if (!SuperproToken.contractHttps) {
+            throw Error(`SuperproToken must be initialized before it can be used`);
+        }
+        return SuperproToken.contractHttps;
+    }
+    /**
+     * Checks if contract has been initialized with socket support
+     */
+    static checkWssInit() {
+        return SuperproToken.contractWss;
+    }
+    /**
+     * Fetching balance of SuperProtocol tokens on address
+     */
+    static async balanceOf(address) {
+        this.checkInit();
+        return convertBigIntToString(await this.contractHttps.methods.balanceOf(address).call());
+    }
+    /**
+     * Fetching allowance of SuperProtocol tokens on address
+     */
+    static async allowance(from, to) {
+        this.checkInit();
+        return convertBigIntToString(await this.contractHttps.methods.allowance(from, to).call());
+    }
+    /**
+     * Transfers specific amount of SP tokens to specific address
+     * @param to - address to revive tokens
+     * @param amount - amount of tokens to transfer
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async transfer(to, amount, transactionOptions, checkTxBeforeSend = false) {
+        const contract = this.checkInit();
+        checkIfActionAccountInitialized(transactionOptions);
+        if (checkTxBeforeSend) {
+            await TxManager.dryRun(contract.methods.transfer(to, amount), transactionOptions);
+        }
+        const receipt = await TxManager.execute(contract.methods.transfer(to, amount), transactionOptions, SuperproToken.addressHttps);
+        return store.web3Https.eth.getTransaction(receipt.transactionHash);
+    }
+    /**
+     * Approve tokens for specific address
+     * @param address - address for approval
+     * @param amount - number of tokens to be approved
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async approve(address, amount, transactionOptions, checkTxBeforeSend = false) {
+        const contract = this.checkInit();
+        checkIfActionAccountInitialized(transactionOptions);
+        if (checkTxBeforeSend) {
+            await TxManager.dryRun(contract.methods.approve(address, amount), transactionOptions);
+        }
+        await TxManager.execute(contract.methods.approve(address, amount), transactionOptions, SuperproToken.addressHttps);
+    }
+    static onTokenApprove(callback, owner, spender) {
+        const contract = this.checkWssInit();
+        const logger = this.logger.child({ method: 'onTokenApprove' });
+        const subscription = contract.events.Approval();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            if (owner && parsedEvent.owner != owner) {
+                return;
+            }
+            if (spender && parsedEvent.spender != spender) {
+                return;
+            }
+            callback(parsedEvent.owner, parsedEvent.spender, parsedEvent.value, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    static onTokenTransfer(callback, from, to) {
+        const contract = this.checkWssInit();
+        const logger = this.logger.child({ method: 'onTokenTransfer' });
+        const subscription = contract.events.Transfer();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            if (from && parsedEvent.from != from) {
+                return;
+            }
+            if (to && parsedEvent.to != to) {
+                return;
+            }
+            callback(parsedEvent.from, parsedEvent.to, parsedEvent.value, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+}
+export default SuperproToken;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,115 @@
+import { BlockInfo, TransactionOptions, HardwareInfo, TeeOfferInfo, OfferCreatedEvent, OptionAddedEvent, TeeSlotAddedEvent, TeeOfferOption, BlockchainId } from '../types/index.js';
+declare class TeeOffers {
+    private static coresDenominator?;
+    private static readonly logger;
+    static teeOffers: BlockchainId[];
+    static get address(): string;
+    static packHardwareInfo(hw: HardwareInfo): Promise<HardwareInfo>;
+    static unpackHardwareInfo(hw: HardwareInfo): Promise<HardwareInfo>;
+    static getDenominator(): Promise<number>;
+    /**
+     * Function for fetching list of all TEE offers addresses
+     */
+    static getAll(): Promise<BlockchainId[]>;
+    /**
+     * Creates new TEE offer
+     * @param providerAuthorityAccount - address of authority account of provider
+     * @param teeOfferInfo - data of new TEE offer
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static create(providerAuthorityAccount: string, teeOfferInfo: TeeOfferInfo, externalId?: string, enabled?: boolean, transactionOptions?: TransactionOptions): Promise<void>;
+    static getByExternalId(filter: {
+        externalId: string;
+        creator?: string;
+    }, fromBlock?: number | string, toBlock?: number | string): Promise<OfferCreatedEvent | null>;
+    /**
+     * Function for fetching TEE offer id by TEE deviceId
+     * @param deviceId - unque TEE device id (unparsed, from blockchain)
+     * @returns TEE offer id
+     */
+    static getByDeviceId(deviceId: string): Promise<BlockchainId>;
+    /**
+     * Function for fetching total count of tee offer slots
+     */
+    static getSlotsCount(): Promise<number>;
+    /**
+     * Function for fetching whether tee offer option exists or not
+     * @param optionId - Option ID
+     */
+    static isOptionExists(optionId: BlockchainId): Promise<boolean>;
+    /**
+     * Function for fetching total count of options
+     */
+    static getOptionsCount(): Promise<number>;
+    /**
+     * Function for fetching tee offer option by id
+     * @param optionId - Option ID
+     */
+    static getOptionById(optionId: BlockchainId): Promise<TeeOfferOption>;
+    static getSlotByExternalId(filter: {
+        externalId: string;
+        creator?: string;
+        offerId?: BlockchainId;
+    }, fromBlock?: number | string, toBlock?: number | string): Promise<TeeSlotAddedEvent | null>;
+    static getOptionByExternalId(filter: {
+        externalId: string;
+        creator?: string;
+        teeOfferId?: BlockchainId;
+    }, fromBlock?: number | string, toBlock?: number | string): Promise<OptionAddedEvent | 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: onTeeSlotAddedCallback, 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: onTeeSlotUpdatedCallback): () => 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: onTeeSlotDeletedCallback): () => void;
+    /**
+     * Function for adding event listeners on OptionAdded event in contract
+     * @param creator - creator address
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onOptionAdded(callback: onTeeOptionAddedCallback, creator?: string): () => void;
+    /**
+     * Function for adding event listeners on OptionUpdated event in contract
+     * @param teeOfferId - tee offer id
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onOptionUpdated(callback: onTeeOptionUpdatedCallback, teeOfferId?: BlockchainId): () => void;
+    /**
+     * Function for adding event listeners on OptionDeleted event in contract
+     * @param teeOfferId - tee offer id
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onOptionDeleted(callback: onTeeOptionDeletedCallback, teeOfferId?: BlockchainId): () => void;
+    /**
+     * Function for adding event listeners on TEE offer created event in TEE offers factory contract
+     * @param callback - function for processing created TEE offer
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onCreated(callback: onTeeOfferCreatedCallback): () => void;
+    static onViolationRateChanged(callback: onTeeViolationRateChangedCallback): () => void;
+}
+export type onTeeOfferCreatedCallback = (offerId: BlockchainId, creator: string, externalId: string, block?: BlockInfo) => void;
+export type onTeeViolationRateChangedCallback = (offerId: BlockchainId, providerAuth: string, violationRate: bigint | string, block?: BlockInfo) => void;
+export type onTeeOptionAddedCallback = (creator: string, teeOfferId: BlockchainId, optionId: BlockchainId, externalId: string, block?: BlockInfo) => void;
+export type onTeeOptionUpdatedCallback = (teeOfferId: BlockchainId, optionId: BlockchainId, block?: BlockInfo) => void;
+export type onTeeOptionDeletedCallback = (teeOfferId: BlockchainId, optionId: BlockchainId, block?: BlockInfo) => void;
+export type onTeeSlotAddedCallback = (creator: string, offerId: BlockchainId, slotId: BlockchainId, externalId: string, block?: BlockInfo) => void;
+export type onTeeSlotUpdatedCallback = (offerId: BlockchainId, slotId: BlockchainId, block?: BlockInfo) => void;
+export type onTeeSlotDeletedCallback = (offerId: BlockchainId, slotId: BlockchainId, block?: BlockInfo) => void;
+export default TeeOffers;