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

package/dist/cjs/utils/TxManager.js

@@ -0,0 +1,285 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Web3TransactionRevertedByEvmError = void 0;
+const NonceTracker_js_1 = __importDefault(require("./NonceTracker.js"));
+const logger_js_1 = __importDefault(require("../logger.js"));
+const store_js_1 = __importDefault(require("../store.js"));
+const index_js_1 = require("../errors/index.js");
+const helper_js_1 = require("./helper.js");
+const constants_js_1 = require("../constants.js");
+const lodash_1 = __importDefault(require("lodash"));
+const bottleneck_1 = __importDefault(require("bottleneck"));
+const ethers_1 = require("ethers");
+class Web3TransactionError extends Error {
+    originalError;
+    constructor(originalError, message) {
+        super(message);
+        this.name = 'Web3TransactionError';
+        this.originalError = originalError;
+    }
+}
+class Web3TransactionRevertedByEvmError extends Web3TransactionError {
+    constructor(originalError, message) {
+        super(originalError, message);
+        this.name = 'Web3TransactionRevertedByEvmError';
+    }
+}
+exports.Web3TransactionRevertedByEvmError = Web3TransactionRevertedByEvmError;
+class TxManager {
+    static provider;
+    static externalTransactionSigner;
+    static logger = logger_js_1.default.child({ className: 'TxManager' });
+    static nonceTrackers = {};
+    static queues = {};
+    static init(provider, externalTransactionSigner = false) {
+        this.provider = provider;
+        this.externalTransactionSigner = externalTransactionSigner;
+    }
+    static checkIfInitialized() {
+        if (!this.provider) {
+            throw Error('TxManager should be initialized before using.');
+        }
+    }
+    static async initAccount(address) {
+        if (this.nonceTrackers[address])
+            return;
+        this.nonceTrackers[address] = new NonceTracker_js_1.default(this.provider, address);
+        await this.nonceTrackers[address].initAccount();
+    }
+    static execute(transaction, transactionOptions) {
+        return TxManager.publishTransaction(transaction, transactionOptions);
+    }
+    static async publishTransaction(transaction, transactionOptions) {
+        this.checkIfInitialized();
+        (0, helper_js_1.checkIfActionAccountInitialized)(transactionOptions);
+        const txOptions = await (0, helper_js_1.createTransactionOptions)(this.externalTransactionSigner, {
+            ...transactionOptions,
+        });
+        if (!txOptions.from) {
+            throw Error('From account is undefined. You should pass it to transactionOptions or init action account.');
+        }
+        const publishTxOptions = {
+            ...txOptions,
+            provider: transactionOptions?.provider || this.provider,
+        };
+        if (!this.queues[publishTxOptions.from]) {
+            this.queues[publishTxOptions.from] = new bottleneck_1.default({
+                maxConcurrent: store_js_1.default.txConcurrency,
+                minTime: store_js_1.default.txIntervalMs,
+            });
+        }
+        let transactionResultData;
+        if (this.externalTransactionSigner) {
+            transactionResultData = this.queues[publishTxOptions.from].schedule(() => TxManager._requestUnsignedTransaction(transaction, publishTxOptions));
+        }
+        else {
+            transactionResultData = this.queues[publishTxOptions.from].schedule(() => TxManager._publishTransaction(transaction, publishTxOptions));
+        }
+        return transactionResultData;
+    }
+    static async _requestUnsignedTransaction(txData, transactionOptions) {
+        const { from, provider } = transactionOptions;
+        const txDataForUnsignedTx = {
+            from: from,
+            to: txData.to,
+            data: txData.data,
+            value: txData.value,
+        };
+        TxManager.logger.debug({
+            txData: lodash_1.default.omit(txDataForUnsignedTx, ['data']),
+        }, 'Publishing unsigned transaction');
+        const txHash = await provider.send('eth_sendTransaction', [
+            txDataForUnsignedTx,
+        ]);
+        return (await provider.waitForTransaction(txHash));
+        // web3 could not intercept a successful transaction. Perhaps ethers can.
+        // If it can't, you can return our code below:
+        //return await TxManager._getReceiptByTxHash(txHash);
+    }
+    // private static async _getReceiptByTxHash(
+    //   txHash: string,
+    //   provider = this.provider,
+    // ): Promise<TransactionReceipt> {
+    //   return await tryWithInterval({
+    //     handler: async () => (await provider!.getTransactionReceipt(txHash))!,
+    //     checkResult: (txHash) => {
+    //       return { isResultOk: txHash !== null };
+    //     },
+    //     retryInterval: BLOCKCHAIN_CALL_RETRY_INTERVAL,
+    //     retryMax: BLOCKCHAIN_CALL_RETRY_ATTEMPTS,
+    //   });
+    // }
+    static async _contractCallHandling(contractCall) {
+        let result;
+        try {
+            result = await contractCall();
+            return result;
+        }
+        catch (error) {
+            if (error.cause !== undefined) {
+                throw error.cause;
+            }
+            if (error.innerError !== undefined) {
+                throw error.innerError;
+            }
+            throw error;
+        }
+    }
+    static _isGasRelatedError(error) {
+        const errorMessage = error.message?.toLowerCase() || '';
+        const gasErrorPatterns = [
+            // discovered by real transaction
+            'transaction underpriced',
+            // source: https://github.com/ethereum/go-ethereum/blob/master/core/txpool/errors.go
+            'transaction gas price below minimum',
+        ];
+        return gasErrorPatterns.some((pattern) => errorMessage.includes(pattern.toLowerCase()));
+    }
+    static _isNonceRelatedError(error) {
+        const errorMessage = error.message?.toLowerCase() || '';
+        const nonceErrorPatterns = [
+            'nonce too low',
+            'nonce too high',
+            'replacement transaction underpriced',
+        ];
+        return nonceErrorPatterns.some((pattern) => errorMessage.includes(pattern.toLowerCase()));
+    }
+    static async _signAndSendTransaction(txData, signingKey, provider, logContext = 'Publishing signed transaction') {
+        const wallet = new ethers_1.Wallet(signingKey, provider);
+        const populateTx = await wallet.populateTransaction(txData);
+        const signed = await wallet.signTransaction(populateTx);
+        const tx = ethers_1.Transaction.from(signed);
+        TxManager.logger.debug({
+            txHash: tx.hash,
+            txData: lodash_1.default.omit(txData, ['data']),
+        }, logContext);
+        const transactionResultData = await TxManager._contractCallHandling(async () => {
+            const tx = await provider.broadcastTransaction(signed);
+            return await tx.wait();
+            // web3 could not intercept a successful transaction. Perhaps ethers can.
+            // If it can't, you can return our code below:
+            // await TxManager._getReceiptByTxHash(tx.hash);
+        });
+        if (transactionResultData.hash !== tx.hash) {
+            throw new Error('Transaction hash mismatch');
+        }
+        TxManager.logger.debug({
+            txHash: tx.hash,
+            txBlockNumber: transactionResultData?.blockNumber,
+            txGasUsed: transactionResultData?.gasUsed,
+        }, `Transaction result: ${logContext}`);
+        return transactionResultData;
+    }
+    static async _publishTransaction(txData, transactionOptions) {
+        const { from, gasLimit, maxPriorityFeePerGas, maxFeePerGas, provider } = transactionOptions;
+        txData = {
+            ...txData,
+            from,
+            gasLimit,
+            maxPriorityFeePerGas,
+            maxFeePerGas,
+        };
+        if (transactionOptions.gasLimit) {
+            TxManager.logger.warn({
+                specifiedGas: transactionOptions.gasLimit,
+            }, 'Gas overriding');
+            txData.gasLimit = transactionOptions.gasLimit;
+        }
+        else {
+            const txDataForEstimate = {
+                ...txData,
+                gasLimit: undefined,
+            };
+            try {
+                const estimatedGas = await TxManager._contractCallHandling(() => provider.estimateGas(txDataForEstimate));
+                txData.gasLimit = (0, helper_js_1.multiplyBigIntByNumber)(estimatedGas, store_js_1.default.gasLimitMultiplier);
+            }
+            catch (e) {
+                const revertReason = e?.data?.message || e?.message || 'Unknown reason';
+                TxManager.logger.error({
+                    err: e,
+                    revertReason,
+                    // omit calldata to avoid huge logs/PII leakage
+                    txData: lodash_1.default.omit(txDataForEstimate, ['data']),
+                }, `Gas estimation failed${revertReason ? `: ${revertReason}` : ''}`);
+                throw e;
+            }
+        }
+        let nonceTracker;
+        if (this.nonceTrackers[transactionOptions.from]) {
+            nonceTracker = this.nonceTrackers[transactionOptions.from];
+            await nonceTracker.onTransactionStartPublishing();
+            txData.nonce = Number(nonceTracker.consumeNonce());
+        }
+        const signingKey = store_js_1.default.keys[transactionOptions.from];
+        try {
+            if (!signingKey) {
+                TxManager.logger.debug({
+                    txData: lodash_1.default.omit(txData, ['data']),
+                }, 'Publishing unsigned transaction');
+                const txHash = await provider.send('eth_sendTransaction', [txData]);
+                const transactionResultData = await provider.waitForTransaction(txHash);
+                if (nonceTracker && txData.nonce !== undefined) {
+                    nonceTracker.onTransactionPublished(BigInt(txData.nonce));
+                }
+                return transactionResultData;
+            }
+            const originalMaxPriorityFeePerGas = txData.maxPriorityFeePerGas;
+            const retries = transactionOptions.retries ?? constants_js_1.TRANSACTION_RETRY_ATTEMPTS;
+            if (retries <= 0) {
+                throw new Error('retries is less than 0');
+            }
+            if (store_js_1.default.chainId === constants_js_1.OPBNB_MAIN_CHAIN_ID || store_js_1.default.chainId === constants_js_1.OPBNB_TEST_CHAIN_ID) {
+                txData.maxPriorityFeePerGas = constants_js_1.OPBNB_MAX_PRIORITY_FEE_PER_GAS;
+            }
+            for (let attempt = 1; attempt <= retries; ++attempt) {
+                try {
+                    const transactionResultData = await this._signAndSendTransaction(txData, signingKey, provider, `Publishing signed transaction (attempt ${attempt})`);
+                    if (nonceTracker && txData.nonce !== undefined) {
+                        nonceTracker.onTransactionPublished(BigInt(txData.nonce));
+                    }
+                    return transactionResultData;
+                }
+                catch (e) {
+                    const error = e;
+                    TxManager.logger.warn({ err: error }, `Attempt ${attempt} failed.`);
+                    if (this._isNonceRelatedError(error) && nonceTracker) {
+                        TxManager.logger.warn('Nonce related error, updating nonce and retrying.');
+                        await nonceTracker.updateNonce();
+                        txData.nonce = Number(nonceTracker.consumeNonce());
+                        if (attempt !== retries)
+                            continue;
+                    }
+                    else if (this._isGasRelatedError(error)) {
+                        TxManager.logger.warn('Gas related error, retrying with original fees.');
+                        txData.maxPriorityFeePerGas = originalMaxPriorityFeePerGas;
+                        if (attempt !== retries)
+                            continue;
+                    }
+                    throw error;
+                }
+            }
+            throw new Error('All retries failed');
+        }
+        catch (e) {
+            const message = 'Error during transaction execution';
+            TxManager.logger.error(e, message);
+            if (nonceTracker)
+                await nonceTracker.onTransactionError();
+            if (e.message?.includes('Transaction has been reverted by the EVM')) {
+                throw new Web3TransactionRevertedByEvmError(e, message);
+            }
+            else if (index_js_1.InsufficientFundsError.isInsufficientFundsError(e)) {
+                throw new index_js_1.InsufficientFundsError(e, message);
+            }
+            else {
+                throw new Web3TransactionError(e, message);
+            }
+        }
+    }
+}
+exports.default = TxManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TxManager.js","sourceRoot":"","sources":["../../../src/utils/TxManager.ts"],"names":[],"mappings":"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"}

package/dist/cjs/utils/cache/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export { createMemoryCache } from './memory.js';

package/dist/cjs/utils/cache/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoryCache = void 0;
+__exportStar(require("./types.js"), exports);
+var memory_js_1 = require("./memory.js");
+Object.defineProperty(exports, "createMemoryCache", { enumerable: true, get: function () { return memory_js_1.createMemoryCache; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvY2FjaGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSw2Q0FBMkI7QUFFM0IseUNBQWdEO0FBQXZDLDhHQUFBLGlCQUFpQixPQUFBIn0=

package/dist/cjs/utils/cache/memory.d.ts

@@ -0,0 +1,19 @@
+import { ICache, MemoryCacheOptions } from './types.js';
+export declare class MemoryCache implements ICache {
+    protected readonly prefix?: string;
+    protected readonly cache: Map<string, {
+        v: unknown | null;
+        ttl?: number;
+    }>;
+    constructor(options?: MemoryCacheOptions);
+    add(key: string, value: unknown | null, ttl?: number): boolean;
+    del(...keys: string[]): boolean;
+    get(key: string): unknown | null | undefined;
+    set(key: string, value: unknown | null, ttl?: number): void;
+    wrap<T>(key: string, fn: () => Promise<T>, options?: {
+        ttl?: number;
+        force?: boolean;
+    }): Promise<T>;
+    protected getPrefixedKey(key: string): string;
+}
+export declare const createMemoryCache: (options?: Partial<MemoryCacheOptions>) => ICache;

package/dist/cjs/utils/cache/memory.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoryCache = exports.MemoryCache = void 0;
+class MemoryCache {
+    prefix;
+    cache;
+    constructor(options = {}) {
+        this.prefix = options.prefix;
+        this.cache = options.initCache ?? new Map();
+    }
+    add(key, value, ttl) {
+        if (value !== undefined && !this.cache.has(this.getPrefixedKey(key))) {
+            const ttlMs = ttl ? ttl * 1000 : undefined;
+            this.cache.set(this.getPrefixedKey(key), {
+                v: value,
+                ...(ttlMs && { ttl: Date.now() + ttlMs }),
+            });
+            return true;
+        }
+        return false;
+    }
+    del(...keys) {
+        keys.forEach((k) => this.cache.delete(this.getPrefixedKey(k)));
+        return true;
+    }
+    get(key) {
+        const data = this.cache.get(this.getPrefixedKey(key));
+        if (data) {
+            if (!data.ttl || data.ttl >= Date.now()) {
+                return data.v;
+            }
+            this.del(this.getPrefixedKey(key));
+        }
+        return;
+    }
+    set(key, value, ttl) {
+        if (value !== undefined) {
+            const ttlMs = ttl ? ttl * 1000 : undefined;
+            this.cache.set(this.getPrefixedKey(key), {
+                v: value,
+                ...(ttlMs && { ttl: Date.now() + ttlMs }),
+            });
+        }
+    }
+    async wrap(key, fn, options) {
+        const { ttl, force = false } = options ?? {};
+        let val = force ? undefined : this.get(key);
+        if (val === undefined) {
+            val = await fn();
+            this.set(key, val, ttl);
+        }
+        return val;
+    }
+    getPrefixedKey(key) {
+        return this.prefix ? `${this.prefix}-${key}` : key;
+    }
+}
+exports.MemoryCache = MemoryCache;
+const createMemoryCache = (options = {}) => {
+    return new MemoryCache({
+        prefix: options.prefix ?? 'sp',
+        initCache: options.initCache,
+    });
+};
+exports.createMemoryCache = createMemoryCache;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/utils/cache/memory.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const memory_js_1 = require("./memory.js");
+describe('MemoryCache', () => {
+    let cache;
+    beforeEach(() => {
+        cache = new memory_js_1.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/cjs/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/cjs/utils/cache/types.js

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

package/dist/cjs/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/cjs/utils/compressors/GzipCompressor.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GzipCompressor = void 0;
+const node_gzip_1 = __importDefault(require("node-gzip"));
+const Compression_js_1 = require("../../proto/Compression.js");
+const { gzip, ungzip } = node_gzip_1.default;
+class GzipCompressor {
+    static type = Compression_js_1.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());
+    }
+}
+exports.GzipCompressor = GzipCompressor;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3ppcENvbXByZXNzb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvY29tcHJlc3NvcnMvR3ppcENvbXByZXNzb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEsMERBQWlDO0FBQ2pDLCtEQUE4RDtBQUc5RCxNQUFNLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxHQUFHLG1CQUFRLENBQUM7QUFFbEMsTUFBYSxjQUFjO0lBQ2xCLE1BQU0sQ0FBQyxJQUFJLEdBQUcsaUNBQWdCLENBQUMsSUFBSSxDQUFDO0lBRXBDLFFBQVEsQ0FBQyxPQUFVO1FBQ3hCLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLENBQUM7UUFFNUMsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDM0IsQ0FBQztJQUVNLEtBQUssQ0FBQyxVQUFVLENBQUMsS0FBYTtRQUNuQyxNQUFNLFdBQVcsR0FBRyxNQUFNLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUV4QyxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDNUMsQ0FBQzs7QUFiSCx3Q0FjQyJ9

package/dist/cjs/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/cjs/utils/compressors/UncompressedCompressor.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UncompressedCompressor = void 0;
+const Compression_js_1 = require("../../proto/Compression.js");
+class UncompressedCompressor {
+    static type = Compression_js_1.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));
+    }
+}
+exports.UncompressedCompressor = UncompressedCompressor;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVW5jb21wcmVzc2VkQ29tcHJlc3Nvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlscy9jb21wcmVzc29ycy9VbmNvbXByZXNzZWRDb21wcmVzc29yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLCtEQUE4RDtBQUc5RCxNQUFhLHNCQUFzQjtJQUMxQixNQUFNLENBQUMsSUFBSSxHQUFHLGlDQUFnQixDQUFDLFlBQVksQ0FBQztJQUU1QyxRQUFRLENBQUMsT0FBVTtRQUN4QixNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBRTVDLE9BQU8sT0FBTyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUM7SUFDbkQsQ0FBQztJQUVNLFVBQVUsQ0FBQyxLQUFhO1FBQzdCLE1BQU0sV0FBVyxHQUFHLEtBQUssQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUVyQyxPQUFPLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDO0lBQ2xELENBQUM7O0FBYkgsd0RBY0MifQ==

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./GzipCompressor.js"), exports);
+__exportStar(require("./UncompressedCompressor.js"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvY29tcHJlc3NvcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHNEQUFvQztBQUNwQyw4REFBNEMifQ==