zo-sdk 0.1.2 → 0.1.4

package/dist/implementations/SLPDataAPI.cjs

@@ -1,4 +1,7 @@
 "use strict";
+/* eslint-disable no-await-in-loop */
+/* eslint-disable @stylistic/indent-binary-ops */
+/* eslint-disable @stylistic/indent */
 /**
  * SLP DataAPI implementation
  * Implements SLP-specific data access methods for Sudo SDK
@@ -7,10 +10,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SLPDataAPI = void 0;
 const transactions_1 = require("@mysten/sui/transactions");
 const utils_1 = require("@mysten/sui/utils");
-const consts_1 = require("../consts/index.cjs");
 const abstract_1 = require("../abstract/index.cjs");
-const utils_2 = require("../utils.cjs");
 const bcs_1 = require("../bcs.cjs");
+const consts_1 = require("../consts/index.cjs");
+const utils_2 = require("../utils.cjs");
 let aprResponse = {};
 const SECONDS_PER_EIGHT_HOUR = 8 * 60 * 60; // 28800 seconds
 class SLPDataAPI extends abstract_1.BaseDataAPI {
@@ -28,7 +31,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                 showContent: true,
             },
         });
-        return this.parseRebaseFeeModel(rawData);
+        return SLPDataAPI.parseRebaseFeeModel(rawData);
     }
     /**
      * Creates vaults valuation for SLP using Sudo SDK approach
@@ -136,9 +139,9 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
         const vaultsValuation = bcs_1.VaultsValuation.parse(new Uint8Array(res.results[(res.results?.length || 0) - symbolsValuationOffset - 1].mutableReferenceOutputs[1][1]));
         const symbolsValuation = bcs_1.SymbolsValuation.parse(new Uint8Array(res.results[(res.results?.length || 0) - 1]
             .mutableReferenceOutputs[1][1]));
-        const result = Number(BigInt(vaultsValuation.value) +
-            BigInt(symbolsValuation.value.value) *
-                BigInt(symbolsValuation.value.is_positive ? 1 : -1)) / 1e18;
+        const result = Number(BigInt(vaultsValuation.value)
+            + BigInt(symbolsValuation.value.value)
+                * BigInt(symbolsValuation.value.is_positive ? 1 : -1)) / 1e18;
         return result;
     }
     /**
@@ -164,8 +167,8 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
             throw new Error('Sudo Core configuration not found');
         }
         const marketInfo = await this.getMarketInfo();
-        let value = await this.simValuateVaults(this.consts.sudoCore.adminCap);
-        let slpPrice = value / marketInfo.lpSupplyWithDecimals;
+        const value = await this.simValuateVaults(this.consts.sudoCore.adminCap);
+        const slpPrice = value / marketInfo.lpSupplyWithDecimals;
         return {
             marketCap: value,
             price: slpPrice,
@@ -189,7 +192,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
         });
         const apr = await this.getCumulativeApr();
         return {
-            ...this.parseMarketInfo(rawData),
+            ...SLPDataAPI.parseMarketInfo(rawData),
             apr,
         };
     }
@@ -283,7 +286,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
     async getStaked(owner) {
         let rawCredentialsData = [];
         let queryNextPage = true;
-        let queryCursor = undefined;
+        let queryCursor;
         const limit = 50;
         while (queryNextPage) {
             const { data, hasNextPage, nextCursor } = await this.provider.getOwnedObjects({
@@ -308,7 +311,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
             rawCredentialsData = [...rawCredentialsData, ...data];
         }
         const pool = await this.getStakePool();
-        const credentials = rawCredentialsData.map((item) => this.parseCredential(item, pool));
+        const credentials = rawCredentialsData.map((item) => SLPDataAPI.parseCredential(item, pool));
         return {
             credentials,
             amount: credentials.reduce((acc, cur) => acc + cur.amount, BigInt(0)),
@@ -322,12 +325,15 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                 showContent: true,
             },
         });
-        return this.parseStakePool(raw);
+        return SLPDataAPI.parseStakePool(raw);
     }
     async fundingFeeRate(indexToken, long, sender) {
+        if (!sender) {
+            throw new Error('Sender address is required for fundingFeeRate calculation');
+        }
         const tx = await this.initOracleTxb([indexToken]);
         const symbol_ = (0, utils_2.joinSymbol)(long ? 'long' : 'short', indexToken);
-        const currentTimestamp = parseInt((+new Date() / 1000).toFixed(0));
+        const currentTimestamp = Number.parseInt((Date.now() / 1000).toFixed(0), 10);
         const symbol = tx.moveCall({
             target: `${this.consts.sudoCore.package}::market::symbol`,
             typeArguments: [
@@ -378,10 +384,13 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
             transactionBlock: tx,
             sender,
         });
-        const de = bcs_1.SRate.parse(new Uint8Array(res.results[res.results.length - 1].returnValues[0][0]));
+        const de = bcs_1.SRate.parse(new Uint8Array(res.results.at(-1).returnValues[0][0]));
         return (Number(BigInt(de.value)) / 1e18) * (de.is_positive ? 1 : -1);
     }
     async rebaseFeeRate(collateralToken, increase, amount, sender) {
+        if (!sender) {
+            throw new Error('Sender address is required for rebaseFeeRate calculation');
+        }
         const tx1 = await this.initOracleTxb(Object.keys(this.consts.pythFeeder.feeder));
         this.valuateVaults(tx1);
         const res1 = await this.provider.devInspectTransactionBlock({
@@ -391,7 +400,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
         const vaultsValuation = bcs_1.VaultsValuation.parse(new Uint8Array(res1.results[(res1.results?.length || 0) - 1]
             .mutableReferenceOutputs[1][1]));
         const singleVaultValue = BigInt(
-        // @ts-ignore
+        // @ts-expect-error: vaultsValuation.handled type is not properly defined in BCS schema
         vaultsValuation.handled.find((item) => (item.key || '').includes(this.consts.coins[collateralToken].module.slice(2)) || false)?.value.value) + BigInt(Math.floor(amount));
         const allVaultValue = BigInt(vaultsValuation.value) + BigInt(Math.floor(amount));
         const singleVaultWeight = BigInt(this.consts.sudoCore.vaults[collateralToken].weight);
@@ -412,17 +421,20 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
             transactionBlock: tx2,
             sender,
         });
-        const de = bcs_1.Rate.parse(new Uint8Array(res2.results[res2.results.length - 1].returnValues[0][0]));
+        const de = bcs_1.Rate.parse(new Uint8Array(res2.results.at(-1).returnValues[0][0]));
         return Number(BigInt(de)) / 1e18;
     }
     async reservingFeeRate(collateralToken, amount, sender) {
+        if (!sender) {
+            throw new Error('Sender address is required for reservingFeeRate calculation');
+        }
         const vaultInfo = await this.getVaultInfo(collateralToken);
-        const vaultSupply = vaultInfo.liquidity +
-            vaultInfo.reservedAmount +
-            vaultInfo.unrealisedReservingFeeAmount +
-            amount;
+        const vaultSupply = vaultInfo.liquidity
+            + vaultInfo.reservedAmount
+            + vaultInfo.unrealisedReservingFeeAmount
+            + amount;
         const utilization = vaultSupply
-            ? parseInt((((vaultInfo.reservedAmount + amount) / vaultSupply) * 1e18).toFixed(0))
+            ? Number.parseInt((((vaultInfo.reservedAmount + amount) / vaultSupply) * 1e18).toFixed(0), 10)
             : 0;
         const tx = new transactions_1.Transaction();
         tx.moveCall({
@@ -437,7 +449,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
             transactionBlock: tx,
             sender,
         });
-        const de = bcs_1.Rate.parse(new Uint8Array(res.results[res.results.length - 1].returnValues[0][0]));
+        const de = bcs_1.Rate.parse(new Uint8Array(res.results.at(-1).returnValues[0][0]));
         return Number(BigInt(de)) / 1e18;
     }
     async getPositionConfig(indexToken, long) {
@@ -452,12 +464,12 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                 showContent: true,
             },
         });
-        return this.parsePositionConfig(rawData);
+        return SLPDataAPI.parsePositionConfig(rawData);
     }
     async getOpenPositions(batchSize = 50, symbol = 'sui') {
         let positionDynamicFields = [];
         let _continue = true;
-        let cursor = undefined;
+        let cursor;
         while (_continue) {
             // data here will be a list of dynamic fields containing name and value
             const { data, nextCursor, hasNextPage } = await this.provider.getDynamicFields({
@@ -469,23 +481,21 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
             cursor = nextCursor;
         }
         // Filter by symbol if provided
-        if (symbol && this.consts.coins[symbol]) {
-            const coinModule = symbol === 'sui' ? '0x2::sui::SUI' : this.consts.coins[symbol].module;
-            positionDynamicFields = positionDynamicFields.filter(field => {
-                // Extract the second coin module from PositionName<coin1, coin2, direction>
-                const typeStr = field.name?.type;
-                if (!typeStr)
-                    return false;
-                const match = typeStr.match(/PositionName<([^,]+),\s*([^,]+),\s*([^>]+)>/);
-                if (!match)
-                    return false;
-                const secondCoin = match[2].trim();
-                return secondCoin === coinModule;
-            });
-        }
-        else {
+        if (!(symbol && this.consts.coins[symbol])) {
             return [];
         }
+        const coinModule = symbol === 'sui' ? '0x2::sui::SUI' : this.consts.coins[symbol].module;
+        positionDynamicFields = positionDynamicFields.filter((field) => {
+            // Extract the second coin module from PositionName<coin1, coin2, direction>
+            const typeStr = field.name?.type;
+            if (!typeStr)
+                return false;
+            const match = typeStr.match(/PositionName<([^,]+),([^,]+),([^>]+)>/);
+            if (!match)
+                return false;
+            const secondCoin = match[2].trim();
+            return secondCoin === coinModule;
+        });
         // then we query by dynamic field names and order by time
         const positionInfoList = [];
         for (let i = 0; i < positionDynamicFields.length; i += batchSize) {
@@ -496,7 +506,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                     name: positionDynamicField.name,
                 });
                 if (positionRaw?.data?.content) {
-                    // @ts-ignore
+                    // @ts-expect-error: content fields type is not properly defined
                     if (positionRaw?.data?.content?.fields?.value?.fields?.closed) {
                         // skip closed positions
                         return;
@@ -513,7 +523,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
             .sort((a, b) => (a.openTimestamp > b.openTimestamp ? 1 : -1));
     }
     async getPositionCapInfoList(owner) {
-        let cursor = undefined;
+        let cursor;
         let hasNextPage = true;
         const positionCapInfoList = [];
         while (hasNextPage) {
@@ -547,7 +557,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
         return positionCapInfoList;
     }
     async getOrderCapInfoList(owner) {
-        let cursor = undefined;
+        let cursor;
         let hasNextPage = true;
         const orderCapInfoList = [];
         while (hasNextPage) {
@@ -605,7 +615,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
             const orderRaw = await this.provider.getDynamicFieldObject({
                 parentId: this.consts.sudoCore.ordersParent,
                 name: {
-                    type: `${this.consts.sudoCore.package}::market::OrderName<${orderCapInfo.symbol0}, ${orderCapInfo.symbol1}, ${this.consts.sudoCore.package}::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${this.consts.coins['sui'].module}>`,
+                    type: `${this.consts.sudoCore.package}::market::OrderName<${orderCapInfo.symbol0}, ${orderCapInfo.symbol1}, ${this.consts.sudoCore.package}::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${this.consts.coins.sui.module}>`,
                     value: {
                         owner,
                         id: orderCapInfo.orderCapId,
@@ -622,9 +632,9 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
     async getCumulativeApr() {
         const refetchDate = new Date(Date.now() - 3600000);
         // fetch new every hour
-        if (!aprResponse?.generatedAt ||
-            (aprResponse?.generatedAt &&
-                refetchDate > new Date(aprResponse?.generatedAt))) {
+        if (!aprResponse?.generatedAt
+            || (aprResponse?.generatedAt
+                && refetchDate > new Date(aprResponse?.generatedAt))) {
             try {
                 const url = `${this.apiEndpoint}/cumulativeApr`;
                 const res = await fetch(url, {
@@ -634,64 +644,63 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                     },
                 });
                 const data = await res.json();
+                // eslint-disable-next-line require-atomic-updates
                 aprResponse = { ...data };
                 return data.cumulativeApr;
             }
-            catch (e) {
+            catch {
                 console.error('Failed to get cumulative APR');
             }
             return 0;
         }
-        else {
-            return aprResponse.apr;
-        }
+        return aprResponse.apr;
     }
     // Private helper methods
-    calculatePositionFundingFee(position, symbol, model, price, lpSupplyAmount, timestamp) {
+    static calculatePositionFundingFee(position, symbol, model, price, lpSupplyAmount, timestamp) {
         const accFundingRate = this.calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, position.long);
         return position.fundingFeeValue + (accFundingRate - position.lastFundingRate) * position.positionSize;
     }
-    calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, isLong) {
+    static calcAccFundingFeeRate(symbol, model, price, lpSupplyAmount, timestamp, isLong) {
         if (symbol.lastUpdate > 0) {
             const elapsed = timestamp - symbol.lastUpdate;
             if (elapsed > 0) {
                 const deltaSize = this.calcDeltaSize(symbol, price, isLong);
                 const pnlPerLp = (symbol.realisedPnl + symbol.unrealisedFundingFeeValue + deltaSize) / lpSupplyAmount;
-                return symbol.accFundingRate + this.calcFundingFeeRate(model, pnlPerLp, elapsed);
+                return symbol.accFundingRate + SLPDataAPI.calcFundingFeeRate(model, pnlPerLp, elapsed);
             }
         }
         return symbol.accFundingRate;
     }
-    calcDeltaSize(symbol, price, isLong) {
+    static calcDeltaSize(symbol, price, isLong) {
         const latestSize = symbol.openingAmount * price;
         return isLong ? symbol.openingSize - latestSize : latestSize - symbol.openingSize;
     }
-    calcFundingFeeRate(model, pnlPerRate, elapsed) {
+    static calcFundingFeeRate(model, pnlPerRate, elapsed) {
         const dailyRate = Math.min(model.multiplier * Math.abs(pnlPerRate), model.max);
         const secondsRate = dailyRate * elapsed / SECONDS_PER_EIGHT_HOUR;
         return pnlPerRate >= 0 ? -secondsRate : secondsRate;
     }
-    calculatePositionReserveFee(position, vault, model, timestamp) {
-        const accReservingRate = this.calcAccReservingFeeRate(vault, model, timestamp);
+    static calculatePositionReserveFee(position, vault, model, timestamp) {
+        const accReservingRate = SLPDataAPI.calcAccReservingFeeRate(vault, model, timestamp);
         return position.reservingFeeAmount + (accReservingRate - position.lastReservingRate) * position.collateralAmount;
     }
-    calcAccReservingFeeRate(vault, model, timestamp) {
+    static calcAccReservingFeeRate(vault, model, timestamp) {
         if (vault.lastUpdate > 0) {
             const elapsed = timestamp - vault.lastUpdate;
             if (elapsed > 0) {
-                const utilization = this.vaultUtilization(vault);
-                return vault.accReservingRate + this.calcReservingFeeRate(model, utilization, elapsed);
+                const utilization = SLPDataAPI.vaultUtilization(vault);
+                return vault.accReservingRate + SLPDataAPI.calcReservingFeeRate(model, utilization, elapsed);
             }
         }
         return vault.accReservingRate;
     }
-    vaultUtilization(vault) {
+    static vaultUtilization(vault) {
         return vault.liquidity > 0 ? vault.reservedAmount / vault.liquidity : 0;
     }
-    calcReservingFeeRate(model, utilization, elapsed) {
+    static calcReservingFeeRate(model, utilization, elapsed) {
         return model.multiplier * utilization * elapsed / SECONDS_PER_EIGHT_HOUR;
     }
-    parsePositionConfig(raw) {
+    static parsePositionConfig(raw) {
         const positionConfigFields = raw.data.content.fields.inner.fields;
         return {
             decreaseFeeBps: (0, utils_2.parseValue)(positionConfigFields.decrease_fee_bps),
@@ -704,21 +713,21 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
             minCollateralValue: (0, utils_2.parseValue)(positionConfigFields.min_collateral_value),
         };
     }
-    parseRebaseFeeModel(raw) {
+    static parseRebaseFeeModel(raw) {
         const { fields } = raw.data.content;
         return {
             base: (0, utils_2.parseValue)(fields.base),
             multiplier: (0, utils_2.parseValue)(fields.multiplier),
         };
     }
-    parseFundingFeeModel(raw) {
+    static parseFundingFeeModel(raw) {
         const { fields } = raw.data.content;
         return {
             multiplier: (0, utils_2.parseValue)(fields.multiplier),
             max: (0, utils_2.parseValue)(fields.max),
         };
     }
-    parseMarketInfo(raw) {
+    static parseMarketInfo(raw) {
         const content = raw.data.content.fields;
         return {
             lpSupply: content.lp_supply.fields.value,
@@ -737,7 +746,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                 showContent: true,
             },
         });
-        const reservingFeeModel = this.parseReservingFeeModel(reservingFeeModelRaw);
+        const reservingFeeModel = SLPDataAPI.parseReservingFeeModel(reservingFeeModelRaw);
         return {
             liquidity: (0, utils_2.parseValue)(vaultFields.liquidity),
             reservedAmount: (0, utils_2.parseValue)(vaultFields.reserved_amount),
@@ -755,14 +764,14 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
             },
         };
     }
-    parseReservingFeeModel(raw) {
+    static parseReservingFeeModel(raw) {
         const content = raw.data.content.fields;
         return {
             multiplier: (0, utils_2.parseValue)(content.multiplier),
         };
     }
     async parseSymbolInfo(raw, long) {
-        const fields = raw.data.content.fields.value.fields;
+        const { fields } = raw.data.content.fields.value;
         const fundingFeeModelAddr = fields.funding_fee_model;
         const fundingFeeModelRaw = await this.provider.getObject({
             id: fundingFeeModelAddr,
@@ -770,7 +779,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
                 showContent: true,
             },
         });
-        const fundingFeeModel = this.parseFundingFeeModel(fundingFeeModelRaw);
+        const fundingFeeModel = SLPDataAPI.parseFundingFeeModel(fundingFeeModelRaw);
         return {
             openingSize: (0, utils_2.parseValue)(fields.opening_size),
             openingAmount: (0, utils_2.parseValue)(fields.opening_amount),
@@ -792,15 +801,15 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
         };
     }
     async parsePositionInfo(raw, id_) {
-        const content = raw.data.content;
-        const fields = content.fields;
+        const { content } = raw.data;
+        const { fields } = content;
         const positionFields = fields.value.fields;
         const dataType = fields.name.type;
         const positionInfo = {
             id: id_,
             long: dataType.includes('::market::LONG'),
             owner: fields.name.fields.owner,
-            version: parseInt(raw.data.version, 10),
+            version: Number.parseInt(raw.data.version, 10),
             collateralToken: (0, utils_2.suiSymbolToSymbol)(dataType.split('<')[1].split(',')[0].trim(), this.consts),
             indexToken: (0, utils_2.suiSymbolToSymbol)(dataType.split(',')[1].trim(), this.consts),
             collateralAmount: (0, utils_2.parseValue)(positionFields.collateral),
@@ -817,8 +826,8 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
         };
         if (!positionFields.closed) {
             try {
-                positionInfo.reservingFeeAmount = this.calculatePositionReserveFee(positionInfo, await this.getVaultInfo(positionInfo.collateralToken), (await this.getVaultInfo(positionInfo.collateralToken)).reservingFeeModel, Date.now() / 1000);
-                positionInfo.fundingFeeValue = this.calculatePositionFundingFee(positionInfo, await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long), (await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long)).fundingFeeModel, (await this.getOraclePrice(positionInfo.indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked(), (await this.getMarketInfo()).lpSupplyWithDecimals, Date.now() / 1000);
+                positionInfo.reservingFeeAmount = SLPDataAPI.calculatePositionReserveFee(positionInfo, await this.getVaultInfo(positionInfo.collateralToken), (await this.getVaultInfo(positionInfo.collateralToken)).reservingFeeModel, Date.now() / 1000);
+                positionInfo.fundingFeeValue = SLPDataAPI.calculatePositionFundingFee(positionInfo, await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long), (await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long)).fundingFeeModel, (await this.getOraclePrice(positionInfo.indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked(), (await this.getMarketInfo()).lpSupplyWithDecimals, Date.now() / 1000);
             }
             catch (e) {
                 console.error(e);
@@ -829,14 +838,14 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
         return positionInfo;
     }
     parseOrderInfo(raw, capId) {
-        let content = raw.data.content;
-        let fields = content.fields.value.fields;
+        const { content } = raw.data;
+        const { fields } = content.fields.value;
         // Extract tokens from dataType
-        let dataType = content.type;
+        const dataType = content.type;
         const orderType = content.fields.value.type.includes('OpenPositionOrder')
             ? 'OPEN_POSITION'
             : 'DECREASE_POSITION';
-        let ret = {
+        const ret = {
             id: content.fields.id.id,
             capId,
             executed: fields.executed,
@@ -866,7 +875,7 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
         }
         return ret;
     }
-    parseCredential(raw, pool) {
+    static parseCredential(raw, pool) {
         const stakedAmount = BigInt(raw.data.content.fields.stake);
         const accRewardPerShare = BigInt(raw.data.content.fields.acc_reward_per_share);
         return {
@@ -874,11 +883,11 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
             lockUntil: (0, utils_2.parseValue)(raw.data.content.fields.lock_until),
             amount: stakedAmount,
             accRewardPerShare,
-            claimable: ((pool.accRewardPerShare - accRewardPerShare) * stakedAmount) /
-                BigInt(1e18),
+            claimable: ((pool.accRewardPerShare - accRewardPerShare) * stakedAmount)
+                / BigInt(1e18),
         };
     }
-    parseStakePool(raw) {
+    static parseStakePool(raw) {
         const content = raw.data.content.fields;
         const pool = {
             id: content.id.id,
@@ -891,22 +900,22 @@ class SLPDataAPI extends abstract_1.BaseDataAPI {
             accRewardPerShare: BigInt(content.acc_reward_per_share),
             lockDuration: (0, utils_2.parseValue)(content.lock_duration),
         };
-        this.refreshPool(pool, Math.floor(Date.now() / 1000));
+        SLPDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000));
         return pool;
     }
-    refreshPool(pool, timestamp) {
+    static refreshPool(pool, timestamp) {
         if (timestamp === pool.lastUpdatedTime || timestamp < pool.startTime) {
             return;
         }
-        if (pool.lastUpdatedTime === pool.endTime ||
-            pool.stakedAmount === BigInt(0)) {
+        if (pool.lastUpdatedTime === pool.endTime
+            || pool.stakedAmount === BigInt(0)) {
             return;
         }
         if (timestamp > pool.endTime) {
             timestamp = pool.endTime;
         }
-        const rewardAmount = (pool.reward * BigInt(timestamp - pool.lastUpdatedTime)) /
-            BigInt(pool.endTime - pool.lastUpdatedTime);
+        const rewardAmount = (pool.reward * BigInt(timestamp - pool.lastUpdatedTime))
+            / BigInt(pool.endTime - pool.lastUpdatedTime);
         pool.lastUpdatedTime = timestamp;
         const rewardPerShare = (rewardAmount * BigInt(1e18)) / pool.stakedAmount;
         pool.accRewardPerShare += rewardPerShare;