@suilend/sdk 1.0.6 → 1.0.8

package/core/utils/events.js

@@ -0,0 +1,104 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRedeemEvent = exports.getEvents = exports.ObligationDataEvent = exports.ClaimRewardEvent = exports.LiquidateEvent = exports.RepayEvent = exports.BorrowEvent = exports.WithdrawEvent = exports.DepositEvent = exports.RedeemEvent = exports.MintEvent = exports.ReserveAssetDataEvent = exports.InterestUpdateEvent = exports.GenericSuilendEvent = exports.SuilendTransactionModule = exports.SuilendEventType = void 0;
+var SuilendEventType;
+(function (SuilendEventType) {
+    SuilendEventType["InterestUpdateEvent"] = "InterestUpdateEvent";
+    SuilendEventType["ReserveAssetDataEvent"] = "ReserveAssetDataEvent";
+    SuilendEventType["MintEvent"] = "MintEvent";
+    SuilendEventType["RedeemEvent"] = "RedeemEvent";
+    SuilendEventType["DepositEvent"] = "DepositEvent";
+    SuilendEventType["WithdrawEvent"] = "WithdrawEvent";
+    SuilendEventType["BorrowEvent"] = "BorrowEvent";
+    SuilendEventType["RepayEvent"] = "RepayEvent";
+    SuilendEventType["LiquidateEvent"] = "LiquidateEvent";
+    SuilendEventType["ClaimRewardEvent"] = "ClaimRewardEvent";
+    SuilendEventType["ObligationDataEvent"] = "ObligationDataEvent";
+})(SuilendEventType || (exports.SuilendEventType = SuilendEventType = {}));
+var SuilendTransactionModule;
+(function (SuilendTransactionModule) {
+    SuilendTransactionModule["LendingMarket"] = "lending_market";
+    SuilendTransactionModule["Reserve"] = "reserve";
+})(SuilendTransactionModule || (exports.SuilendTransactionModule = SuilendTransactionModule = {}));
+class TypedParamsSuiEvent {
+    constructor(event) {
+        this.event = event;
+    }
+    params() {
+        return this.event.parsedJson;
+    }
+    isType(module, eventType) {
+        return this.event.type.includes(`${module}::${eventType}`);
+    }
+}
+class GenericSuilendEvent extends TypedParamsSuiEvent {
+}
+exports.GenericSuilendEvent = GenericSuilendEvent;
+class InterestUpdateEvent extends TypedParamsSuiEvent {
+}
+exports.InterestUpdateEvent = InterestUpdateEvent;
+class ReserveAssetDataEvent extends TypedParamsSuiEvent {
+}
+exports.ReserveAssetDataEvent = ReserveAssetDataEvent;
+class MintEvent extends TypedParamsSuiEvent {
+}
+exports.MintEvent = MintEvent;
+class RedeemEvent extends TypedParamsSuiEvent {
+}
+exports.RedeemEvent = RedeemEvent;
+class DepositEvent extends TypedParamsSuiEvent {
+}
+exports.DepositEvent = DepositEvent;
+class WithdrawEvent extends TypedParamsSuiEvent {
+}
+exports.WithdrawEvent = WithdrawEvent;
+class BorrowEvent extends TypedParamsSuiEvent {
+}
+exports.BorrowEvent = BorrowEvent;
+class RepayEvent extends TypedParamsSuiEvent {
+}
+exports.RepayEvent = RepayEvent;
+class LiquidateEvent extends TypedParamsSuiEvent {
+}
+exports.LiquidateEvent = LiquidateEvent;
+class ClaimRewardEvent extends TypedParamsSuiEvent {
+}
+exports.ClaimRewardEvent = ClaimRewardEvent;
+class ObligationDataEvent extends TypedParamsSuiEvent {
+}
+exports.ObligationDataEvent = ObligationDataEvent;
+function getEvents(client, digest) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tx = yield client.getTransactionBlock({
+            digest,
+            options: { showEvents: true },
+        });
+        const events = [];
+        for (const event of tx.events || []) {
+            events.push(new GenericSuilendEvent(event));
+        }
+        return events;
+    });
+}
+exports.getEvents = getEvents;
+function getRedeemEvent(client, digest) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const events = yield getEvents(client, digest);
+        for (const event of events) {
+            if (event.isType(SuilendTransactionModule.LendingMarket, SuilendEventType.RedeemEvent)) {
+                return event;
+            }
+        }
+        return null;
+    });
+}
+exports.getRedeemEvent = getRedeemEvent;

package/core/utils/simulate.d.ts

@@ -0,0 +1,56 @@
+import BigNumber from "bignumber.js";
+import { SuiPriceServiceConnection } from "../../pyth-sdk";
+interface Deps {
+    Decimal: any;
+    Obligation: any;
+    Deposit: any;
+    Borrow: any;
+    Reserve: any;
+    ReserveConfig: any;
+    PoolRewardManager: any;
+    PoolReward: any;
+    UserRewardManager: any;
+    UserReward: any;
+}
+export declare class Simulate {
+    Decimal: Deps["Decimal"];
+    Obligation: Deps["Obligation"];
+    Deposit: Deps["Deposit"];
+    Borrow: Deps["Borrow"];
+    Reserve: Deps["Reserve"];
+    ReserveConfig: Deps["ReserveConfig"];
+    PoolRewardManager: Deps["PoolRewardManager"];
+    PoolReward: Deps["PoolReward"];
+    UserRewardManager: Deps["UserRewardManager"];
+    UserReward: Deps["UserReward"];
+    constructor({ Decimal, Obligation, Deposit, Borrow, Reserve, ReserveConfig, PoolRewardManager, PoolReward, UserRewardManager, UserReward, }: Deps);
+    /**
+     * @deprecated since version 1.0.8. Use `calculateUtilizationPercent` instead.
+     */
+    calculateUtilizationRate(reserve: typeof this.Reserve): BigNumber;
+    calculateUtilizationPercent(reserve: typeof this.Reserve): BigNumber;
+    /**
+     * @deprecated since version 1.0.8. Use `calculateBorrowAprPercent` instead.
+     */
+    calculateBorrowApr(reserve: typeof this.Reserve): BigNumber;
+    calculateBorrowAprPercent(reserve: typeof this.Reserve): BigNumber;
+    /**
+     * @deprecated since version 1.0.8. Use `calculateDepositAprPercent` instead.
+     */
+    calculateSupplyApr(reserve: typeof this.Reserve): BigNumber;
+    calculateDepositAprPercent(reserve: typeof this.Reserve): BigNumber;
+    compoundReserveInterest(reserve: typeof this.Reserve, now: number): typeof this.Reserve;
+    updatePoolRewardsManager(manager: typeof this.PoolRewardManager, nowMs: number): typeof this.PoolRewardManager;
+    refreshReservePrice(reserves: (typeof this.Reserve)[], pythConnection: SuiPriceServiceConnection): Promise<(typeof this.Reserve)[]>;
+    updateUserRewardManager(poolManager: typeof this.PoolRewardManager, userRewardManager: typeof this.UserRewardManager, now: number): typeof this.UserRewardManager;
+    refreshObligation(unrefreshedObligation: typeof this.Obligation, refreshedReserves: (typeof this.Reserve)[]): typeof this.Obligation;
+    numberToDecimal(value: number): any;
+    stringToDecimal(value: string): any;
+    decimalToBigNumber(value: typeof this.Decimal): BigNumber;
+    getCTokenMarketValue(reserve: typeof this.Reserve, depositedCTokenAmount: BigNumber): BigNumber;
+    getCTokenMarketValueLowerBound(reserve: typeof this.Reserve, depositedCTokenAmount: BigNumber): BigNumber;
+    cTokenRatio(reserve: typeof this.Reserve): BigNumber;
+    totalSupply(reserve: typeof this.Reserve): BigNumber;
+    compoundDebt(borrow: typeof this.Borrow, reserve: typeof this.Reserve): typeof this.Borrow;
+}
+export {};

package/core/utils/simulate.js

@@ -0,0 +1,317 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Simulate = void 0;
+const bcs_1 = require("@mysten/sui.js/bcs");
+const utils_1 = require("@mysten/sui.js/utils");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const constants_1 = require("../constants");
+class Simulate {
+    constructor({ Decimal, Obligation, Deposit, Borrow, Reserve, ReserveConfig, PoolRewardManager, PoolReward, UserRewardManager, UserReward, }) {
+        this.Decimal = Decimal;
+        this.Obligation = Obligation;
+        this.Deposit = Deposit;
+        this.Borrow = Borrow;
+        this.Reserve = Reserve;
+        this.ReserveConfig = ReserveConfig;
+        this.PoolRewardManager = PoolRewardManager;
+        this.PoolReward = PoolReward;
+        this.UserRewardManager = UserRewardManager;
+        this.UserReward = UserReward;
+    }
+    /**
+     * @deprecated since version 1.0.8. Use `calculateUtilizationPercent` instead.
+     */
+    calculateUtilizationRate(reserve) {
+        const { mintDecimals } = reserve;
+        // Parsing logic from core/parsers/reserve.ts
+        const availableAmount = new bignumber_js_1.default(reserve.availableAmount.toString()).div(10 ** mintDecimals);
+        const borrowedAmount = new bignumber_js_1.default(reserve.borrowedAmount.value.toString())
+            .div(constants_1.WAD)
+            .div(10 ** mintDecimals);
+        const unclaimedSpreadFees = new bignumber_js_1.default(reserve.unclaimedSpreadFees.value.toString())
+            .div(constants_1.WAD)
+            .div(10 ** mintDecimals);
+        const depositedAmount = borrowedAmount
+            .plus(availableAmount)
+            .minus(unclaimedSpreadFees);
+        return depositedAmount.eq(0)
+            ? new bignumber_js_1.default(0)
+            : borrowedAmount.div(depositedAmount);
+    }
+    calculateUtilizationPercent(reserve) {
+        return this.calculateUtilizationRate(reserve).times(100);
+    }
+    /**
+     * @deprecated since version 1.0.8. Use `calculateBorrowAprPercent` instead.
+     */
+    calculateBorrowApr(reserve) {
+        const config = reserve.config.element;
+        const utilizationPercent = this.calculateUtilizationPercent(reserve);
+        let i = 1;
+        while (i < config.interestRateUtils.length) {
+            // Parsing logic from core/parsers/reserve.ts
+            const leftUtilPercent = new bignumber_js_1.default(config.interestRateUtils[i - 1]);
+            const rightUtilPercent = new bignumber_js_1.default(config.interestRateUtils[i]);
+            if (utilizationPercent.gte(leftUtilPercent) &&
+                utilizationPercent.lte(rightUtilPercent)) {
+                const leftAprPercent = new bignumber_js_1.default(config.interestRateAprs[i - 1].toString()).div(100);
+                const rightAprPercent = new bignumber_js_1.default(config.interestRateAprs[i].toString()).div(100);
+                const weight = new bignumber_js_1.default(utilizationPercent.minus(leftUtilPercent)).div(rightUtilPercent.minus(leftUtilPercent));
+                return leftAprPercent.plus(weight.times(rightAprPercent.minus(leftAprPercent)));
+            }
+            i = i + 1;
+        }
+        // Should never reach here
+        return new bignumber_js_1.default(0);
+    }
+    calculateBorrowAprPercent(reserve) {
+        return this.calculateBorrowApr(reserve);
+    }
+    /**
+     * @deprecated since version 1.0.8. Use `calculateDepositAprPercent` instead.
+     */
+    calculateSupplyApr(reserve) {
+        const config = reserve.config.element;
+        const utilizationPercent = this.calculateUtilizationPercent(reserve);
+        const borrowAprPercent = this.calculateBorrowAprPercent(reserve);
+        return new bignumber_js_1.default(utilizationPercent.div(100))
+            .times(borrowAprPercent.div(100))
+            .times(1 - +config.spreadFeeBps.toString() / 10000)
+            .times(100);
+    }
+    calculateDepositAprPercent(reserve) {
+        return this.calculateSupplyApr(reserve);
+    }
+    compoundReserveInterest(reserve, now) {
+        var _a, _b;
+        const timeElapsedSeconds = now - Number(reserve.interestLastUpdateTimestampS);
+        if (timeElapsedSeconds === 0) {
+            return reserve;
+        }
+        bignumber_js_1.default.config({ POW_PRECISION: 100 });
+        const compoundedBorrowRate = new bignumber_js_1.default(1)
+            .plus(this.calculateBorrowAprPercent(reserve)
+            .div(100)
+            .div(365 * 24 * 60 * 60))
+            .pow(new bignumber_js_1.default(timeElapsedSeconds).toNumber());
+        const updatedReserve = Object.assign({}, reserve);
+        const oldBorrowedAmount = this.decimalToBigNumber(reserve.borrowedAmount);
+        const oldCumulativeBorrowRate = this.decimalToBigNumber(reserve.cumulativeBorrowRate);
+        const oldUnclaimedSpreadFees = this.decimalToBigNumber(reserve.unclaimedSpreadFees);
+        updatedReserve.cumulativeBorrowRate = this.stringToDecimal(compoundedBorrowRate.multipliedBy(oldCumulativeBorrowRate).toString());
+        const netNewDebt = oldBorrowedAmount.multipliedBy(compoundedBorrowRate.minus(1));
+        const spreadFee = new bignumber_js_1.default(((_b = (_a = reserve.config.element) === null || _a === void 0 ? void 0 : _a.spreadFeeBps) === null || _b === void 0 ? void 0 : _b.toString()) || 0);
+        updatedReserve.unclaimedSpreadFees = this.stringToDecimal(oldUnclaimedSpreadFees
+            .plus(netNewDebt.multipliedBy(spreadFee.dividedBy(10000)))
+            .toString());
+        updatedReserve.borrowedAmount = this.stringToDecimal(oldBorrowedAmount.plus(netNewDebt).toString());
+        updatedReserve.interestLastUpdateTimestampS = BigInt(now);
+        updatedReserve.depositsPoolRewardManager = this.updatePoolRewardsManager(updatedReserve.depositsPoolRewardManager, now * 1000);
+        updatedReserve.borrowsPoolRewardManager = this.updatePoolRewardsManager(updatedReserve.borrowsPoolRewardManager, now * 1000);
+        return updatedReserve;
+    }
+    updatePoolRewardsManager(manager, nowMs) {
+        const updatedManager = Object.assign({}, manager);
+        const timeElapsedMs = nowMs - Number(manager.lastUpdateTimeMs);
+        if (manager.totalShares === BigInt(0) || timeElapsedMs === 0) {
+            return updatedManager;
+        }
+        updatedManager.poolRewards = updatedManager.poolRewards.map((poolReward) => {
+            if (poolReward === null) {
+                return poolReward;
+            }
+            if (nowMs < poolReward.startTimeMs ||
+                manager.lastUpdateTimeMs >= poolReward.endTimeMs) {
+                return poolReward;
+            }
+            const updatedPoolReward = Object.assign({}, poolReward);
+            const endTimeMs = Number(poolReward.endTimeMs);
+            const startTimeMs = Number(poolReward.startTimeMs);
+            const lastUpdateTimeMs = Number(manager.lastUpdateTimeMs);
+            const timePassedMs = Math.min(nowMs, endTimeMs) - Math.max(startTimeMs, lastUpdateTimeMs);
+            const unlockedRewards = new bignumber_js_1.default(poolReward.totalRewards.toString())
+                .multipliedBy(timePassedMs)
+                .dividedBy(Number(poolReward.endTimeMs - poolReward.startTimeMs));
+            updatedPoolReward.allocatedRewards = this.stringToDecimal(this.decimalToBigNumber(poolReward.allocatedRewards)
+                .plus(unlockedRewards)
+                .toString());
+            updatedPoolReward.cumulativeRewardsPerShare = this.stringToDecimal(this.decimalToBigNumber(poolReward.cumulativeRewardsPerShare)
+                .plus(unlockedRewards.dividedBy(Number(manager.totalShares)))
+                .toString());
+            return updatedPoolReward;
+        });
+        updatedManager.lastUpdateTimeMs = BigInt(nowMs);
+        return updatedManager;
+    }
+    refreshReservePrice(reserves, pythConnection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const priceIdentifiers = reserves.map((r) => (0, utils_1.toHEX)(new Uint8Array(r.priceIdentifier.bytes)));
+            const priceData = yield pythConnection.getLatestPriceFeeds(priceIdentifiers);
+            if (!priceData)
+                return reserves;
+            const updatedReserves = [];
+            for (let i = 0; i < reserves.length; i++) {
+                const newReserve = Object.assign({}, reserves[i]);
+                newReserve.price = this.stringToDecimal(priceData[i].getPriceUnchecked().getPriceAsNumberUnchecked().toString());
+                newReserve.smoothedPrice = this.stringToDecimal(priceData[i]
+                    .getEmaPriceUnchecked()
+                    .getPriceAsNumberUnchecked()
+                    .toString());
+                newReserve.priceLastUpdateTimestampS = BigInt(priceData[i].getPriceUnchecked().publishTime);
+                updatedReserves.push(newReserve);
+            }
+            return updatedReserves;
+        });
+    }
+    updateUserRewardManager(poolManager, userRewardManager, now) {
+        const updatedUserRewardManager = Object.assign({}, userRewardManager);
+        for (let i = 0; i < poolManager.poolRewards.length; i++) {
+            const poolReward = poolManager.poolRewards[i];
+            if (poolReward == null) {
+                continue;
+            }
+            if (i >= userRewardManager.rewards.length) {
+                userRewardManager.rewards.push(null);
+            }
+            const oldReward = updatedUserRewardManager.rewards[i];
+            const reward = Object.assign({}, oldReward);
+            if (oldReward != null) {
+                const newRewards = this.decimalToBigNumber(poolReward.cumulativeRewardsPerShare)
+                    .minus(this.decimalToBigNumber(oldReward.cumulativeRewardsPerShare))
+                    .multipliedBy(new bignumber_js_1.default(Number(userRewardManager.share)));
+                reward.earnedRewards = this.stringToDecimal(this.decimalToBigNumber(oldReward.earnedRewards)
+                    .plus(newRewards)
+                    .toString());
+                reward.cumulativeRewardsPerShare = poolReward.cumulativeRewardsPerShare;
+                updatedUserRewardManager.rewards[i] = reward;
+            }
+            else {
+                if (userRewardManager.lastUpdateTimeMs <= poolReward.endTimeMs) {
+                    updatedUserRewardManager.rewards[i] = this.UserReward.fromFields({
+                        pool_reward_id: { bytes: poolReward.id.slice(2) },
+                        earned_rewards: this.stringToDecimal((userRewardManager.lastUpdateTimeMs <= poolReward.startTimeMs
+                            ? this.decimalToBigNumber(poolReward.cumulativeRewardsPerShare).multipliedBy(new bignumber_js_1.default(Number(userRewardManager.share)))
+                            : new bignumber_js_1.default(0)).toString()),
+                        cumulative_rewards_per_share: poolReward.cumulativeRewardsPerShare,
+                    });
+                }
+            }
+        }
+        updatedUserRewardManager.lastUpdateTimeMs = BigInt(now);
+        return updatedUserRewardManager;
+    }
+    refreshObligation(unrefreshedObligation, refreshedReserves) {
+        const obligation = Object.assign({}, unrefreshedObligation);
+        // Refresh Deposits
+        let depositValueUsd = new bignumber_js_1.default(0);
+        let allowedBorrowValueUsd = new bignumber_js_1.default(0);
+        let unhealthyBorrowValueUsd = new bignumber_js_1.default(0);
+        for (let i = 0; i < obligation.deposits.length; i++) {
+            const deposit = Object.assign({}, obligation.deposits[i]);
+            const reserve = refreshedReserves.find((r) => r.coinType.name === deposit.coinType.name);
+            if (!reserve) {
+                throw new Error(`Unable to find reserve for coin type ${deposit.coinType.name}`);
+            }
+            const config = reserve.config.element;
+            obligation.userRewardManagers[deposit.userRewardManagerIndex] = this.updateUserRewardManager(reserve.depositsPoolRewardManager, obligation.userRewardManagers[deposit.userRewardManagerIndex], Date.now());
+            const marketValue = this.getCTokenMarketValue(reserve, new bignumber_js_1.default(deposit.depositedCtokenAmount.toString()));
+            const marketValueLowerBound = this.getCTokenMarketValueLowerBound(reserve, new bignumber_js_1.default(deposit.depositedCtokenAmount.toString()));
+            deposit.marketValue = this.stringToDecimal(marketValue.toString());
+            depositValueUsd = depositValueUsd.plus(new bignumber_js_1.default(marketValue.toString()));
+            allowedBorrowValueUsd = allowedBorrowValueUsd.plus(marketValueLowerBound.multipliedBy(new bignumber_js_1.default(config.openLtvPct / 100)));
+            unhealthyBorrowValueUsd = unhealthyBorrowValueUsd.plus(marketValue.multipliedBy(new bignumber_js_1.default(config.closeLtvPct / 100)));
+            obligation.deposits[i] = deposit;
+        }
+        obligation.unhealthyBorrowValueUsd = this.stringToDecimal(unhealthyBorrowValueUsd.toString());
+        obligation.allowedBorrowValueUsd = this.stringToDecimal(allowedBorrowValueUsd.toString());
+        obligation.depositedValueUsd = this.stringToDecimal(depositValueUsd.toString());
+        // Refresh borrows
+        let unweightedBorrowedValueUsd = new bignumber_js_1.default(0);
+        let weightedBorrowedValueUsd = new bignumber_js_1.default(0);
+        let weightedBorrowedValueUpperBoundUsd = new bignumber_js_1.default(0);
+        for (let i = 0; i < obligation.borrows.length; i++) {
+            const unrefreshedBorrow = obligation.borrows[i];
+            const reserve = refreshedReserves.find((r) => r.coinType.name == unrefreshedBorrow.coinType.name);
+            if (!reserve) {
+                throw new Error(`Unable to find reserve for coin type ${unrefreshedBorrow.coinType.name}`);
+            }
+            const config = reserve.config.element;
+            const borrow = Object.assign({}, this.compoundDebt(unrefreshedBorrow, reserve));
+            obligation.userRewardManagers[borrow.userRewardManagerIndex] = this.updateUserRewardManager(reserve.borrowsPoolRewardManager, obligation.userRewardManagers[borrow.userRewardManagerIndex], Date.now());
+            const marketValue = this.decimalToBigNumber(borrow.borrowedAmount)
+                .multipliedBy(this.decimalToBigNumber(reserve.price))
+                .dividedBy(new bignumber_js_1.default(10 ** reserve.mintDecimals));
+            const upperBoundPrice = bignumber_js_1.default.max(this.decimalToBigNumber(reserve.price), this.decimalToBigNumber(reserve.smoothedPrice));
+            const marketValueUpperBound = this.decimalToBigNumber(reserve.borrowedAmount)
+                .multipliedBy(upperBoundPrice)
+                .dividedBy(new bignumber_js_1.default(10 ** reserve.mintDecimals));
+            borrow.marketValue = this.stringToDecimal(marketValue.toString());
+            unweightedBorrowedValueUsd = unweightedBorrowedValueUsd.plus(marketValue);
+            const borrowWeight = new bignumber_js_1.default((config.borrowWeightBps / BigInt(10000)).toString());
+            weightedBorrowedValueUsd = weightedBorrowedValueUsd.plus(marketValue.multipliedBy(borrowWeight));
+            weightedBorrowedValueUpperBoundUsd =
+                weightedBorrowedValueUpperBoundUsd.plus(marketValueUpperBound.multipliedBy(borrowWeight));
+        }
+        obligation.unweightedBorrowedValueUsd = this.stringToDecimal(unweightedBorrowedValueUsd.toString());
+        obligation.weightedBorrowedValueUpperBoundUsd = this.stringToDecimal(weightedBorrowedValueUpperBoundUsd.toString());
+        obligation.weightedBorrowedValueUsd = this.stringToDecimal(weightedBorrowedValueUsd.toString());
+        return obligation;
+    }
+    numberToDecimal(value) {
+        const adjustedValue = Math.round(value * +constants_1.WAD);
+        return this.Decimal.fromBcs(bcs_1.bcs.u256().serialize(adjustedValue).toBytes());
+    }
+    stringToDecimal(value) {
+        return this.numberToDecimal(new bignumber_js_1.default(value).toNumber());
+    }
+    decimalToBigNumber(value) {
+        return new bignumber_js_1.default(value.value.toString()).div(constants_1.WAD);
+    }
+    getCTokenMarketValue(reserve, depositedCTokenAmount) {
+        const liquidityAmount = depositedCTokenAmount.multipliedBy(this.cTokenRatio(reserve));
+        return this.decimalToBigNumber(reserve.price)
+            .multipliedBy(liquidityAmount)
+            .dividedBy(new bignumber_js_1.default(10 ** reserve.mintDecimals));
+    }
+    getCTokenMarketValueLowerBound(reserve, depositedCTokenAmount) {
+        const liquidityAmount = depositedCTokenAmount.multipliedBy(this.cTokenRatio(reserve));
+        const price = bignumber_js_1.default.min(this.decimalToBigNumber(reserve.price), this.decimalToBigNumber(reserve.smoothedPrice));
+        return price
+            .multipliedBy(liquidityAmount)
+            .dividedBy(new bignumber_js_1.default(10 ** reserve.mintDecimals));
+    }
+    cTokenRatio(reserve) {
+        if (reserve.ctokenSupply === BigInt(0)) {
+            return new bignumber_js_1.default(1);
+        }
+        return this.totalSupply(reserve).dividedBy(new bignumber_js_1.default(reserve.ctokenSupply.toString()));
+    }
+    totalSupply(reserve) {
+        return new bignumber_js_1.default(reserve.availableAmount.toString())
+            .plus(this.decimalToBigNumber(reserve.borrowedAmount))
+            .minus(this.decimalToBigNumber(reserve.unclaimedSpreadFees));
+    }
+    compoundDebt(borrow, reserve) {
+        const borrowCopy = Object.assign({}, borrow);
+        const newCumulativeBorrowRate = this.decimalToBigNumber(reserve.cumulativeBorrowRate);
+        const compoundedInterestRate = newCumulativeBorrowRate.dividedBy(this.decimalToBigNumber(borrow.cumulativeBorrowRate));
+        borrowCopy.borrowedAmount = this.stringToDecimal(this.decimalToBigNumber(borrow.borrowedAmount)
+            .multipliedBy(compoundedInterestRate)
+            .toString());
+        borrowCopy.cumulativeBorrowRate = this.stringToDecimal(newCumulativeBorrowRate.toString());
+        return borrowCopy;
+    }
+}
+exports.Simulate = Simulate;

package/core/utils/utils.d.ts

@@ -0,0 +1,61 @@
+import { SerializedBcs } from "@mysten/bcs";
+import { SharedObjectRef } from "@mysten/sui.js/bcs";
+import { SuiObjectRef } from "@mysten/sui.js/client";
+import { TransactionArgument, TransactionBlock, TransactionObjectArgument } from "@mysten/sui.js/transactions";
+/**
+ * These are the basics types that can be used in SUI
+ */
+export type SuiBasicTypes = "address" | "bool" | "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "signer";
+export type SuiAddressArg = TransactionArgument | SerializedBcs<any> | string;
+export type SuiTxArg = SuiAddressArg | number | bigint | boolean;
+export type SuiInputTypes = "object" | SuiBasicTypes;
+export type SuiObjectArg = TransactionObjectArgument | string | SharedObjectRef | SuiObjectRef;
+export type SuiVecTxArg = {
+    value: SuiTxArg[];
+    vecType: SuiInputTypes;
+} | SuiTxArg[];
+export declare function takeAmountFromCoins(txBlock: TransactionBlock, coins: SuiObjectArg[], amount: SuiTxArg): TransactionObjectArgument[];
+export declare function splitSUIFromGas(txBlock: TransactionBlock, amounts: SuiTxArg[]): import("@mysten/sui.js/transactions").TransactionResult;
+/**
+ * Convert any valid input into array of TransactionArgument.
+ *
+ * @param txb The Transaction Block
+ * @param args The array of argument to convert.
+ * @returns The converted array of TransactionArgument.
+ */
+export declare function convertArgs(txBlock: TransactionBlock, args: (SuiTxArg | SuiVecTxArg)[]): ({
+    index: number;
+    kind: "Input";
+    type: "pure";
+    value?: any;
+} | TransactionObjectArgument | SerializedBcs<unknown, unknown> | (SerializedBcs<any, any> & import("@mysten/sui.js/bcs").PureArg))[];
+/**
+ * Convert any valid object input into a TransactionArgument.
+ *
+ * @param txb The Transaction Block
+ * @param arg The object argument to convert.
+ * @returns The converted TransactionArgument.
+ */
+export declare function convertObjArg(txb: TransactionBlock, arg: SuiObjectArg): TransactionObjectArgument;
+/**
+ * Check whether it is an valid move vec input.
+ *
+ * @param arg The argument to check.
+ * @returns boolean.
+ */
+export declare function isMoveVecArg(arg: SuiTxArg | SuiVecTxArg): arg is SuiVecTxArg;
+export declare const getDefaultSuiInputType: (value: SuiTxArg) => SuiInputTypes | undefined;
+/**
+ * Since we know the elements in the array are the same type
+ * If type is not provided, we will try to infer the type from the first element
+ * By default,
+ *
+ * string is hex and its length equal to 32 =====> object id
+ * number, bigint ====> u64
+ * boolean =====> bool
+ *
+ * If type is provided, we will use the type to convert the array
+ * @param args
+ * @param type 'address' | 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256' | 'signer' | 'object' | string
+ */
+export declare function makeVecParam(txBlock: TransactionBlock, args: SuiTxArg[], type?: SuiInputTypes): TransactionArgument;