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

package/dist/mjs/utils/helpers/index.js

@@ -0,0 +1,6 @@
+export * from './tryWithInterval.js';
+export * from './promise.js';
+export * from './calculateObjectHash.js';
+export * from './getRawRpc.js';
+export * from './streamToBuffer.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLHFCQUFxQixDQUFDIn0=

package/dist/mjs/utils/helpers/promise.d.ts

@@ -0,0 +1,2 @@
+export declare const isFulfilled: <T>(p: PromiseSettledResult<T>) => p is PromiseFulfilledResult<T>;
+export declare const isRejected: <T>(p: PromiseSettledResult<T>) => p is PromiseRejectedResult;

package/dist/mjs/utils/helpers/promise.js

@@ -0,0 +1,5 @@
+// Example: allSettledResults.filter(isFulfilled).map((result) => result.value)
+export const isFulfilled = (p) => p.status === 'fulfilled';
+// Example: results.filter(isRejected).forEach((rejected) => console.log(rejected.reason))
+export const isRejected = (p) => p.status === 'rejected';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvbWlzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlscy9oZWxwZXJzL3Byb21pc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0VBQStFO0FBQy9FLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxDQUFJLENBQTBCLEVBQWtDLEVBQUUsQ0FDM0YsQ0FBQyxDQUFDLE1BQU0sS0FBSyxXQUFXLENBQUM7QUFFM0IsMEZBQTBGO0FBQzFGLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxDQUFJLENBQTBCLEVBQThCLEVBQUUsQ0FDdEYsQ0FBQyxDQUFDLE1BQU0sS0FBSyxVQUFVLENBQUMifQ==

package/dist/mjs/utils/helpers/streamToBuffer.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from 'stream';
+export declare const streamToBuffer: (stream: Readable) => Promise<Buffer>;

package/dist/mjs/utils/helpers/streamToBuffer.js

@@ -0,0 +1,9 @@
+export const streamToBuffer = (stream) => {
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+        stream.on('error', (err) => reject(err));
+        stream.on('end', () => resolve(Buffer.concat(chunks)));
+    });
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyZWFtVG9CdWZmZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvaGVscGVycy9zdHJlYW1Ub0J1ZmZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsQ0FBQyxNQUFnQixFQUFtQixFQUFFO0lBQ2xFLE1BQU0sTUFBTSxHQUFhLEVBQUUsQ0FBQztJQUU1QixPQUFPLElBQUksT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxFQUFFO1FBQ3JDLE1BQU0sQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzlELE1BQU0sQ0FBQyxFQUFFLENBQUMsT0FBTyxFQUFFLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztRQUN6QyxNQUFNLENBQUMsRUFBRSxDQUFDLEtBQUssRUFBRSxHQUFHLEVBQUUsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDekQsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDLENBQUMifQ==

package/dist/mjs/utils/helpers/tryWithInterval.d.ts

@@ -0,0 +1,13 @@
+export interface TryWithIntervalParams<T> {
+    handler: () => Promise<T>;
+    checkResult?: (result: T) => {
+        isResultOk: boolean;
+    };
+    checkError?: (err: unknown) => {
+        retryable: boolean;
+    };
+    startDelay?: number;
+    retryInterval: number;
+    retryMax: number;
+}
+export declare const tryWithInterval: <T>(params: TryWithIntervalParams<T>) => Promise<T>;

package/dist/mjs/utils/helpers/tryWithInterval.js

@@ -0,0 +1,35 @@
+export const tryWithInterval = async (params) => {
+    let checkedTimes = 0;
+    const { handler, checkResult, checkError, startDelay = 0, retryInterval, retryMax } = params;
+    const reachedMaxRetries = () => checkedTimes >= retryMax;
+    return await new Promise((resolve, reject) => {
+        const scheduleNewIteration = (delay) => {
+            checkedTimes += 1;
+            setTimeout(timeoutFn, delay);
+        };
+        const timeoutFn = async () => {
+            try {
+                const result = await handler();
+                const isResultOk = checkResult ? checkResult(result).isResultOk : true;
+                if (isResultOk) {
+                    resolve(result);
+                    return;
+                }
+                if (reachedMaxRetries()) {
+                    reject(new Error(`${tryWithInterval.name}: MaxCheck count reached!`));
+                    return;
+                }
+            }
+            catch (err) {
+                const isErrorRetryable = checkError ? checkError(err).retryable : true;
+                if (!isErrorRetryable || reachedMaxRetries()) {
+                    reject(err);
+                    return;
+                }
+            }
+            scheduleNewIteration(retryInterval);
+        };
+        scheduleNewIteration(startDelay);
+    });
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJ5V2l0aEludGVydmFsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWxzL2hlbHBlcnMvdHJ5V2l0aEludGVydmFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVNBLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxLQUFLLEVBQUssTUFBZ0MsRUFBYyxFQUFFO0lBQ3ZGLElBQUksWUFBWSxHQUFHLENBQUMsQ0FBQztJQUNyQixNQUFNLEVBQUUsT0FBTyxFQUFFLFdBQVcsRUFBRSxVQUFVLEVBQUUsVUFBVSxHQUFHLENBQUMsRUFBRSxhQUFhLEVBQUUsUUFBUSxFQUFFLEdBQUcsTUFBTSxDQUFDO0lBRTdGLE1BQU0saUJBQWlCLEdBQUcsR0FBWSxFQUFFLENBQUMsWUFBWSxJQUFJLFFBQVEsQ0FBQztJQUVsRSxPQUFPLE1BQU0sSUFBSSxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUU7UUFDM0MsTUFBTSxvQkFBb0IsR0FBRyxDQUFDLEtBQWEsRUFBUSxFQUFFO1lBQ25ELFlBQVksSUFBSSxDQUFDLENBQUM7WUFDbEIsVUFBVSxDQUFDLFNBQVMsRUFBRSxLQUFLLENBQUMsQ0FBQztRQUMvQixDQUFDLENBQUM7UUFFRixNQUFNLFNBQVMsR0FBRyxLQUFLLElBQW1CLEVBQUU7WUFDMUMsSUFBSSxDQUFDO2dCQUNILE1BQU0sTUFBTSxHQUFHLE1BQU0sT0FBTyxFQUFFLENBQUM7Z0JBQy9CLE1BQU0sVUFBVSxHQUFHLFdBQVcsQ0FBQyxDQUFDLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO2dCQUN2RSxJQUFJLFVBQVUsRUFBRSxDQUFDO29CQUNmLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQztvQkFFaEIsT0FBTztnQkFDVCxDQUFDO2dCQUNELElBQUksaUJBQWlCLEVBQUUsRUFBRSxDQUFDO29CQUN4QixNQUFNLENBQUMsSUFBSSxLQUFLLENBQUMsR0FBRyxlQUFlLENBQUMsSUFBSSwyQkFBMkIsQ0FBQyxDQUFDLENBQUM7b0JBRXRFLE9BQU87Z0JBQ1QsQ0FBQztZQUNILENBQUM7WUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO2dCQUNiLE1BQU0sZ0JBQWdCLEdBQUcsVUFBVSxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7Z0JBQ3ZFLElBQUksQ0FBQyxnQkFBZ0IsSUFBSSxpQkFBaUIsRUFBRSxFQUFFLENBQUM7b0JBQzdDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztvQkFFWixPQUFPO2dCQUNULENBQUM7WUFDSCxDQUFDO1lBRUQsb0JBQW9CLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDdEMsQ0FBQyxDQUFDO1FBRUYsb0JBQW9CLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDbkMsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDLENBQUMifQ==

package/dist/mjs/utils/rent-calculator/index.d.ts

@@ -0,0 +1,2 @@
+export * from './rent-calculator.js';
+export * from './types.js';

package/dist/mjs/utils/rent-calculator/index.js

@@ -0,0 +1,3 @@
+export * from './rent-calculator.js';
+export * from './types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvcmVudC1jYWxjdWxhdG9yL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxZQUFZLENBQUMifQ==

package/dist/mjs/utils/rent-calculator/rent-calculator.d.ts

@@ -0,0 +1,14 @@
+import { OrderRentInfo, OrderThreshold, RentConfig } from './types.js';
+export declare class RentCalculator {
+    private readonly order;
+    private readonly rentConfig;
+    private readonly minimalRentPeriod;
+    private optionsTotalFixedPrice;
+    private optionsTotalPricePerHour;
+    constructor(order: OrderRentInfo, rentConfig: RentConfig);
+    calculateThreshold(orderPrice: string): OrderThreshold;
+    isAwaitingPayment(orderPrice: string): boolean;
+    calculateAwaitingPaymentDate(orderPrice: string): Date | null;
+    private calculateOrderMinimalRentPrice;
+    private getWorkingTimeMinutes;
+}

package/dist/mjs/utils/rent-calculator/rent-calculator.js

@@ -0,0 +1,110 @@
+import { PriceType } from '../../types/index.js';
+export class RentCalculator {
+    order;
+    rentConfig;
+    minimalRentPeriod;
+    optionsTotalFixedPrice = BigInt(0);
+    optionsTotalPricePerHour = BigInt(0);
+    constructor(order, rentConfig) {
+        this.order = order;
+        this.rentConfig = rentConfig;
+        const optionUsage = this.order.selectedUsage?.optionUsage || [];
+        const slotMinTimeMinutes = this.order.selectedUsage?.slotUsage?.minTimeMinutes || 0;
+        this.minimalRentPeriod =
+            Math.max(...optionUsage.map((usage) => usage.minTimeMinutes), slotMinTimeMinutes) ||
+                this.rentConfig.orderMinimumRentTimeMinutes;
+        optionUsage.forEach((usage, index) => {
+            const optionsCount = this.order.selectedUsage?.optionsCount[index] || 0;
+            const optionPrice = BigInt(usage.price) * BigInt(optionsCount);
+            if (usage.priceType === PriceType.Fixed) {
+                this.optionsTotalFixedPrice += BigInt(optionPrice);
+            }
+            else if (usage.priceType === PriceType.PerHour) {
+                this.optionsTotalPricePerHour += BigInt(optionPrice);
+            }
+        });
+    }
+    calculateThreshold(orderPrice) {
+        const deposit = BigInt(this.order.deposit || 0);
+        const depositLeft = deposit - BigInt(orderPrice);
+        const orderMinimalRentPrice = this.calculateOrderMinimalRentPrice();
+        if (orderMinimalRentPrice === 0n) {
+            // free order with PerHour type price or order with Fixed price type
+            return { orderCurrentThresholdPercent: Infinity, orderRemainTimeMinutes: Infinity };
+        }
+        const workingTimeMinutes = this.getWorkingTimeMinutes();
+        const firstMinWorkingTimePeriodRemainMinutes = this.minimalRentPeriod - workingTimeMinutes;
+        const firstMinWorkingTimePeriodThresholdPercent = (firstMinWorkingTimePeriodRemainMinutes * 100) / this.minimalRentPeriod;
+        const orderCurrentThresholdPercent = Math.max(firstMinWorkingTimePeriodThresholdPercent, 0) +
+            Number((depositLeft * 100n) / orderMinimalRentPrice);
+        const orderRemainTimeMinutes = (this.minimalRentPeriod * orderCurrentThresholdPercent) / 100;
+        return { orderCurrentThresholdPercent, orderRemainTimeMinutes };
+    }
+    isAwaitingPayment(orderPrice) {
+        const { orderCurrentThresholdPercent, orderRemainTimeMinutes } = this.calculateThreshold(orderPrice);
+        return (orderCurrentThresholdPercent < this.rentConfig.orderMaximumThresholdPercent ||
+            orderRemainTimeMinutes < this.rentConfig.orderMinimumRentTimeMinutes);
+    }
+    calculateAwaitingPaymentDate(orderPrice) {
+        const now = Date.now();
+        const { orderRemainTimeMinutes, orderCurrentThresholdPercent } = this.calculateThreshold(orderPrice);
+        const isInfThreshold = !isFinite(orderCurrentThresholdPercent);
+        const isInfTime = !isFinite(orderRemainTimeMinutes);
+        // If both are infinite (e.g., free order), no check needed soon
+        if (isInfThreshold && isInfTime) {
+            return null;
+        }
+        // Estimate time until minimal rent time violation
+        let timeToMinRentViolationMs = Infinity;
+        if (!isInfTime && orderRemainTimeMinutes >= this.rentConfig.orderMinimumRentTimeMinutes) {
+            const minutesAboveMinRent = orderRemainTimeMinutes - this.rentConfig.orderMinimumRentTimeMinutes;
+            timeToMinRentViolationMs = minutesAboveMinRent * 60 * 1000;
+        }
+        else if (!isInfTime) {
+            timeToMinRentViolationMs = 0;
+        }
+        // Estimate time until maximum threshold percentage violation
+        let timeToMaxThresholdViolationMs = Infinity;
+        const targetPercent = this.rentConfig.orderMaximumThresholdPercent;
+        if (!isInfThreshold &&
+            orderCurrentThresholdPercent > targetPercent &&
+            this.minimalRentPeriod > 0) {
+            const percentToDrop = orderCurrentThresholdPercent - targetPercent;
+            const minutesToDrop = (this.minimalRentPeriod / 100) * percentToDrop;
+            timeToMaxThresholdViolationMs = minutesToDrop * 60 * 1000;
+        }
+        else if (!isInfThreshold && orderCurrentThresholdPercent <= targetPercent) {
+            timeToMaxThresholdViolationMs = 0;
+        }
+        timeToMinRentViolationMs = Math.max(0, timeToMinRentViolationMs);
+        timeToMaxThresholdViolationMs = Math.max(0, timeToMaxThresholdViolationMs);
+        // Calculate the earliest violation time
+        const minTimeToViolationMs = Math.min(timeToMinRentViolationMs, timeToMaxThresholdViolationMs);
+        if (!isFinite(minTimeToViolationMs)) {
+            return null;
+        }
+        const targetViolationTimestamp = now + minTimeToViolationMs;
+        const finalCheckTimestamp = minTimeToViolationMs === 0 ? now : targetViolationTimestamp;
+        return new Date(finalCheckTimestamp);
+    }
+    calculateOrderMinimalRentPrice() {
+        if (!this.order.selectedUsage) {
+            throw new Error(`Rent Calculator: selectedUsage is empty`);
+        }
+        const slotUsage = this.order.selectedUsage.slotUsage;
+        const slotCount = this.order.selectedUsage.slotCount;
+        let orderPricePerHour = 0n;
+        if (slotUsage?.priceType === PriceType.PerHour) {
+            const slotCountMultiplier = BigInt(slotCount) || 1n; // slotCount is '0' for value orders
+            orderPricePerHour = BigInt(slotUsage.price) * slotCountMultiplier;
+        }
+        return (((orderPricePerHour + this.optionsTotalPricePerHour) * BigInt(this.minimalRentPeriod)) / 60n);
+    }
+    getWorkingTimeMinutes() {
+        // Math.abs - a little math trick for tests with manipulating time
+        //in integration tests startDate is bigger then Date.now()
+        const startDateMs = this.order.startDate * 1000;
+        return Math.floor(Math.abs(Date.now() - startDateMs) / (60 * 1000));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/utils/rent-calculator/types.d.ts

@@ -0,0 +1,14 @@
+import { OrderUsage, TokenAmount } from '../../types/index.js';
+export type OrderThreshold = {
+    orderCurrentThresholdPercent: number;
+    orderRemainTimeMinutes: number;
+};
+export type RentConfig = {
+    orderMinimumRentTimeMinutes: number;
+    orderMaximumThresholdPercent: number;
+};
+export type OrderRentInfo = {
+    selectedUsage: OrderUsage;
+    deposit: TokenAmount;
+    startDate: number;
+};

package/dist/mjs/utils/rent-calculator/types.js

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

package/dist/mjs/utils/resourceLoaders/BaseResourceLoader.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { Resource } from '@super-protocol/dto-js';
+import { IResourceLoader } from '../../types/ResourceLoader.js';
+export declare abstract class BaseResourceLoader implements IResourceLoader {
+    abstract download(resource: Resource): Promise<Buffer>;
+    abstract downloadToFile(resource: Resource, downloadPath: string): Promise<void>;
+    protected downloadToBuffer(readableStream: Readable): Promise<Buffer>;
+}

package/dist/mjs/utils/resourceLoaders/BaseResourceLoader.js

@@ -0,0 +1,10 @@
+export class BaseResourceLoader {
+    async downloadToBuffer(readableStream) {
+        const buffer = [];
+        for await (const chunk of readableStream) {
+            buffer.push(chunk);
+        }
+        return Buffer.concat(buffer);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmFzZVJlc291cmNlTG9hZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWxzL3Jlc291cmNlTG9hZGVycy9CYXNlUmVzb3VyY2VMb2FkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsTUFBTSxPQUFnQixrQkFBa0I7SUFLNUIsS0FBSyxDQUFDLGdCQUFnQixDQUFDLGNBQXdCO1FBQ3ZELE1BQU0sTUFBTSxHQUFpQixFQUFFLENBQUM7UUFFaEMsSUFBSSxLQUFLLEVBQUUsTUFBTSxLQUFLLElBQUksY0FBYyxFQUFFLENBQUM7WUFDekMsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNyQixDQUFDO1FBRUQsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQy9CLENBQUM7Q0FDRiJ9

package/dist/mjs/utils/resourceLoaders/StorageProviderLoader.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { Resource, ResourceType } from '@super-protocol/dto-js';
+import { IResourceLoader, ResourceLoaderConfig } from '../../types/ResourceLoader.js';
+import { BaseResourceLoader } from './BaseResourceLoader.js';
+export declare class StorageProviderLoader extends BaseResourceLoader implements IResourceLoader {
+    private static DEFAULT_RETRY_COUNT;
+    private static DEFAULT_START_OFFSET;
+    static type: ResourceType;
+    private progressListener?;
+    private chunkSize?;
+    private concurrency?;
+    private startOffset;
+    private retry;
+    constructor(config?: ResourceLoaderConfig);
+    download(resource: Resource): Promise<Buffer>;
+    downloadToFile(resource: Resource, downloadPath: string): Promise<void>;
+    private getFileStream;
+}

package/dist/mjs/utils/resourceLoaders/StorageProviderLoader.js

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import stream from 'stream';
+import { ResourceType } from '@super-protocol/dto-js';
+import { createDownloadChunkMethodWithRetry, downloadChunkMethod, DownloadDecorator, } from '../../providers/storage/ChunksDownloadDecorator.js';
+import getStorageProvider from '../../providers/storage/getStorageProvider.js';
+import { BaseResourceLoader } from './BaseResourceLoader.js';
+export class StorageProviderLoader extends BaseResourceLoader {
+    static DEFAULT_RETRY_COUNT = 3;
+    static DEFAULT_START_OFFSET = 0;
+    static type = ResourceType.StorageProvider;
+    progressListener;
+    chunkSize;
+    concurrency;
+    startOffset;
+    retry;
+    constructor(config = {}) {
+        super();
+        this.progressListener = config.progressListener;
+        this.chunkSize = config.chunkSize;
+        this.concurrency = config.concurrency;
+        this.startOffset = config.startOffset || StorageProviderLoader.DEFAULT_START_OFFSET;
+        this.retry = {
+            retryMaxCount: config.retry?.retryMaxCount || StorageProviderLoader.DEFAULT_RETRY_COUNT,
+            onRetry: config.retry?.onRetry,
+            retryWaitTimeFactory: config.retry?.retryWaitTimeFactory,
+        };
+    }
+    async download(resource) {
+        const downloadStream = await this.getFileStream(resource);
+        return this.downloadToBuffer(downloadStream);
+    }
+    async downloadToFile(resource, downloadPath) {
+        const downloadStream = await this.getFileStream(resource);
+        await stream.promises.pipeline(downloadStream, fs.createWriteStream(downloadPath));
+    }
+    getFileStream(resource) {
+        const storageProvider = getStorageProvider(resource);
+        let storageProviderToInvoke;
+        if (this.chunkSize && this.concurrency) {
+            const chunkedDownloadWithRetry = createDownloadChunkMethodWithRetry(downloadChunkMethod, this.retry);
+            storageProviderToInvoke = new DownloadDecorator(storageProvider, chunkedDownloadWithRetry, {
+                chunkSize: this.chunkSize,
+                concurrency: this.concurrency,
+                offset: this.startOffset,
+            });
+        }
+        else {
+            storageProviderToInvoke = storageProvider;
+        }
+        return storageProviderToInvoke.downloadFile(resource.filepath, {}, this.progressListener);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/utils/resourceLoaders/UrlResourceLoader.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Resource, ResourceType } from '@super-protocol/dto-js';
+import { BaseResourceLoader } from './BaseResourceLoader.js';
+export declare class UrlResourceLoader extends BaseResourceLoader {
+    static type: ResourceType;
+    download(resource: Resource): Promise<Buffer>;
+    downloadToFile(resource: Resource, downloadPath: string): Promise<void>;
+    private getFileStream;
+}

package/dist/mjs/utils/resourceLoaders/UrlResourceLoader.js

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import http from 'http';
+import https from 'https';
+import stream from 'stream';
+import { ResourceType } from '@super-protocol/dto-js';
+import { BaseResourceLoader } from './BaseResourceLoader.js';
+export class UrlResourceLoader extends BaseResourceLoader {
+    static type = ResourceType.Url;
+    async download(resource) {
+        const downloadStream = await this.getFileStream(resource);
+        return this.downloadToBuffer(downloadStream);
+    }
+    async downloadToFile(resource, downloadPath) {
+        const downloadStream = await this.getFileStream(resource);
+        await stream.promises.pipeline(downloadStream, fs.createWriteStream(downloadPath));
+    }
+    getFileStream(resource) {
+        let { url } = resource;
+        return new Promise((resolve, reject) => {
+            const fileProtocol = 'file://';
+            if (url.startsWith(fileProtocol)) {
+                url = url.substring(fileProtocol.length);
+                try {
+                    const response = fs.createReadStream(url);
+                    resolve(response);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }
+            else {
+                const module = url.startsWith('https:') ? https : http;
+                module
+                    .get(url, (response) => {
+                    resolve(response);
+                })
+                    .on('error', (error) => {
+                    reject(error);
+                });
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/utils/resourceLoaders/getResourceLoader.d.ts

@@ -0,0 +1,5 @@
+import { ResourceType } from '@super-protocol/dto-js';
+import { IResourceLoader } from '../../types/ResourceLoader.js';
+export declare const getResourceLoader: (resourceType: ResourceType) => {
+    new (): IResourceLoader;
+};

package/dist/mjs/utils/resourceLoaders/getResourceLoader.js

@@ -0,0 +1,11 @@
+import { StorageProviderLoader } from './StorageProviderLoader.js';
+import { UrlResourceLoader } from './UrlResourceLoader.js';
+export const getResourceLoader = (resourceType) => {
+    const loaders = [UrlResourceLoader, StorageProviderLoader];
+    const Loader = loaders.find((LoaderClass) => LoaderClass.type === resourceType);
+    if (!Loader) {
+        throw new Error(`Loader for type ${resourceType} is not supported`);
+    }
+    return Loader;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0UmVzb3VyY2VMb2FkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvcmVzb3VyY2VMb2FkZXJzL2dldFJlc291cmNlTG9hZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ25FLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRTNELE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLENBQUMsWUFBMEIsRUFBK0IsRUFBRTtJQUMzRixNQUFNLE9BQU8sR0FBRyxDQUFDLGlCQUFpQixFQUFFLHFCQUFxQixDQUFDLENBQUM7SUFFM0QsTUFBTSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLFdBQVcsRUFBRSxFQUFFLENBQUMsV0FBVyxDQUFDLElBQUksS0FBSyxZQUFZLENBQUMsQ0FBQztJQUVoRixJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDWixNQUFNLElBQUksS0FBSyxDQUFDLG1CQUFtQixZQUFZLG1CQUFtQixDQUFDLENBQUM7SUFDdEUsQ0FBQztJQUVELE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUMsQ0FBQyJ9

package/dist/mjs/utils/resourceLoaders/index.d.ts

@@ -0,0 +1 @@
+export * from './getResourceLoader.js';

package/dist/mjs/utils/resourceLoaders/index.js

@@ -0,0 +1,2 @@
+export * from './getResourceLoader.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvcmVzb3VyY2VMb2FkZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUMifQ==

package/dist/mjs/utils/schema-utils/index.d.ts

@@ -0,0 +1,2 @@
+export { serializeBySchema, deserializeBySchema } from './serializer.js';
+export { validateBySchema } from './validator.js';

package/dist/mjs/utils/schema-utils/index.js

@@ -0,0 +1,3 @@
+export { serializeBySchema, deserializeBySchema } from './serializer.js';
+export { validateBySchema } from './validator.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvc2NoZW1hLXV0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ3pFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGdCQUFnQixDQUFDIn0=

package/dist/mjs/utils/schema-utils/serializer.d.ts

@@ -0,0 +1,3 @@
+import { Static, TSchema } from '@sinclair/typebox';
+export declare const serializeBySchema: <T extends TSchema>(data: Record<string, unknown>, schema: T) => string;
+export declare const deserializeBySchema: <T extends TSchema, R = Static<T>>(data: string, schema: T) => R | undefined;

package/dist/mjs/utils/schema-utils/serializer.js

@@ -0,0 +1,26 @@
+import { validateBySchema } from './validator.js';
+export const serializeBySchema = (data, schema) => {
+    const { isValid, errors } = validateBySchema(data, schema);
+    if (!isValid) {
+        throw new Error(`Invalid data: ${errors?.[0]} (schema=${schema.title})`);
+    }
+    return JSON.stringify(data);
+};
+export const deserializeBySchema = (data, schema) => {
+    if (!data) {
+        return;
+    }
+    let parsedData;
+    try {
+        parsedData = JSON.parse(data);
+    }
+    catch (err) {
+        throw new Error(`Invalid json data: ${err} (schema=${schema.title})`);
+    }
+    const { isValid, errors } = validateBySchema(parsedData, schema);
+    if (!isValid) {
+        throw new Error(`Invalid data: ${errors?.[0]} (schema=${schema.title})`);
+    }
+    return parsedData;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VyaWFsaXplci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlscy9zY2hlbWEtdXRpbHMvc2VyaWFsaXplci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUVsRCxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxDQUMvQixJQUE2QixFQUM3QixNQUFTLEVBQ0QsRUFBRTtJQUNWLE1BQU0sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLEdBQUcsZ0JBQWdCLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBRTNELElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUNiLE1BQU0sSUFBSSxLQUFLLENBQUMsaUJBQWlCLE1BQU0sRUFBRSxDQUFDLENBQUMsQ0FBQyxZQUFZLE1BQU0sQ0FBQyxLQUFLLEdBQUcsQ0FBQyxDQUFDO0lBQzNFLENBQUM7SUFFRCxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDOUIsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsQ0FDakMsSUFBWSxFQUNaLE1BQVMsRUFDTSxFQUFFO0lBQ2pCLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNWLE9BQU87SUFDVCxDQUFDO0lBRUQsSUFBSSxVQUFVLENBQUM7SUFDZixJQUFJLENBQUM7UUFDSCxVQUFVLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNoQyxDQUFDO0lBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztRQUNiLE1BQU0sSUFBSSxLQUFLLENBQUMsc0JBQXNCLEdBQUcsWUFBWSxNQUFNLENBQUMsS0FBSyxHQUFHLENBQUMsQ0FBQztJQUN4RSxDQUFDO0lBRUQsTUFBTSxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUUsR0FBRyxnQkFBZ0IsQ0FBQyxVQUFVLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFFakUsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ2IsTUFBTSxJQUFJLEtBQUssQ0FBQyxpQkFBaUIsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDLFlBQVksTUFBTSxDQUFDLEtBQUssR0FBRyxDQUFDLENBQUM7SUFDM0UsQ0FBQztJQUVELE9BQU8sVUFBVSxDQUFDO0FBQ3BCLENBQUMsQ0FBQyJ9

package/dist/mjs/utils/schema-utils/validator.d.ts

@@ -0,0 +1,7 @@
+import { TSchema } from '@sinclair/typebox';
+export declare const validateBySchema: <T extends TSchema>(data: Record<string, unknown>, schema: T, options?: {
+    allErrors: boolean;
+}) => {
+    isValid: boolean;
+    errors?: string[] | undefined;
+};

package/dist/mjs/utils/schema-utils/validator.js

@@ -0,0 +1,45 @@
+import { TypeCompiler } from '@sinclair/typebox/compiler';
+import { createHash } from 'crypto';
+import { Encoding, HashAlgorithm } from '@super-protocol/dto-js';
+const schemaCache = new Map();
+const compileSchema = (schema) => {
+    const schemaHash = createHash(HashAlgorithm.SHA256)
+        .update(JSON.stringify(schema))
+        .digest(Encoding.hex);
+    if (!schemaCache.has(schemaHash)) {
+        const compiledSchema = TypeCompiler.Compile(schema);
+        schemaCache.set(schemaHash, compiledSchema);
+    }
+    return schemaCache.get(schemaHash);
+};
+const enhanceErrorMessage = (error) => {
+    const { path, value, schema } = error;
+    const descriptions = (schema.anyOf || [])
+        .map((subSchema) => subSchema.description)
+        .filter(Boolean);
+    const specificError = descriptions.length > 0
+        ? descriptions.join('; ')
+        : schema.errorMessage?.type ?? 'Invalid value';
+    return `Validation error at ${path}: ${error.message}\nvalue: ${JSON.stringify(value)}\ndetailed info: ${specificError}`;
+};
+export const validateBySchema = (data, schema, options) => {
+    const validator = compileSchema(schema);
+    const isValid = validator.Check(data);
+    const allErrors = options?.allErrors ?? false;
+    let errors;
+    if (!isValid) {
+        const errorsIterator = validator.Errors(data);
+        if (allErrors) {
+            errors = [...errorsIterator].map(enhanceErrorMessage);
+        }
+        else {
+            const firstError = errorsIterator.First();
+            errors = firstError ? [enhanceErrorMessage(firstError)] : undefined;
+        }
+    }
+    return {
+        isValid,
+        ...(errors && { errors }),
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/utils/tcb.d.ts

@@ -0,0 +1,2 @@
+import { SignedTcbData } from '../types/Consensus.js';
+export declare function getTcbDataHash(signableData: SignedTcbData): string;

package/dist/mjs/utils/tcb.js

@@ -0,0 +1,9 @@
+import { ethers } from 'ethers';
+export function getTcbDataHash(signableData) {
+    const sizes = 'uint64 cpuSize,uint64 ramSize,uint64 gpuSize,uint64 diskSize,uint64 networkSize,uint64 vramSize';
+    const marks = 'uint32 cpuMark,uint32 ramMark,uint32 gpuMark,uint32 diskMark,uint32 networkMark';
+    const cpuInfo = 'tuple(string vendorId, uint128 cpuFamily, uint128 model, string modelName, uint32 totalPhysicalCores, uint32 baseFreq, uint32 maxFreq) cpuInfo';
+    const userData = ethers.AbiCoder.defaultAbiCoder().encode(['uint256', `tuple(${sizes},${marks},${cpuInfo})`, 'string'], [signableData.teeOfferId, signableData.benchmark, signableData.pubKey]);
+    return ethers.sha256(userData).slice(2); // remove 0x
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGNiLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxzL3RjYi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBR2hDLE1BQU0sVUFBVSxjQUFjLENBQUMsWUFBMkI7SUFDeEQsTUFBTSxLQUFLLEdBQ1QsaUdBQWlHLENBQUM7SUFDcEcsTUFBTSxLQUFLLEdBQUcsaUZBQWlGLENBQUM7SUFDaEcsTUFBTSxPQUFPLEdBQ1gsZ0pBQWdKLENBQUM7SUFFbkosTUFBTSxRQUFRLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxlQUFlLEVBQUUsQ0FBQyxNQUFNLENBQ3ZELENBQUMsU0FBUyxFQUFFLFNBQVMsS0FBSyxJQUFJLEtBQUssSUFBSSxPQUFPLEdBQUcsRUFBRSxRQUFRLENBQUMsRUFDNUQsQ0FBQyxZQUFZLENBQUMsVUFBVSxFQUFFLFlBQVksQ0FBQyxTQUFTLEVBQUUsWUFBWSxDQUFDLE1BQU0sQ0FBQyxDQUN2RSxDQUFDO0lBRUYsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLFlBQVk7QUFDdkQsQ0FBQyJ9

package/dist/mjs/utils/tokens/get-tokens-info.d.ts

@@ -0,0 +1,8 @@
+import { TokenInfoStruct } from '../../contracts/typechain-types/hardhat-diamond-abi/HardhatDiamondABI.sol/App.js';
+type ExtendedTokenInfo = Omit<TokenInfoStruct, 'tokenAddress'> & {
+    index: number;
+    address: string;
+    symbol: string;
+};
+export declare const getTokensInfo: () => Promise<ExtendedTokenInfo[]>;
+export {};

package/dist/mjs/utils/tokens/get-tokens-info.js

@@ -0,0 +1,25 @@
+import logger from '../../logger.js';
+import Superpro from '../../staticModels/Superpro.js';
+import SuperproToken from '../../staticModels/SuperproToken.js';
+export const getTokensInfo = async () => {
+    const tokens = await Superpro.getTokens();
+    const output = [];
+    for (const token of tokens) {
+        const contract = SuperproToken.createContract(token.tokenInfo.tokenAddress);
+        const symbol = await SuperproToken.symbol(contract).catch((err) => {
+            logger.error(err, `Failed to get token symbol (tokenAddress=${token.tokenInfo.tokenAddress})`);
+            throw err;
+        });
+        output.push({
+            index: Number(token.index),
+            address: token.tokenInfo.tokenAddress,
+            symbol,
+            isPrimary: token.tokenInfo.isPrimary,
+            protocolCommissionPercent: token.tokenInfo.protocolCommissionPercent,
+            storageRequestFee: token.tokenInfo.storageRequestFee,
+            considerInProviderReward: token.tokenInfo.considerInProviderReward,
+        });
+    }
+    return output;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXRva2Vucy1pbmZvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWxzL3Rva2Vucy9nZXQtdG9rZW5zLWluZm8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxNQUFNLE1BQU0saUJBQWlCLENBQUM7QUFDckMsT0FBTyxRQUFRLE1BQU0sZ0NBQWdDLENBQUM7QUFDdEQsT0FBTyxhQUFhLE1BQU0scUNBQXFDLENBQUM7QUFRaEUsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLEtBQUssSUFBa0MsRUFBRTtJQUNwRSxNQUFNLE1BQU0sR0FBRyxNQUFNLFFBQVEsQ0FBQyxTQUFTLEVBQUUsQ0FBQztJQUMxQyxNQUFNLE1BQU0sR0FBd0IsRUFBRSxDQUFDO0lBRXZDLEtBQUssTUFBTSxLQUFLLElBQUksTUFBTSxFQUFFLENBQUM7UUFDM0IsTUFBTSxRQUFRLEdBQUcsYUFBYSxDQUFDLGNBQWMsQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQzVFLE1BQU0sTUFBTSxHQUFHLE1BQU0sYUFBYSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRTtZQUNoRSxNQUFNLENBQUMsS0FBSyxDQUNWLEdBQUcsRUFDSCw0Q0FBNEMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxZQUFZLEdBQUcsQ0FDNUUsQ0FBQztZQUNGLE1BQU0sR0FBRyxDQUFDO1FBQ1osQ0FBQyxDQUFDLENBQUM7UUFFSCxNQUFNLENBQUMsSUFBSSxDQUFDO1lBQ1YsS0FBSyxFQUFFLE1BQU0sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDO1lBQzFCLE9BQU8sRUFBRSxLQUFLLENBQUMsU0FBUyxDQUFDLFlBQVk7WUFDckMsTUFBTTtZQUNOLFNBQVMsRUFBRSxLQUFLLENBQUMsU0FBUyxDQUFDLFNBQVM7WUFDcEMseUJBQXlCLEVBQUUsS0FBSyxDQUFDLFNBQVMsQ0FBQyx5QkFBeUI7WUFDcEUsaUJBQWlCLEVBQUUsS0FBSyxDQUFDLFNBQVMsQ0FBQyxpQkFBaUI7WUFDcEQsd0JBQXdCLEVBQUUsS0FBSyxDQUFDLFNBQVMsQ0FBQyx3QkFBd0I7U0FDbkUsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUMsQ0FBQyJ9

package/dist/mjs/utils/tokens/index.d.ts

@@ -0,0 +1 @@
+export * from './get-tokens-info.js';

package/dist/mjs/utils/tokens/index.js

@@ -0,0 +1,2 @@
+export * from './get-tokens-info.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvdG9rZW5zL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUMifQ==