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

package/dist/mjs/utils/cache/memory.spec.js

@@ -0,0 +1,89 @@
+import { MemoryCache } from './memory.js';
+describe('MemoryCache', () => {
+    let cache;
+    beforeEach(() => {
+        cache = new MemoryCache();
+        jest.useFakeTimers();
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    describe('wrap', () => {
+        it('wrap method retrieves value from cache and calls function if not in cache', async () => {
+            const mockFunction = jest.fn(() => 'result');
+            await cache.wrap('key', mockFunction);
+            await cache.wrap('key', mockFunction);
+            expect(mockFunction).toHaveBeenCalledTimes(1);
+            expect(cache.get('key')).toBe('result');
+        });
+        it('wrap method does not updates value in cache if key is existed', async () => {
+            const mockFunction = jest.fn(() => 'new result');
+            cache.add('key', 'old result');
+            await cache.wrap('key', mockFunction);
+            expect(mockFunction).not.toHaveBeenCalled();
+            expect(cache.get('key')).toBe('old result');
+        });
+        it('wrap method updates value in cache with ttl', async () => {
+            const mockFunction = jest.fn(() => 'new result');
+            await cache.wrap('key', mockFunction, { ttl: 1 });
+            expect(cache.get('key')).toBe('new result');
+            jest.advanceTimersByTime(2000);
+            expect(cache.get('key')).toBeUndefined();
+        });
+        it('wrap method respects ttl and calls function again after expiration', async () => {
+            const mockFunction = jest.fn(() => 'result');
+            // First call - should cache the result
+            await cache.wrap('key', mockFunction, { ttl: 1 });
+            expect(mockFunction).toHaveBeenCalledTimes(1);
+            expect(cache.get('key')).toBe('result');
+            // Second call before expiration - should use cached value
+            await cache.wrap('key', mockFunction, { ttl: 1 });
+            expect(mockFunction).toHaveBeenCalledTimes(1);
+            expect(cache.get('key')).toBe('result');
+            // Advance time past TTL
+            jest.advanceTimersByTime(2000);
+            // Third call after expiration - should call function again
+            await cache.wrap('key', mockFunction, { ttl: 1 });
+            expect(mockFunction).toHaveBeenCalledTimes(2);
+            expect(cache.get('key')).toBe('result');
+        });
+    });
+    describe('add', () => {
+        it('add method adds value to the cache', () => {
+            expect(cache.add('key', 'value')).toBe(true);
+            expect(cache.add('key', 'value')).toBe(false);
+            expect(cache.add('nullKey', null)).toBe(true);
+        });
+        it('add method with ttl adds value to the cache and expires correctly', () => {
+            cache.add('key', 'value', 1);
+            expect(cache.get('key')).toBe('value');
+            jest.advanceTimersByTime(1000);
+            expect(cache.get('key')).toBe('value');
+            jest.advanceTimersByTime(2000);
+            expect(cache.get('key')).toBeUndefined();
+            expect(cache.add('key', 'new value')).toBe(true);
+            expect(cache.get('key')).toBe('new value');
+        });
+    });
+    it('get method retrieves value from the cache', () => {
+        cache.add('key', 'value');
+        cache.add('nullKey', null);
+        expect(cache.get('key')).toBe('value');
+        expect(cache.get('nullKey')).toBeNull();
+    });
+    it('del method removes value from the cache', () => {
+        cache.add('key', 'value');
+        expect(cache.get('key')).toBe('value');
+        cache.del('key');
+        expect(cache.get('key')).toBeUndefined();
+    });
+    it('set method updates value in the cache', () => {
+        cache.add('key', 'value');
+        expect(cache.get('key')).toBe('value');
+        cache.set('key', 'new value');
+        expect(cache.get('key')).toBe('new value');
+        cache.set('nullKey', null);
+        expect(cache.get('nullKey')).toBeNull();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/utils/cache/types.d.ts

@@ -0,0 +1,17 @@
+export interface ICache {
+    add(key: string, value: unknown, ttl?: number): boolean;
+    del(...keys: string[]): boolean;
+    get(key: string): unknown | undefined;
+    set(key: string, value: unknown, ttl?: number): void;
+    wrap<T>(key: string, fn: () => Promise<T>, options?: {
+        ttl?: number;
+        force?: boolean;
+    }): Promise<T>;
+}
+export type MemoryCacheOptions = {
+    prefix?: string;
+    initCache?: Map<string, {
+        v: unknown | null;
+        ttl?: number;
+    }>;
+};

package/dist/mjs/utils/cache/types.js

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

package/dist/mjs/utils/compressors/GzipCompressor.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Compression_TYPE } from '../../proto/Compression.js';
+import { Compressor } from '../../types/Compressor.js';
+export declare class GzipCompressor<T> implements Compressor<T> {
+    static type: Compression_TYPE;
+    compress(content: T): Promise<Buffer>;
+    decompress(bytes: Buffer): Promise<T>;
+}

package/dist/mjs/utils/compressors/GzipCompressor.js

@@ -0,0 +1,15 @@
+import nodeGzip from 'node-gzip';
+import { Compression_TYPE } from '../../proto/Compression.js';
+const { gzip, ungzip } = nodeGzip;
+export class GzipCompressor {
+    static type = Compression_TYPE.GZIP;
+    compress(content) {
+        const stringified = JSON.stringify(content);
+        return gzip(stringified);
+    }
+    async decompress(bytes) {
+        const stringified = await ungzip(bytes);
+        return JSON.parse(stringified.toString());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3ppcENvbXByZXNzb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvY29tcHJlc3NvcnMvR3ppcENvbXByZXNzb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxRQUFRLE1BQU0sV0FBVyxDQUFDO0FBQ2pDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRzlELE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLEdBQUcsUUFBUSxDQUFDO0FBRWxDLE1BQU0sT0FBTyxjQUFjO0lBQ2xCLE1BQU0sQ0FBQyxJQUFJLEdBQUcsZ0JBQWdCLENBQUMsSUFBSSxDQUFDO0lBRXBDLFFBQVEsQ0FBQyxPQUFVO1FBQ3hCLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLENBQUM7UUFFNUMsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDM0IsQ0FBQztJQUVNLEtBQUssQ0FBQyxVQUFVLENBQUMsS0FBYTtRQUNuQyxNQUFNLFdBQVcsR0FBRyxNQUFNLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUV4QyxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDNUMsQ0FBQyJ9

package/dist/mjs/utils/compressors/UncompressedCompressor.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Compression_TYPE } from '../../proto/Compression.js';
+import { Compressor } from '../../types/Compressor.js';
+export declare class UncompressedCompressor<T = unknown> implements Compressor<T> {
+    static type: Compression_TYPE;
+    compress(content: T): Promise<Buffer>;
+    decompress(bytes: Buffer): Promise<T>;
+}

package/dist/mjs/utils/compressors/UncompressedCompressor.js

@@ -0,0 +1,13 @@
+import { Compression_TYPE } from '../../proto/Compression.js';
+export class UncompressedCompressor {
+    static type = Compression_TYPE.Uncompressed;
+    compress(content) {
+        const stringified = JSON.stringify(content);
+        return Promise.resolve(Buffer.from(stringified));
+    }
+    decompress(bytes) {
+        const stringified = bytes.toString();
+        return Promise.resolve(JSON.parse(stringified));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVW5jb21wcmVzc2VkQ29tcHJlc3Nvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlscy9jb21wcmVzc29ycy9VbmNvbXByZXNzZWRDb21wcmVzc29yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRzlELE1BQU0sT0FBTyxzQkFBc0I7SUFDMUIsTUFBTSxDQUFDLElBQUksR0FBRyxnQkFBZ0IsQ0FBQyxZQUFZLENBQUM7SUFFNUMsUUFBUSxDQUFDLE9BQVU7UUFDeEIsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUU1QyxPQUFPLE9BQU8sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDO0lBQ25ELENBQUM7SUFFTSxVQUFVLENBQUMsS0FBYTtRQUM3QixNQUFNLFdBQVcsR0FBRyxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUM7UUFFckMsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQztJQUNsRCxDQUFDIn0=

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

@@ -0,0 +1,2 @@
+export * from './GzipCompressor.js';
+export * from './UncompressedCompressor.js';

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

@@ -0,0 +1,3 @@
+export * from './GzipCompressor.js';
+export * from './UncompressedCompressor.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvY29tcHJlc3NvcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDZCQUE2QixDQUFDIn0=

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

@@ -0,0 +1,87 @@
+import { JsonRpcOptionalPayload, Provider, TransactionOptions } from '../types/Web3.js';
+import { SlotInfo } from '../types/SlotInfo.js';
+import { LoaderSecretAccessPublicKey, LoaderSession, OfferResource, OfferStorageAllocated, OfferStorageRequest, OptionInfo, OptionInfoRaw, OrderUsage, OrderUsageRaw, SecretRequest, SlotUsage, TeeOfferOption, TeeOfferOptionRaw, TeeOfferSlot, ValueOfferSlot, ValueOfferSlotRaw, ConsensusBenchmarkPriceMultipliers, OfferVersion, OfferVersionInfo, OfferVersionInfoRaw, OfferVersionRaw, TeeOfferInfo, TeeOfferInfoRaw, HardwareInfoRaw, HardwareInfo, OfferInfoRaw, OfferInfo, ValueOfferRestrictionsSpecification, OfferType, OfferGroup, Origins } from '../types/index.js';
+import { BenchmarkInfo } from '@super-protocol/dto-js';
+import { BatchResponse, BatchResponseSuccess, ExecuteBatchOptions } from './types.js';
+import { WssSubscriptionOnDataFn } from '../connectors/BlockchainEventsListener.js';
+import { TypedContractEvent, TypedEventLog } from '../contracts/typechain-types/common.js';
+/**
+ * Function for checking if provider action account initialized (required for set methods)
+ * Used in all set methods
+ */
+export declare const checkIfActionAccountInitialized: (transactionOptions?: TransactionOptions) => void;
+export declare const getBaseBlockFee: (provider: Provider) => Promise<bigint>;
+export declare const getMaxPriorityFeePerGas: (provider: Provider) => Promise<bigint>;
+export declare const multiplyBigIntByNumber: (big: bigint, num: number) => bigint;
+/**
+ * Get gas limit based on current network
+ */
+export declare const getGasLimitForNetwork: () => bigint;
+/**
+ * Merge transaction options from arguments and from store
+ * Used in all set methods
+ */
+export declare const createTransactionOptions: (externalTransactionSigner: boolean, options?: TransactionOptions) => Promise<TransactionOptions>;
+export declare const isNodeJS: () => boolean;
+export declare function incrementMethodCall(): (_target: unknown, propertyName: string, propertyDescriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function convertBigIntToString(obj: any): any;
+export declare function convertTeeOfferOptionFromRaw(option: TeeOfferOptionRaw): TeeOfferOption;
+export declare function convertLoaderSecretAccessPublicKeyFromRaw(loaderSecretAccessPublicKeyRaw: LoaderSecretAccessPublicKey): LoaderSecretAccessPublicKey;
+export declare function convertLoaderSessionFromRaw(loaderSessionRaw: LoaderSession): LoaderSession;
+export declare function convertOfferResourceFromRaw(offerResourceRaw: OfferResource): OfferResource;
+export declare function convertSecretRequestFromRaw(secretRequestRaw: SecretRequest): SecretRequest;
+export declare function convertOfferStorageAllocatedFromRaw(offerStorageAllocatedRaw: OfferStorageAllocated): OfferStorageAllocated;
+export declare function convertOfferStorageRequestFromRaw(offerStorageRequestRaw: OfferStorageRequest): OfferStorageRequest;
+export declare function convertOrigins(source: Origins): Origins;
+export declare function convertOfferVersionInfo(source: OfferVersionInfoRaw): OfferVersionInfo;
+export declare function convertOfferVersion(source: OfferVersionRaw): OfferVersion;
+export declare function convertHardwareInfo(source: HardwareInfoRaw, coresDenominator: number): HardwareInfo;
+export declare function convertTeeOfferInfo(params: {
+    offerInfoRaw: TeeOfferInfoRaw;
+    hardwareInfoRaw: HardwareInfoRaw;
+    coresDenominator: number;
+}): TeeOfferInfo;
+export declare function convertValueOfferInfo(params: {
+    offerInfoRaw: OfferInfoRaw;
+    offerType: OfferType;
+    offerGroup: OfferGroup;
+    restrictions: ValueOfferRestrictionsSpecification;
+}): OfferInfo;
+export declare function formatEpochIndexes(epochIndexes: string[]): number[];
+export declare function formatTeeOfferSlot(slot: TeeOfferSlot, coresDenominator: number): TeeOfferSlot;
+export declare function formatOfferSlot(slot: ValueOfferSlotRaw, coresDenominator: number): ValueOfferSlot;
+export declare function createBenchmarkInfo(mark: number, size: number): BenchmarkInfo;
+export declare function formatPriceMultipliers(priceMultipliers: ConsensusBenchmarkPriceMultipliers): ConsensusBenchmarkPriceMultipliers;
+export declare function formatUsage(usage: SlotUsage): SlotUsage;
+export declare function convertOrderUsage(usage: OrderUsageRaw, slotInfo: SlotInfo, slotUsage: SlotUsage): OrderUsage;
+export declare function convertOptionInfoFromRaw(optionInfo: OptionInfoRaw): OptionInfo;
+export declare function convertOptionInfoToRaw(optionInfoRaw: OptionInfo): OptionInfoRaw;
+export declare function unpackSlotInfo(slotInfo: SlotInfo, coresDenominator: number): SlotInfo;
+export declare function packSlotInfo(slotInfo: SlotInfo, coresDenominator: number): SlotInfo;
+export declare function isValidBytes32Hex(data: string): boolean;
+export declare const cleanWeb3Data: <T>(rawData: T) => any;
+export declare const transformComplexObject: (obj: any) => any;
+export declare function executeBatchAsync<T>(requests: JsonRpcOptionalPayload[], options: ExecuteBatchOptions & {
+    throwOnError: true;
+}): Promise<BatchResponseSuccess<T>[]>;
+export declare function executeBatchAsync<T>(requests: JsonRpcOptionalPayload[], options?: ExecuteBatchOptions): Promise<BatchResponse<T>[]>;
+export declare const preparePrivateKey: (pk: string) => string;
+export declare const isIpAddress: (host: string) => boolean;
+export declare const fromBlockchainHexOptional: (hex?: string) => Uint8Array | undefined;
+export declare const fromBlockchainHex: (hex: string) => Uint8Array;
+export declare const toBlockchainHex: (u?: Uint8Array) => string;
+export declare function makeOnData<TContract extends {
+    filters: Record<string, TypedContractEvent<any, any, any>>;
+}, TEventName extends keyof TContract['filters']>(_: TContract, __: TEventName, handler: (log: TypedEventLog<TContract['filters'][TEventName]>) => void): WssSubscriptionOnDataFn;
+export declare function withCleanArgs(callback: (...args: any[]) => void): (...args: any[]) => void;
+export type EventInputTuple<E> = E extends TypedContractEvent<infer I, any, any> ? I : never;
+export type EventOutputObject<E> = E extends TypedContractEvent<any, any, infer I> ? I : never;
+type FilterValue<T> = T | T[] | null;
+export type EventFilterTuple<T> = EventInputTuple<T> extends infer Tuple ? {
+    [K in keyof Tuple]?: FilterValue<Tuple[K]>;
+} : never;
+export type BigIntToString<T> = {
+    [K in keyof T]: T[K] extends bigint ? string : T[K] extends bigint | null | undefined ? string | Extract<T[K], null | undefined> : T[K] extends object ? BigIntToString<T[K]> : T[K];
+};
+export type StringifiedEventOutput<T> = T extends TypedContractEvent<any, any, infer OutputObject> ? BigIntToString<OutputObject> : never;
+export {};