@suilend/sdk 1.0.7 → 1.0.9

package/core/utils/events.d.ts

@@ -0,0 +1,176 @@
+import { SuiClient, SuiEvent } from "@mysten/sui.js/client";
+type TypeName = {
+    name: string;
+};
+type Decimal = {
+    value: string;
+};
+type address = string;
+type u64 = string;
+export declare enum SuilendEventType {
+    InterestUpdateEvent = "InterestUpdateEvent",
+    ReserveAssetDataEvent = "ReserveAssetDataEvent",
+    MintEvent = "MintEvent",
+    RedeemEvent = "RedeemEvent",
+    DepositEvent = "DepositEvent",
+    WithdrawEvent = "WithdrawEvent",
+    BorrowEvent = "BorrowEvent",
+    RepayEvent = "RepayEvent",
+    LiquidateEvent = "LiquidateEvent",
+    ClaimRewardEvent = "ClaimRewardEvent",
+    ObligationDataEvent = "ObligationDataEvent"
+}
+export declare enum SuilendTransactionModule {
+    LendingMarket = "lending_market",
+    Reserve = "reserve"
+}
+declare class TypedParamsSuiEvent<T> {
+    event: SuiEvent;
+    constructor(event: SuiEvent);
+    params(): T;
+    isType(module: SuilendTransactionModule, eventType: SuilendEventType): boolean;
+}
+export declare class GenericSuilendEvent extends TypedParamsSuiEvent<{}> {
+}
+export declare class InterestUpdateEvent extends TypedParamsSuiEvent<{
+    lending_market_id: address;
+    coin_type: TypeName;
+    reserve_id: address;
+    cumulative_borrow_rate: Decimal;
+    available_amount: u64;
+    borrowed_amount: Decimal;
+    unclaimed_spread_fees: Decimal;
+    ctoken_supply: u64;
+    borrow_interest_paid: Decimal;
+    spread_fee: Decimal;
+    supply_interest_earned: Decimal;
+    borrow_interest_paid_usd_estimate: Decimal;
+    protocol_fee_usd_estimate: Decimal;
+    supply_interest_earned_usd_estimate: Decimal;
+}> {
+}
+export declare class ReserveAssetDataEvent extends TypedParamsSuiEvent<{
+    lending_market_id: address;
+    coin_type: TypeName;
+    reserve_id: address;
+    available_amount: Decimal;
+    supply_amount: Decimal;
+    borrowed_amount: Decimal;
+    available_amount_usd_estimate: Decimal;
+    supply_amount_usd_estimate: Decimal;
+    borrowed_amount_usd_estimate: Decimal;
+    borrow_apr: Decimal;
+    supply_apr: Decimal;
+    ctoken_supply: u64;
+    cumulative_borrow_rate: Decimal;
+    price: Decimal;
+    smoothed_price: Decimal;
+    price_last_update_timestamp_s: u64;
+}> {
+}
+export declare class MintEvent extends TypedParamsSuiEvent<{
+    lending_market_id: address;
+    coin_type: TypeName;
+    reserve_id: address;
+    liquidity_amount: u64;
+    ctoken_amount: u64;
+}> {
+}
+export declare class RedeemEvent extends TypedParamsSuiEvent<{
+    lending_market_id: address;
+    coin_type: TypeName;
+    reserve_id: address;
+    ctoken_amount: u64;
+    liquidity_amount: u64;
+}> {
+}
+export declare class DepositEvent extends TypedParamsSuiEvent<{
+    lending_market_id: address;
+    coin_type: TypeName;
+    reserve_id: address;
+    obligation_id: address;
+    ctoken_amount: u64;
+}> {
+}
+export declare class WithdrawEvent extends TypedParamsSuiEvent<{
+    lending_market_id: address;
+    coin_type: TypeName;
+    reserve_id: address;
+    obligation_id: address;
+    ctoken_amount: u64;
+}> {
+}
+export declare class BorrowEvent extends TypedParamsSuiEvent<{
+    lending_market_id: address;
+    coin_type: TypeName;
+    reserve_id: address;
+    obligation_id: address;
+    liquidity_amount: u64;
+    origination_fee_amount: u64;
+}> {
+}
+export declare class RepayEvent extends TypedParamsSuiEvent<{
+    lending_market_id: address;
+    coin_type: TypeName;
+    reserve_id: address;
+    obligation_id: address;
+    liquidity_amount: u64;
+}> {
+}
+export declare class LiquidateEvent extends TypedParamsSuiEvent<{
+    lending_market_id: address;
+    repay_reserve_id: address;
+    withdraw_reserve_id: address;
+    obligation_id: address;
+    repay_coin_type: TypeName;
+    withdraw_coin_type: TypeName;
+    repay_amount: u64;
+    withdraw_amount: u64;
+    protocol_fee_amount: u64;
+    liquidator_bonus_amount: u64;
+}> {
+}
+export declare class ClaimRewardEvent extends TypedParamsSuiEvent<{
+    lending_market_id: address;
+    reserve_id: address;
+    obligation_id: address;
+    is_deposit_reward: boolean;
+    pool_reward_id: address;
+    coin_type: TypeName;
+    liquidity_amount: u64;
+}> {
+}
+export declare class ObligationDataEvent extends TypedParamsSuiEvent<{
+    lending_market_id: address;
+    obligation_id: address;
+    deposits: {
+        coin_type: TypeName;
+        reserve_array_index: u64;
+        deposited_ctoken_amount: u64;
+        market_value: Decimal;
+        user_reward_manager_index: u64;
+        attributed_borrow_value: Decimal;
+    }[];
+    borrows: {
+        coin_type: TypeName;
+        reserve_array_index: u64;
+        borrowed_amount: Decimal;
+        cumulative_borrow_rate: Decimal;
+        market_value: Decimal;
+        user_reward_manager_index: u64;
+    }[];
+    deposited_value_usd: Decimal;
+    allowed_borrow_value_usd: Decimal;
+    unhealthy_borrow_value_usd: Decimal;
+    super_unhealthy_borrow_value_usd: Decimal;
+    unweighted_borrowed_value_usd: Decimal;
+    weighted_borrowed_value_usd: Decimal;
+    weighted_borrowed_value_upper_bound_usd: Decimal;
+    borrowing_isolated_asset: boolean;
+    bad_debt_usd: Decimal;
+    closable: boolean;
+}> {
+}
+export declare function getEvents(client: SuiClient, digest: string): Promise<GenericSuilendEvent[]>;
+export declare function getRedeemEvent(client: SuiClient, digest: string): Promise<RedeemEvent | null>;
+export {};

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,312 @@
+"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 uuid_1 = require("uuid");
+const constants_1 = require("../constants");
+const utils_2 = require("../utils");
+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;
+        // From core/parsers/reserve.ts > parseReserve
+        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);
+        // From core/parsers/reserve.ts > parseReserveConfig
+        const interestRate = config.interestRateUtils.map((util, index) => ({
+            id: (0, uuid_1.v4)(),
+            utilPercent: new bignumber_js_1.default(util.toString()),
+            aprPercent: new bignumber_js_1.default(config.interestRateAprs[index].toString()).div(100),
+        }));
+        return (0, utils_2.linearlyInterpolate)(interestRate, "utilPercent", "aprPercent", utilizationPercent);
+    }
+    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);
+        // From core/parsers/reserve.ts > parseReserveConfig
+        const spreadFeeBps = Number(config.spreadFeeBps.toString());
+        return new bignumber_js_1.default(utilizationPercent.div(100))
+            .times(borrowAprPercent.div(100))
+            .times(1 - spreadFeeBps / 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;