zo-sdk 0.1.2 → 0.1.3

package/dist/implementations/SLPDataAPI.mjs

@@ -1,13 +1,16 @@
+/* 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
  */
 import { Transaction } from "@mysten/sui/transactions";
 import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
-import { LPToken, SLP_TOKEN_DECIMALS } from "../consts/index.mjs";
 import { BaseDataAPI } from "../abstract/index.mjs";
-import { decimalToObject, joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from "../utils.mjs";
 import { Rate, SRate, SymbolsValuation, VaultsValuation } from "../bcs.mjs";
+import { LPToken, SLP_TOKEN_DECIMALS } from "../consts/index.mjs";
+import { decimalToObject, joinSymbol, parseSymbolKey, parseValue, suiSymbolToSymbol } from "../utils.mjs";
 let aprResponse = {};
 const SECONDS_PER_EIGHT_HOUR = 8 * 60 * 60; // 28800 seconds
 export class SLPDataAPI extends BaseDataAPI {
@@ -25,7 +28,7 @@ export class SLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        return this.parseRebaseFeeModel(rawData);
+        return SLPDataAPI.parseRebaseFeeModel(rawData);
     }
     /**
      * Creates vaults valuation for SLP using Sudo SDK approach
@@ -133,9 +136,9 @@ export class SLPDataAPI extends BaseDataAPI {
         const vaultsValuation = VaultsValuation.parse(new Uint8Array(res.results[(res.results?.length || 0) - symbolsValuationOffset - 1].mutableReferenceOutputs[1][1]));
         const symbolsValuation = 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;
     }
     /**
@@ -161,8 +164,8 @@ export class SLPDataAPI extends 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,
@@ -186,7 +189,7 @@ export class SLPDataAPI extends BaseDataAPI {
         });
         const apr = await this.getCumulativeApr();
         return {
-            ...this.parseMarketInfo(rawData),
+            ...SLPDataAPI.parseMarketInfo(rawData),
             apr,
         };
     }
@@ -280,7 +283,7 @@ export class SLPDataAPI extends 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({
@@ -305,7 +308,7 @@ export class SLPDataAPI extends 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)),
@@ -319,12 +322,15 @@ export class SLPDataAPI extends 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_ = 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: [
@@ -375,10 +381,13 @@ export class SLPDataAPI extends BaseDataAPI {
             transactionBlock: tx,
             sender,
         });
-        const de = SRate.parse(new Uint8Array(res.results[res.results.length - 1].returnValues[0][0]));
+        const de = 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({
@@ -388,7 +397,7 @@ export class SLPDataAPI extends BaseDataAPI {
         const vaultsValuation = 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);
@@ -409,17 +418,20 @@ export class SLPDataAPI extends BaseDataAPI {
             transactionBlock: tx2,
             sender,
         });
-        const de = Rate.parse(new Uint8Array(res2.results[res2.results.length - 1].returnValues[0][0]));
+        const de = 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 Transaction();
         tx.moveCall({
@@ -434,7 +446,7 @@ export class SLPDataAPI extends BaseDataAPI {
             transactionBlock: tx,
             sender,
         });
-        const de = Rate.parse(new Uint8Array(res.results[res.results.length - 1].returnValues[0][0]));
+        const de = Rate.parse(new Uint8Array(res.results.at(-1).returnValues[0][0]));
         return Number(BigInt(de)) / 1e18;
     }
     async getPositionConfig(indexToken, long) {
@@ -449,12 +461,12 @@ export class SLPDataAPI extends 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({
@@ -466,23 +478,21 @@ export class SLPDataAPI extends 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) {
@@ -493,7 +503,7 @@ export class SLPDataAPI extends 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;
@@ -510,7 +520,7 @@ export class SLPDataAPI extends 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) {
@@ -544,7 +554,7 @@ export class SLPDataAPI extends BaseDataAPI {
         return positionCapInfoList;
     }
     async getOrderCapInfoList(owner) {
-        let cursor = undefined;
+        let cursor;
         let hasNextPage = true;
         const orderCapInfoList = [];
         while (hasNextPage) {
@@ -602,7 +612,7 @@ export class SLPDataAPI extends 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,
@@ -619,9 +629,9 @@ export class SLPDataAPI extends 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, {
@@ -631,64 +641,63 @@ export class SLPDataAPI extends 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: parseValue(positionConfigFields.decrease_fee_bps),
@@ -701,21 +710,21 @@ export class SLPDataAPI extends BaseDataAPI {
             minCollateralValue: parseValue(positionConfigFields.min_collateral_value),
         };
     }
-    parseRebaseFeeModel(raw) {
+    static parseRebaseFeeModel(raw) {
         const { fields } = raw.data.content;
         return {
             base: parseValue(fields.base),
             multiplier: parseValue(fields.multiplier),
         };
     }
-    parseFundingFeeModel(raw) {
+    static parseFundingFeeModel(raw) {
         const { fields } = raw.data.content;
         return {
             multiplier: parseValue(fields.multiplier),
             max: parseValue(fields.max),
         };
     }
-    parseMarketInfo(raw) {
+    static parseMarketInfo(raw) {
         const content = raw.data.content.fields;
         return {
             lpSupply: content.lp_supply.fields.value,
@@ -734,7 +743,7 @@ export class SLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        const reservingFeeModel = this.parseReservingFeeModel(reservingFeeModelRaw);
+        const reservingFeeModel = SLPDataAPI.parseReservingFeeModel(reservingFeeModelRaw);
         return {
             liquidity: parseValue(vaultFields.liquidity),
             reservedAmount: parseValue(vaultFields.reserved_amount),
@@ -752,14 +761,14 @@ export class SLPDataAPI extends BaseDataAPI {
             },
         };
     }
-    parseReservingFeeModel(raw) {
+    static parseReservingFeeModel(raw) {
         const content = raw.data.content.fields;
         return {
             multiplier: 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,
@@ -767,7 +776,7 @@ export class SLPDataAPI extends BaseDataAPI {
                 showContent: true,
             },
         });
-        const fundingFeeModel = this.parseFundingFeeModel(fundingFeeModelRaw);
+        const fundingFeeModel = SLPDataAPI.parseFundingFeeModel(fundingFeeModelRaw);
         return {
             openingSize: parseValue(fields.opening_size),
             openingAmount: parseValue(fields.opening_amount),
@@ -789,15 +798,15 @@ export class SLPDataAPI extends 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: suiSymbolToSymbol(dataType.split('<')[1].split(',')[0].trim(), this.consts),
             indexToken: suiSymbolToSymbol(dataType.split(',')[1].trim(), this.consts),
             collateralAmount: parseValue(positionFields.collateral),
@@ -814,8 +823,8 @@ export class SLPDataAPI extends 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);
@@ -826,14 +835,14 @@ export class SLPDataAPI extends 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,
@@ -863,7 +872,7 @@ export class SLPDataAPI extends 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 {
@@ -871,11 +880,11 @@ export class SLPDataAPI extends BaseDataAPI {
             lockUntil: 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,
@@ -888,22 +897,22 @@ export class SLPDataAPI extends BaseDataAPI {
             accRewardPerShare: BigInt(content.acc_reward_per_share),
             lockDuration: 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;