@strkfarm/sdk 1.0.6

package/src/interfaces/lending.ts

@@ -0,0 +1,75 @@
+import { IConfig } from "@/interfaces/common";
+import { TokenInfo } from "./common";
+import { ContractAddr } from "@/dataTypes/address";
+import { loggers } from "winston";
+import { logger } from "@/global";
+import { log } from "console";
+import { Web3Number } from "@/dataTypes/bignumber";
+
+export interface ILendingMetadata {
+    name: string;
+    logo: string;
+}
+
+export enum MarginType {
+    SHARED = "shared",
+    NONE = "none",
+}
+
+export interface ILendingPosition {
+    tokenName: string;
+    tokenSymbol: string;
+    marginType: MarginType,
+    debtAmount: Web3Number;
+    debtUSD: Web3Number;
+    supplyAmount: Web3Number;
+    supplyUSD: Web3Number;
+}
+
+export interface LendingToken extends TokenInfo {
+    borrowFactor: Web3Number;
+    collareralFactor: Web3Number;
+}
+
+export abstract class ILending {
+    readonly config: IConfig;
+    readonly metadata: ILendingMetadata;
+    readonly tokens: LendingToken[] = [];
+
+    protected initialised: boolean = false;
+    constructor(config:IConfig, metadata: ILendingMetadata) {
+        this.metadata = metadata;
+        this.config = config;
+        this.init();
+    }
+
+    /** Async function to init the class */
+    abstract init(): Promise<void>;
+
+    /** Wait for initialisation */
+    waitForInitilisation() {
+        return new Promise<void>((resolve, reject) => {
+            const interval = setInterval(() => {
+                logger.verbose(`Waiting for ${this.metadata.name} to initialise`);
+                if (this.initialised) {
+                    logger.verbose(`${this.metadata.name} initialised`);
+                    clearInterval(interval);
+                    resolve();
+                }
+            }, 1000);
+        });
+    }
+
+    /**
+     * 
+     * @param lending_tokens Array of tokens to consider for compute collateral value
+     * @param debt_tokens Array of tokens to consider to compute debt values
+     * @param user 
+     */
+    abstract get_health_factor_tokenwise(lending_tokens: TokenInfo[], debt_tokens: TokenInfo[], user: ContractAddr): Promise<number>;
+    abstract get_health_factor(user: ContractAddr): Promise<number>;
+    abstract getPositionsSummary(user: ContractAddr): Promise<{
+        collateralUSD: number,
+        debtUSD: number,
+    }>
+}

package/src/modules/index.ts

@@ -0,0 +1,3 @@
+export * from './pricer';
+export * from './pragma';
+export * from './zkLend';

package/src/modules/pragma.ts

@@ -0,0 +1,22 @@
+import { Contract, RpcProvider } from "starknet";
+import PragmaAbi from '@/data/pragma.abi.json';
+import { logger } from "@/global";
+
+export class Pragma {
+    contractAddr = '0x023fb3afbff2c0e3399f896dcf7400acf1a161941cfb386e34a123f228c62832';
+    readonly contract: Contract;
+
+    constructor(provider: RpcProvider) {
+        this.contract = new Contract(PragmaAbi, this.contractAddr, provider);
+    }
+
+    async getPrice(tokenAddr: string) {
+        if (!tokenAddr) {
+            throw new Error(`Pragma:getPrice - no token`)
+        }
+        const result: any = await this.contract.call('get_price', [tokenAddr]);
+        const price = Number(result.price) / 10**8;
+        logger.verbose(`Pragma:${tokenAddr}: ${price}`);
+        return price;
+    }
+}

package/src/modules/pricer.ts

@@ -0,0 +1,125 @@
+import axios from "axios";
+import { FatalError, Global, logger } from "@/global";
+import { TokenInfo } from "@/interfaces/common";
+import { IConfig } from "@/interfaces/common";
+
+export interface PriceInfo {
+    price: number,
+    timestamp: Date
+}
+export class Pricer {
+    readonly config: IConfig;
+    readonly tokens: TokenInfo[] = [];
+    protected prices: {
+        [key: string]: PriceInfo
+    } = {}
+
+    /**
+     * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB
+     */
+    protected PRICE_API = `https://api.coinbase.com/v2/prices/{{PRICER_KEY}}/buy`;
+    constructor(config: IConfig, tokens: TokenInfo[]) {
+        this.config = config;
+        this.tokens = tokens;
+    }
+
+    isReady() {
+        const allPricesExist = Object.keys(this.prices).length === this.tokens.length;
+        if (!allPricesExist) return false;
+
+        let atleastOneStale = false;
+        for (let token of this.tokens) {
+            const priceInfo = this.prices[token.symbol];
+            const isStale = this.isStale(priceInfo.timestamp, token.symbol);
+            if (isStale) {
+                atleastOneStale = true;
+                logger.warn(`Atleast one stale: ${token.symbol}: ${JSON.stringify(this.prices[token.symbol])}`);
+                break;
+            }
+        }
+        return allPricesExist && !atleastOneStale;
+    }
+
+    waitTillReady() {
+        return new Promise<void>((resolve, reject) => {
+            const interval = setInterval(() => {
+                logger.verbose(`Waiting for pricer to initialise`);
+                if (this.isReady()) {
+                    logger.verbose(`Pricer initialised`);
+                    clearInterval(interval);
+                    resolve();
+                }
+            }, 1000);
+        });
+    }
+
+    start() {
+        this._loadPrices();
+        setInterval(() => {
+            this._loadPrices();
+        }, 30000);
+    }
+
+    isStale(timestamp: Date, tokenName: string) {
+        const STALE_TIME = 60000;
+        return (new Date().getTime() - timestamp.getTime()) > STALE_TIME;
+    }
+
+    assertNotStale(timestamp: Date, tokenName: string) {
+        Global.assert(!this.isStale(timestamp, tokenName), `Price of ${tokenName} is stale`);
+
+    }
+    async getPrice(tokenName: string) {
+        Global.assert(this.prices[tokenName], `Price of ${tokenName} not found`);
+       this.assertNotStale(this.prices[tokenName].timestamp, tokenName);
+        return this.prices[tokenName];
+    }
+
+    protected _loadPrices(onUpdate: (tokenSymbol: string) => void = () => {}) {
+        this.tokens.forEach(async (token) => {
+            const MAX_RETRIES = 10;
+            let retry = 0;
+            while (retry < MAX_RETRIES) {
+                try {
+                    if (token.symbol === 'USDT') {
+                        this.prices[token.symbol] = {
+                            price: 1,
+                            timestamp: new Date()
+                        }
+                        onUpdate(token.symbol);
+                        return;
+                    }
+                    if (!token.pricerKey) {
+                        throw new FatalError(`Pricer key not found for ${token.name}`);
+                    }
+                    const url = this.PRICE_API.replace("{{PRICER_KEY}}", token.pricerKey);
+                    const result = await axios.get(url);
+                    const data: any = result.data;
+                    const price = Number(data.data.amount);
+                    this.prices[token.symbol] = {
+                        price,
+                        timestamp: new Date()
+                    }
+                    onUpdate(token.symbol);
+                    logger.verbose(`Fetched price of ${token.name} as ${price}`);
+                    break;
+                } catch (error: any) {
+                    if (retry < MAX_RETRIES) {
+                        logger.warn(`Error fetching data from ${token.name}, retry: ${retry}`);
+                        logger.warn(error);
+                        retry++;
+                        await new Promise((resolve) => setTimeout(resolve, retry * 2000));
+                    } else {
+                        throw new FatalError(`Error fetching data from ${token.name}`, error);
+                    }
+                }
+            }
+        })
+        if (this.isReady() && this.config.heartbeatUrl) {
+            console.log(`sending beat`)
+            axios.get(this.config.heartbeatUrl).catch(err => {
+                console.error('Pricer: Heartbeat err', err);
+            })
+        }
+    }
+}

package/src/modules/zkLend.ts

@@ -0,0 +1,162 @@
+import axios from "axios";
+import BigNumber from "bignumber.js";
+import { Web3Number } from "@/dataTypes/bignumber";
+import { FatalError, Global, logger } from "@/global";
+import { TokenInfo } from "@/interfaces";
+import { ILending, ILendingPosition, LendingToken, MarginType } from "@/interfaces/lending";
+import { ContractAddr } from "@/dataTypes/address";
+import { IConfig } from "@/interfaces";
+import { Pricer } from "./pricer";
+
+export class ZkLend extends ILending implements ILending {
+    readonly pricer: Pricer;
+    static readonly POOLS_URL = 'https://app.zklend.com/api/pools';
+    private POSITION_URL = 'https://app.zklend.com/api/users/{{USER_ADDR}}/all';
+
+    constructor(config: IConfig, pricer: Pricer) {
+        super(config, { 
+            name: "zkLend",
+            logo: 'https://app.zklend.com/favicon.ico'
+        });
+        this.pricer = pricer;
+    }
+
+    async init() {
+        try {
+            logger.verbose(`Initialising ${this.metadata.name}`);
+            const result = await axios.get(ZkLend.POOLS_URL);
+            const data: any[] = result.data;
+            const savedTokens = await Global.getTokens()
+            data.forEach((pool) => {
+                let collareralFactor = new Web3Number(0, 0);
+                if (pool.collateral_factor) {
+                    collareralFactor = Web3Number.fromWei(pool.collateral_factor.value, pool.collateral_factor.decimals);
+                }
+                const savedTokenInfo = savedTokens.find(t => t.symbol == pool.token.symbol);
+                const token: LendingToken = {
+                    name: pool.token.name,
+                    symbol: pool.token.symbol,
+                    address: savedTokenInfo?.address || '',
+                    decimals: pool.token.decimals,
+                    borrowFactor: Web3Number.fromWei(pool.borrow_factor.value, pool.borrow_factor.decimals),
+                    collareralFactor
+                }
+                this.tokens.push(token);
+            });
+            logger.info(`Initialised ${this.metadata.name} with ${this.tokens.length} tokens`);
+            this.initialised = true;
+        } catch (error: any) {
+            return Global.httpError(ZkLend.POOLS_URL, error);
+        }
+    }
+
+    /**
+     * @description Get the health factor of the user for given lending and debt tokens
+     * @param lending_tokens 
+     * @param debt_tokens 
+     * @param user 
+     * @returns hf (e.g. returns 1.5 for 150% health factor)
+     */
+    async get_health_factor_tokenwise(lending_tokens: TokenInfo[], debt_tokens: TokenInfo[], user: ContractAddr): Promise<number> {
+        const positions = await this.getPositions(user);
+        logger.verbose(`${this.metadata.name}:: Positions: ${JSON.stringify(positions)}`);
+        
+        // Computes Sum of debt USD / borrow factor
+        let effectiveDebt = new Web3Number(0, 6);
+        positions.filter((pos) => {
+            return debt_tokens.find((t) => t.symbol === pos.tokenSymbol);
+        }).forEach((pos) => {
+            const token = this.tokens.find((t) => t.symbol === pos.tokenSymbol);
+            if (!token) {
+                throw new FatalError(`Token ${pos.tokenName} not found in ${this.metadata.name}`);
+            }
+            effectiveDebt = effectiveDebt.plus(pos.debtUSD.dividedBy(token.borrowFactor.toFixed(6)).toString());
+        });
+        logger.verbose(`${this.metadata.name}:: Effective debt: ${effectiveDebt}`);
+        if (effectiveDebt.isZero()) {
+            return Infinity;
+        }
+
+        // Computs Sum of collateral USD * collateral factor
+        let effectiveCollateral = new Web3Number(0, 6);
+        positions.filter(pos => {
+            const exp1 = lending_tokens.find((t) => t.symbol === pos.tokenSymbol);
+            const exp2 = pos.marginType === MarginType.SHARED;
+            return exp1 && exp2;
+        }).forEach((pos) => {
+            const token = this.tokens.find((t) => t.symbol === pos.tokenSymbol);
+            if (!token) {
+                throw new FatalError(`Token ${pos.tokenName} not found in ${this.metadata.name}`);
+            }
+            logger.verbose(`${this.metadata.name}:: Token: ${pos.tokenName}, Collateral factor: ${token.collareralFactor.toFixed(6)}`);
+            effectiveCollateral = effectiveCollateral.plus(pos.supplyUSD.multipliedBy(token.collareralFactor.toFixed(6)).toString());
+        });
+        logger.verbose(`${this.metadata.name}:: Effective collateral: ${effectiveCollateral}`);
+
+        // Health factor = Effective collateral / Effective debt
+        const healthFactor = effectiveCollateral.dividedBy(effectiveDebt.toFixed(6)).toNumber();
+        logger.verbose(`${this.metadata.name}:: Health factor: ${healthFactor}`);
+        return healthFactor;
+    }
+
+    /**
+     * @description Get the health factor of the user
+     * - Considers all tokens for collateral and debt
+     */
+    async get_health_factor(user: ContractAddr): Promise<number> {
+        return this.get_health_factor_tokenwise(this.tokens, this.tokens, user);
+    }
+
+    async getPositionsSummary(user: ContractAddr): Promise<{
+        collateralUSD: number,
+        debtUSD: number,
+    }> {
+        const pos = await this.getPositions(user);
+        const collateralUSD = pos.reduce((acc, p) => acc + p.supplyUSD.toNumber(), 0);
+        const debtUSD = pos.reduce((acc, p) => acc + p.debtUSD.toNumber(), 0);
+        return {
+            collateralUSD,
+            debtUSD
+        }
+    }
+    /**
+     * @description Get the token-wise collateral and debt positions of the user 
+     * @param user Contract address of the user
+     * @returns Promise<ILendingPosition[]>
+     */
+    async getPositions(user: ContractAddr): Promise<ILendingPosition[]> {
+        const url = this.POSITION_URL.replace('{{USER_ADDR}}', user.address);
+        /**
+         * Sample response:
+            {"pools":[{"data":{"debt_amount":"0x0","is_collateral":false,"supply_amount":"0x0","wallet_balance":"0x0"},
+            "token_symbol":"ETH"},{"data":{"debt_amount":"0x0","is_collateral":false,"supply_amount":"0x0",
+            "wallet_balance":"0x0"},"token_symbol":"USDC"}]}
+        */
+        const result = await axios.get(url);
+        const data: any = result.data;
+        const lendingPosition: ILendingPosition[] = [];
+        logger.verbose(`${this.metadata.name}:: Positions: ${JSON.stringify(data)}`);
+        for(let i=0; i<data.pools.length; i++) {
+            const pool = data.pools[i];
+            const token = this.tokens.find((t) => {
+                return t.symbol === pool.token_symbol
+            });
+            if (!token) {
+                throw new FatalError(`Token ${pool.token_symbol} not found in ${this.metadata.name}`);
+            }
+            const debtAmount = Web3Number.fromWei(pool.data.debt_amount, token.decimals);
+            const supplyAmount = Web3Number.fromWei(pool.data.supply_amount, token.decimals);
+            const price = (await this.pricer.getPrice(token.symbol)).price;
+            lendingPosition.push({
+                tokenName: token.name,
+                tokenSymbol: token.symbol,
+                marginType: pool.data.is_collateral ? MarginType.SHARED : MarginType.NONE,
+                debtAmount,
+                debtUSD: debtAmount.multipliedBy(price.toFixed(6)),
+                supplyAmount,
+                supplyUSD: supplyAmount.multipliedBy(price.toFixed(6))
+            });
+        };
+        return lendingPosition;
+    }
+}

package/src/node/index.ts

@@ -0,0 +1 @@
+export * from './pricer-redis';

package/src/node/pricer-redis.ts

@@ -0,0 +1,71 @@
+import { FatalError, Global, logger } from '@/global';
+import { IConfig, TokenInfo } from '@/interfaces';
+import { PriceInfo, Pricer } from '@/modules/pricer';
+import { createClient } from 'redis';
+import type { RedisClientType } from 'redis'
+
+export class PricerRedis extends Pricer {
+    private redisClient: RedisClientType | null = null;
+    constructor(config: IConfig, tokens: TokenInfo[]) {
+        super(config, tokens)
+    }
+
+    /** Reads prices from Pricer._loadPrices and uses a callback to set prices in redis */
+    async startWithRedis(redisUrl: string) {
+        await this.initRedis(redisUrl);
+
+        logger.info(`Starting Pricer with Redis`);
+        this._loadPrices(this._setRedisPrices.bind(this));
+        setInterval(() => {
+            this._loadPrices(this._setRedisPrices.bind(this));
+        }, 30000);
+    }
+
+    async close() {
+        if (this.redisClient) {
+            await this.redisClient.disconnect();
+        }
+    }
+
+    async initRedis(redisUrl: string) {
+        logger.info(`Initialising Redis Client`);
+        this.redisClient = <RedisClientType>(await createClient({
+            url: redisUrl
+        }));
+        this.redisClient.on('error', (err: any) => console.log('Redis Client Error', err))
+        .connect();
+        logger.info(`Redis Client Initialised`);
+    }
+
+    /** sets current local price in redis */
+    private _setRedisPrices(tokenSymbol: string) {
+        if (!this.redisClient) {
+            throw new FatalError(`Redis client not initialised`);
+        }
+        this.redisClient.set(`Price:${tokenSymbol}`, JSON.stringify(this.prices[tokenSymbol]))
+        .catch(err => {
+            logger.warn(`Error setting price in redis for ${tokenSymbol}`);
+        })
+    }
+
+    /** Returns price from redis */
+    async getPrice(tokenSymbol: string) {
+        const STALE_TIME = 60000;
+        if (!this.redisClient) {
+            throw new FatalError(`Redis client not initialised`);
+        }
+        const data = await this.redisClient.get(`Price:${tokenSymbol}`);
+        if (!data) {
+            throw new FatalError(`Redis:Price of ${tokenSymbol} not found`);
+        }
+
+        logger.verbose(`Redis:Price of ${tokenSymbol} is ${data}`);
+
+        const priceInfo: PriceInfo = JSON.parse(data);
+        priceInfo.timestamp = new Date(priceInfo.timestamp);
+        const isStale = (new Date().getTime() - priceInfo.timestamp.getTime()) > STALE_TIME;
+        Global.assert(!isStale, `Price of ${tokenSymbol} is stale`);
+        return priceInfo;
+
+    }
+}

package/src/notifs/index.ts

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

package/src/notifs/telegram.ts

@@ -0,0 +1,48 @@
+import { logger } from "@/global";
+import TelegramBot from "node-telegram-bot-api";
+
+export class TelegramNotif {
+    private subscribers: string[] = [
+        // '6820228303',
+        '1505578076',
+        // '5434736198', // maaza
+        '1356705582', // langs
+        '1388729514', // hwashere
+        '6020162572', //minato
+        '985902592'
+    ];
+    readonly bot: TelegramBot;
+
+    constructor(token: string, shouldPoll: boolean) {
+        this.bot = new TelegramBot(token, { polling: shouldPoll });
+    }
+
+    // listen to start msgs, register chatId and send registered msg
+    activateChatBot() {
+        this.bot.on('message', (msg: any) => {
+            const chatId = msg.chat.id;
+            let text = msg.text.toLowerCase().trim()
+            logger.verbose(`Tg: IncomingMsg: ID: ${chatId}, msg: ${text}`)
+            if(text=='start') {
+                this.bot.sendMessage(chatId, "Registered")
+                this.subscribers.push(chatId)
+                logger.verbose(`Tg: New subscriber: ${chatId}`);
+            } else {
+                this.bot.sendMessage(chatId, "Unrecognized command. Supported commands: start");
+            }
+        });
+    }
+
+    // send a given msg to all registered users
+    sendMessage(msg: string) {
+        logger.verbose(`Tg: Sending message: ${msg}`);
+        for (let chatId of this.subscribers) {
+            this.bot.sendMessage(chatId, msg).catch((err: any) => {
+                logger.error(`Tg: Error sending msg to ${chatId}`);
+                logger.error(`Tg: Error sending message: ${err.message}`);
+            }).then(() => {
+                logger.verbose(`Tg: Message sent to ${chatId}`);
+            })
+        }
+    }
+}

package/src/strategies/autoCompounderStrk.ts

@@ -0,0 +1,71 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { IConfig } from "@/interfaces";
+import { Contract, uint256 } from "starknet";
+import { Pricer } from "@/modules/pricer";
+
+export class AutoCompounderSTRK {
+    readonly config: IConfig;
+    readonly addr = ContractAddr.from('0x541681b9ad63dff1b35f79c78d8477f64857de29a27902f7298f7b620838ea');
+    readonly pricer: Pricer;
+    private initialized: boolean = false;
+
+    contract: Contract | null = null;
+
+    readonly metadata = {
+        decimals: 18,
+        underlying: {
+            // zSTRK
+            address: ContractAddr.from('0x06d8fa671ef84f791b7f601fa79fea8f6ceb70b5fa84189e3159d532162efc21'),
+            name: 'STRK',
+            symbol: 'STRK',
+        },
+        name: 'AutoCompounderSTRK',
+    }
+
+    constructor(config: IConfig, pricer: Pricer) {
+        this.config = config;
+        this.pricer = pricer;
+        this.init();
+    }
+
+    async init() {
+        const cls = await this.config.provider.getClassAt(this.addr.address);
+        this.contract = new Contract(cls.abi, this.addr.address, this.config.provider);
+        this.initialized = true;
+    }
+
+    async waitForInitilisation() {
+        return new Promise<void>((resolve, reject) => {
+            const interval = setInterval(() => {
+                if (this.initialized) {
+                    clearInterval(interval);
+                    resolve();
+                }
+            }, 1000);
+        });
+    }
+
+    /** Returns shares of user */
+    async balanceOf(user: ContractAddr) {
+        const result = await this.contract!.balanceOf(user.address);
+        return Web3Number.fromWei(result.toString(), this.metadata.decimals);
+    }
+
+    /** Returns underlying assets of user */
+    async balanceOfUnderlying(user: ContractAddr) {
+        const balanceShares = await this.balanceOf(user);
+        const assets = await this.contract!.convert_to_assets(uint256.bnToUint256(balanceShares.toWei()));
+        return Web3Number.fromWei(assets.toString(), this.metadata.decimals);
+    }
+
+    /** Returns usd value of assets */
+    async usdBalanceOfUnderlying(user: ContractAddr) {
+        const assets = await this.balanceOfUnderlying(user);
+        const price = await this.pricer.getPrice(this.metadata.underlying.name);
+        const usd = assets.multipliedBy(price.price.toFixed(6))
+        return {
+            usd,
+            assets
+        }
+    }
+}

package/src/strategies/index.ts

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

package/src/utils/encrypt.ts

@@ -0,0 +1,68 @@
+import * as crypto from 'crypto';
+
+export class PasswordJsonCryptoUtil {
+  private readonly algorithm = 'aes-256-gcm';
+  private readonly keyLength = 32; // 256 bits
+  private readonly saltLength = 16; // 128 bits
+  private readonly ivLength = 12; // 96 bits for GCM
+  private readonly tagLength = 16; // 128 bits
+  private readonly pbkdf2Iterations = 100000; // Number of iterations for PBKDF2
+
+  private deriveKey(password: string, salt: Buffer): Buffer {
+    return crypto.pbkdf2Sync(password, salt, this.pbkdf2Iterations, this.keyLength, 'sha256');
+  }
+
+  encrypt(data: any, password: string): string {
+    // Convert data to JSON string
+    const jsonString = JSON.stringify(data);
+
+    // Generate a random salt and IV
+    const salt = crypto.randomBytes(this.saltLength);
+    const iv = crypto.randomBytes(this.ivLength);
+
+    // Derive a key from the password and salt
+    const key = this.deriveKey(password, salt);
+
+    // Create cipher
+    const cipher = crypto.createCipheriv(this.algorithm, key, iv, { authTagLength: this.tagLength });
+
+    // Encrypt the data
+    let encrypted = cipher.update(jsonString, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+
+    // Get the authentication tag
+    const tag = cipher.getAuthTag();
+
+    // Combine all pieces: salt (16 bytes) + iv (12 bytes) + tag (16 bytes) + encrypted data
+    return Buffer.concat([salt, iv, tag, Buffer.from(encrypted, 'hex')]).toString('base64');
+  }
+
+  decrypt(encryptedData: string, password: string): any {
+    // Convert the base64 string back to a buffer
+    const data = Buffer.from(encryptedData, 'base64');
+
+    // Extract the pieces
+    const salt = data.subarray(0, this.saltLength);
+    const iv = data.subarray(this.saltLength, this.saltLength + this.ivLength);
+    const tag = data.subarray(this.saltLength + this.ivLength, this.saltLength + this.ivLength + this.tagLength);
+    const encrypted = data.subarray(this.saltLength + this.ivLength + this.tagLength);
+
+    // Derive the key
+    const key = this.deriveKey(password, salt);
+
+    // Create decipher
+    const decipher = crypto.createDecipheriv(this.algorithm, key, iv, { authTagLength: this.tagLength });
+    decipher.setAuthTag(tag);
+
+    try {
+      // Decrypt the data
+      let decrypted = decipher.update(encrypted.toString('hex'), 'hex', 'utf8');
+      decrypted += decipher.final('utf8');
+
+      // Parse the JSON string
+      return JSON.parse(decrypted);
+    } catch (error) {
+      throw new Error('Decryption failed. This could be due to an incorrect password or corrupted data.');
+    }
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,12 @@
+export * from './store';
+export * from './encrypt';
+
+// Utility type to make all optional properties required
+export type RequiredFields<T> = {
+    [K in keyof T]-?: T[K]
+}
+
+// Utility type to get only the required fields of a type
+export type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K
+}[keyof T]