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

package/dist/mjs/utils/Monitoring.js

@@ -0,0 +1,44 @@
+import rootLogger from '../logger.js';
+export class Monitoring {
+    static instance;
+    logger = rootLogger.child({ className: 'Monitoring' });
+    contractMethodCalls = new Map();
+    interval;
+    constructor() {
+        // Singleton
+    }
+    static getInstance() {
+        if (!Monitoring.instance) {
+            Monitoring.instance = new Monitoring();
+        }
+        return Monitoring.instance;
+    }
+    initializeLogging() {
+        const checkInterval = process.env.PRINT_CONTRACT_CALLS_INTERVAL || 300000;
+        this.shutdownLogging();
+        const startTs = Date.now();
+        this.interval = setInterval(() => {
+            this.contractMethodCalls.forEach((value, key) => this.logger.debug({
+                methodName: key,
+                calledTimes: value,
+            }));
+            const totalCalls = Array.from(this.contractMethodCalls.values()).reduce((acc, curr) => acc + curr, 0);
+            const timeSpend = Math.floor((Date.now() - startTs) / (60 * 1000));
+            this.logger.debug({
+                timeSpend: timeSpend + ' min',
+                totalCalls,
+            }, 'Contract methods calls');
+        }, +checkInterval);
+    }
+    shutdownLogging() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+    }
+    incrementCall(methodName) {
+        const prevValue = this.contractMethodCalls.get(methodName) || 0;
+        this.contractMethodCalls.set(methodName, prevValue + 1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,20 @@
+import { Provider } from 'ethers';
+declare class NonceTracker {
+    private provider;
+    private address;
+    private logger;
+    private txCount?;
+    private transactionsOnHold;
+    private countOfPendingTransactions;
+    constructor(provider: Provider, address: string);
+    initAccount(): Promise<void>;
+    updateNonce(): Promise<void>;
+    getNonce(): bigint;
+    consumeNonce(): bigint;
+    onTransactionStartPublishing(): Promise<void>;
+    onTransactionPublished(nonce: bigint): void;
+    onTransactionError(): Promise<void>;
+    private waitForPendingTransactions;
+    private sendHoldTransactions;
+}
+export default NonceTracker;

package/dist/mjs/utils/NonceTracker.js

@@ -0,0 +1,77 @@
+import rootLogger from '../logger.js';
+class NonceTracker {
+    provider;
+    address;
+    logger;
+    txCount;
+    transactionsOnHold;
+    countOfPendingTransactions = 0;
+    constructor(provider, address) {
+        this.provider = provider;
+        this.address = address;
+        this.logger = rootLogger.child({ className: 'NonceTracker', address });
+        this.logger.trace('Created NonceTracker');
+    }
+    async initAccount() {
+        await this.updateNonce();
+        this.logger.trace(`Initialized ${this.address} account with nonce: ${this.txCount}`);
+    }
+    async updateNonce() {
+        this.txCount = BigInt(await this.provider.getTransactionCount(this.address));
+        this.logger.trace(`Updated nonce: ${this.txCount}`);
+    }
+    getNonce() {
+        if (this.txCount === undefined)
+            throw Error(`NonceTracker for address ${this.address} is not initialized`);
+        this.logger.trace(`Get nonce: ${this.txCount}`);
+        return this.txCount;
+    }
+    consumeNonce() {
+        if (this.txCount === undefined)
+            throw Error(`NonceTracker for address ${this.address} is not initialized`);
+        this.logger.trace(`Consume nonce: ${this.txCount}. Next nonce: ${this.txCount + BigInt(1)}`);
+        return this.txCount++;
+    }
+    async onTransactionStartPublishing() {
+        if (this.transactionsOnHold) {
+            await this.waitForPendingTransactions();
+        }
+        this.countOfPendingTransactions++;
+    }
+    onTransactionPublished(nonce) {
+        this.countOfPendingTransactions--;
+        if (this.countOfPendingTransactions === 0) {
+            this.logger.trace(`last tx published with nonce: ${nonce}. State nonce ${this.txCount}`);
+            void this.sendHoldTransactions();
+        }
+    }
+    async onTransactionError() {
+        this.countOfPendingTransactions--;
+        if (!this.transactionsOnHold)
+            this.transactionsOnHold = [];
+        if (this.countOfPendingTransactions === 0) {
+            await this.sendHoldTransactions();
+        }
+        else {
+            await this.waitForPendingTransactions();
+        }
+    }
+    waitForPendingTransactions() {
+        return new Promise((resolve) => {
+            if (!this.transactionsOnHold)
+                return resolve();
+            this.transactionsOnHold.push(() => {
+                resolve();
+            });
+        });
+    }
+    async sendHoldTransactions() {
+        if (!this.transactionsOnHold)
+            return;
+        await this.initAccount();
+        this.transactionsOnHold.forEach((callback) => callback());
+        this.transactionsOnHold = undefined;
+    }
+}
+export default NonceTracker;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,9 @@
+type Listener<Message> = (message: Message) => void;
+export default class PubSub<Event, Message> {
+    private subscriptions;
+    subscribe(event: Event, listener: Listener<Message>): () => void;
+    unsubscribe(event: Event, listener: Listener<Message>): void;
+    publish(event: Event, message: Message): void;
+    clear(event?: Event): void;
+}
+export {};

package/dist/mjs/utils/PubSub.js

@@ -0,0 +1,32 @@
+export default class PubSub {
+    subscriptions = new Map();
+    subscribe(event, listener) {
+        this.subscriptions.set(event, (this.subscriptions.get(event) || []).concat(listener));
+        return () => {
+            this.unsubscribe(event, listener);
+        };
+    }
+    unsubscribe(event, listener) {
+        const eventListeners = this.subscriptions.get(event);
+        if (eventListeners) {
+            this.subscriptions.set(event, eventListeners.filter((l) => l !== listener));
+        }
+    }
+    publish(event, message) {
+        const eventListeners = this.subscriptions.get(event);
+        if (eventListeners) {
+            eventListeners.forEach((listener) => {
+                listener(message);
+            });
+        }
+    }
+    clear(event) {
+        if (event) {
+            this.subscriptions.delete(event);
+        }
+        else {
+            this.subscriptions.clear();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUHViU3ViLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxzL1B1YlN1Yi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQUMsT0FBTyxPQUFPLE1BQU07SUFDakIsYUFBYSxHQUFvQyxJQUFJLEdBQUcsRUFBRSxDQUFDO0lBRW5FLFNBQVMsQ0FBQyxLQUFZLEVBQUUsUUFBMkI7UUFDakQsSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFFLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7UUFFdEYsT0FBTyxHQUFHLEVBQUU7WUFDVixJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssRUFBRSxRQUFRLENBQUMsQ0FBQztRQUNwQyxDQUFDLENBQUM7SUFDSixDQUFDO0lBRUQsV0FBVyxDQUFDLEtBQVksRUFBRSxRQUEyQjtRQUNuRCxNQUFNLGNBQWMsR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNyRCxJQUFJLGNBQWMsRUFBRSxDQUFDO1lBQ25CLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUNwQixLQUFLLEVBQ0wsY0FBYyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxLQUFLLFFBQVEsQ0FBQyxDQUM3QyxDQUFDO1FBQ0osQ0FBQztJQUNILENBQUM7SUFFRCxPQUFPLENBQUMsS0FBWSxFQUFFLE9BQWdCO1FBQ3BDLE1BQU0sY0FBYyxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3JELElBQUksY0FBYyxFQUFFLENBQUM7WUFDbkIsY0FBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFO2dCQUNsQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDcEIsQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDO0lBQ0gsQ0FBQztJQUVELEtBQUssQ0FBQyxLQUFhO1FBQ2pCLElBQUksS0FBSyxFQUFFLENBQUM7WUFDVixJQUFJLENBQUMsYUFBYSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNuQyxDQUFDO2FBQU0sQ0FBQztZQUNOLElBQUksQ0FBQyxhQUFhLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDN0IsQ0FBQztJQUNILENBQUM7Q0FDRiJ9

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

@@ -0,0 +1,28 @@
+import { TransactionOptions, Provider } from '../types/index.js';
+import { TransactionReceipt, ContractTransaction } from 'ethers';
+declare class Web3TransactionError extends Error {
+    readonly originalError: unknown;
+    constructor(originalError: unknown, message: string);
+}
+export declare class Web3TransactionRevertedByEvmError extends Web3TransactionError {
+    constructor(originalError: unknown, message: string);
+}
+declare class TxManager {
+    private static provider;
+    private static externalTransactionSigner;
+    private static logger;
+    private static nonceTrackers;
+    private static queues;
+    static init(provider: Provider, externalTransactionSigner?: boolean): void;
+    private static checkIfInitialized;
+    static initAccount(address: string): Promise<void>;
+    static execute(transaction: ContractTransaction, transactionOptions?: TransactionOptions): Promise<TransactionReceipt>;
+    static publishTransaction(transaction: ContractTransaction, transactionOptions?: TransactionOptions): Promise<TransactionReceipt>;
+    private static _requestUnsignedTransaction;
+    private static _contractCallHandling;
+    private static _isGasRelatedError;
+    private static _isNonceRelatedError;
+    private static _signAndSendTransaction;
+    private static _publishTransaction;
+}
+export default TxManager;

package/dist/mjs/utils/TxManager.js

@@ -0,0 +1,278 @@
+import NonceTracker from './NonceTracker.js';
+import rootLogger from '../logger.js';
+import store from '../store.js';
+import { InsufficientFundsError } from '../errors/index.js';
+import { checkIfActionAccountInitialized, createTransactionOptions, multiplyBigIntByNumber, } from './helper.js';
+import { OPBNB_MAIN_CHAIN_ID, OPBNB_MAX_PRIORITY_FEE_PER_GAS, OPBNB_TEST_CHAIN_ID, TRANSACTION_RETRY_ATTEMPTS, } from '../constants.js';
+import lodash from 'lodash';
+import Bottleneck from 'bottleneck';
+import { Transaction, Wallet, } from 'ethers';
+class Web3TransactionError extends Error {
+    originalError;
+    constructor(originalError, message) {
+        super(message);
+        this.name = 'Web3TransactionError';
+        this.originalError = originalError;
+    }
+}
+export class Web3TransactionRevertedByEvmError extends Web3TransactionError {
+    constructor(originalError, message) {
+        super(originalError, message);
+        this.name = 'Web3TransactionRevertedByEvmError';
+    }
+}
+class TxManager {
+    static provider;
+    static externalTransactionSigner;
+    static logger = rootLogger.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(this.provider, address);
+        await this.nonceTrackers[address].initAccount();
+    }
+    static execute(transaction, transactionOptions) {
+        return TxManager.publishTransaction(transaction, transactionOptions);
+    }
+    static async publishTransaction(transaction, transactionOptions) {
+        this.checkIfInitialized();
+        checkIfActionAccountInitialized(transactionOptions);
+        const txOptions = await 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({
+                maxConcurrent: store.txConcurrency,
+                minTime: store.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.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 Wallet(signingKey, provider);
+        const populateTx = await wallet.populateTransaction(txData);
+        const signed = await wallet.signTransaction(populateTx);
+        const tx = Transaction.from(signed);
+        TxManager.logger.debug({
+            txHash: tx.hash,
+            txData: lodash.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 = multiplyBigIntByNumber(estimatedGas, store.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.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.keys[transactionOptions.from];
+        try {
+            if (!signingKey) {
+                TxManager.logger.debug({
+                    txData: lodash.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 ?? TRANSACTION_RETRY_ATTEMPTS;
+            if (retries <= 0) {
+                throw new Error('retries is less than 0');
+            }
+            if (store.chainId === OPBNB_MAIN_CHAIN_ID || store.chainId === OPBNB_TEST_CHAIN_ID) {
+                txData.maxPriorityFeePerGas = 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 (InsufficientFundsError.isInsufficientFundsError(e)) {
+                throw new InsufficientFundsError(e, message);
+            }
+            else {
+                throw new Web3TransactionError(e, message);
+            }
+        }
+    }
+}
+export 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/mjs/utils/cache/index.d.ts

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

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

@@ -0,0 +1,3 @@
+export * from './types.js';
+export { createMemoryCache } from './memory.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvY2FjaGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFZLENBQUM7QUFFM0IsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sYUFBYSxDQUFDIn0=

package/dist/mjs/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/mjs/utils/cache/memory.js

@@ -0,0 +1,61 @@
+export 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;
+    }
+}
+export const createMemoryCache = (options = {}) => {
+    return new MemoryCache({
+        prefix: options.prefix ?? 'sp',
+        initCache: options.initCache,
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

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

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