@suilend/sdk 1.0.0

package/mainnet/utils/obligation.js

@@ -0,0 +1,299 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.getObligationHistoryPage = exports.fetchAllObligationsForMarket = exports.fetchAllObligationsForMarketWithHandler = void 0;
+const utils_1 = require("@mysten/sui.js/utils");
+const p_limit_1 = __importDefault(require("p-limit"));
+const reified_1 = require("../_generated/_framework/reified");
+const suilend_1 = require("../_generated/suilend");
+const structs_1 = require("../_generated/suilend/obligation/structs");
+const client_1 = require("../client");
+const parsed = __importStar(require("./events"));
+function fetchAllObligationsForMarketWithHandler(client, marketAddress, chunkHandler) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const limit = (0, p_limit_1.default)(30);
+        const rawLendingMarket = yield client.getObject({
+            id: marketAddress,
+            options: {
+                showType: true,
+                showContent: true,
+                showOwner: true,
+                showBcs: true,
+            },
+        });
+        const obligationField = ((_a = rawLendingMarket.data) === null || _a === void 0 ? void 0 : _a.content).fields
+            .obligations;
+        const obligationOwnerID = obligationField.fields.id.id;
+        let hasNextPage = true;
+        let cursor = null;
+        const promises = [];
+        while (hasNextPage) {
+            const response = yield client.getDynamicFields({
+                parentId: obligationOwnerID,
+                cursor: cursor,
+            });
+            hasNextPage = response.hasNextPage;
+            cursor = response.nextCursor;
+            promises.push(limit(() => __awaiter(this, void 0, void 0, function* () {
+                var _b;
+                const obligationObjects = yield chunkedMultiGet(client, response.data.map((x) => x.objectId));
+                const obligations = [];
+                for (const rawObligation of obligationObjects) {
+                    obligations.push(structs_1.Obligation.fromBcs((0, reified_1.phantom)(client_1.LENDING_MARKET_TYPE), (0, utils_1.fromB64)(((_b = rawObligation.data) === null || _b === void 0 ? void 0 : _b.bcs).bcsBytes)));
+                }
+                yield chunkHandler(obligations);
+            })));
+        }
+        yield Promise.all(promises);
+    });
+}
+exports.fetchAllObligationsForMarketWithHandler = fetchAllObligationsForMarketWithHandler;
+function fetchAllObligationsForMarket(client, marketAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const rawLendingMarket = yield client.getObject({
+            id: marketAddress,
+            options: {
+                showType: true,
+                showContent: true,
+                showOwner: true,
+                showBcs: true,
+            },
+        });
+        const obligationField = ((_a = rawLendingMarket.data) === null || _a === void 0 ? void 0 : _a.content).fields
+            .obligations;
+        const obligationOwnerID = obligationField.fields.id.id;
+        let hasNextPage = true;
+        let cursor = null;
+        let fields = [];
+        while (hasNextPage) {
+            const response = yield client.getDynamicFields({
+                parentId: obligationOwnerID,
+                cursor: cursor,
+            });
+            fields = fields.concat(response.data);
+            hasNextPage = response.hasNextPage;
+            cursor = response.nextCursor;
+        }
+        const obligationObjects = yield chunkedMultiGet(client, fields.map((x) => x.objectId));
+        const obligations = [];
+        for (const rawObligation of obligationObjects) {
+            obligations.push(structs_1.Obligation.fromBcs((0, reified_1.phantom)(client_1.LENDING_MARKET_TYPE), (0, utils_1.fromB64)(((_b = rawObligation.data) === null || _b === void 0 ? void 0 : _b.bcs).bcsBytes)));
+        }
+        return obligations;
+    });
+}
+exports.fetchAllObligationsForMarket = fetchAllObligationsForMarket;
+function chunkedMultiGet(client, objectIds) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const limit = (0, p_limit_1.default)(30);
+        const results = [];
+        const chunks = splitIntoChunks(objectIds, 50);
+        const promises = [];
+        for (const chunk of chunks) {
+            promises.push(limit(() => client.multiGetObjects({
+                ids: chunk,
+                options: {
+                    showType: true,
+                    showContent: true,
+                    showOwner: true,
+                    showBcs: true,
+                },
+            })));
+        }
+        for (const chunk of yield Promise.all(promises)) {
+            for (const result of chunk) {
+                results.push(result);
+            }
+        }
+        return results;
+    });
+}
+function splitIntoChunks(arr, chunkSize) {
+    const result = [];
+    for (let i = 0; i < arr.length; i += chunkSize) {
+        const chunk = arr.slice(i, i + chunkSize);
+        result.push(chunk);
+    }
+    return result;
+}
+function getObligationHistoryPage(client, obligationId, maxQuantity, cursor) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (maxQuantity > 50 || maxQuantity < 1) {
+            throw Error("maxQuantity must be between 1 and 50");
+        }
+        const payload = yield client.queryTransactionBlocks({
+            cursor: cursor,
+            limit: maxQuantity,
+            order: "descending",
+            filter: {
+                ChangedObject: obligationId,
+            },
+            options: {
+                showEffects: true,
+                showEvents: true,
+            },
+        });
+        let formattedEvents = [];
+        for (const data of payload.data) {
+            const events = ((_a = data.events) === null || _a === void 0 ? void 0 : _a.filter((e) => e.packageId === suilend_1.PACKAGE_ID)) || [];
+            formattedEvents = formattedEvents.concat(formatEventsToHistory(obligationId, data, events));
+        }
+        if (payload.hasNextPage) {
+            return {
+                cursor: payload.nextCursor,
+                history: formattedEvents,
+            };
+        }
+        return {
+            cursor: null,
+            history: formattedEvents,
+        };
+    });
+}
+exports.getObligationHistoryPage = getObligationHistoryPage;
+function formatEventsToHistory(obligationId, data, events) {
+    const formattedEvents = [];
+    for (const [, event] of events.entries()) {
+        const eventComponents = event.type.split("::");
+        const eventType = eventComponents[eventComponents.length - 1];
+        if (eventType === "DepositEvent") {
+            const deposit = new parsed.DepositEvent(event);
+            if (deposit.params().obligation_id !== obligationId) {
+                continue;
+            }
+            // Find the corresponding mint event
+            const matchingEvent = events.find((e) => {
+                return (e.type.includes("MintEvent") &&
+                    new parsed.MintEvent(e).params().ctoken_amount ===
+                        deposit.params().ctoken_amount);
+            });
+            if (!matchingEvent) {
+                // TODO: Handle case with solo Mint or solo Deposit
+                continue;
+            }
+            const mint = new parsed.MintEvent(matchingEvent);
+            formattedEvents.push({
+                reserveId: deposit.params().reserve_id,
+                quantity: parseInt(mint.params().liquidity_amount),
+                action: "Deposit",
+                timestampMs: parseInt(data.timestampMs, 10),
+                digest: data.digest,
+            });
+        }
+        else if (eventType === "WithdrawEvent") {
+            const withdraw = new parsed.WithdrawEvent(event);
+            if (withdraw.params().obligation_id !== obligationId) {
+                continue;
+            }
+            // Find the corresponding mint event
+            const matchingEvent = events.find((e) => {
+                return (e.type.includes("RedeemEvent") &&
+                    new parsed.RedeemEvent(e).params().ctoken_amount ===
+                        withdraw.params().ctoken_amount);
+            });
+            if (!matchingEvent) {
+                continue;
+            }
+            const redeem = new parsed.RedeemEvent(matchingEvent);
+            formattedEvents.push({
+                reserveId: redeem.params().reserve_id,
+                quantity: parseInt(redeem.params().liquidity_amount),
+                action: "Withdraw",
+                timestampMs: parseInt(data.timestampMs, 10),
+                digest: data.digest,
+            });
+        }
+        else if (eventType === "BorrowEvent") {
+            const borrow = new parsed.BorrowEvent(event);
+            if (borrow.params().obligation_id !== obligationId) {
+                continue;
+            }
+            formattedEvents.push({
+                reserveId: borrow.params().reserve_id,
+                quantity: parseInt(borrow.params().liquidity_amount),
+                action: "Borrow",
+                timestampMs: parseInt(data.timestampMs, 10),
+                digest: data.digest,
+            });
+        }
+        else if (eventType === "RepayEvent") {
+            const repay = new parsed.RepayEvent(event);
+            if (repay.params().obligation_id !== obligationId) {
+                continue;
+            }
+            formattedEvents.push({
+                reserveId: repay.params().reserve_id,
+                quantity: parseInt(repay.params().liquidity_amount),
+                action: "Repay",
+                timestampMs: parseInt(data.timestampMs, 10),
+                digest: data.digest,
+            });
+        }
+        else if (eventType === "LiquidateEvent") {
+            const liquidate = new parsed.LiquidateEvent(event);
+            if (liquidate.params().obligation_id !== obligationId) {
+                continue;
+            }
+            formattedEvents.push({
+                repayReserveId: liquidate.params().repay_reserve_id,
+                repayQuantity: parseInt(liquidate.params().repay_amount),
+                withdrawReserveId: liquidate.params().withdraw_reserve_id,
+                withdrawQuantity: parseInt(liquidate.params().withdraw_amount),
+                action: "Liquidation",
+                timestampMs: parseInt(data.timestampMs, 10),
+                digest: data.digest,
+            });
+        }
+        else if (eventType === "ClaimRewardEvent") {
+            const claimReward = new parsed.ClaimRewardEvent(event);
+            if (claimReward.params().obligation_id !== obligationId) {
+                continue;
+            }
+            formattedEvents.push({
+                reserveId: claimReward.params().reserve_id,
+                quantity: parseInt(claimReward.params().liquidity_amount),
+                action: "Claim Reward",
+                timestampMs: parseInt(data.timestampMs, 10),
+                digest: data.digest,
+            });
+        }
+    }
+    return formattedEvents;
+}

package/mainnet/utils/simulate.d.ts

@@ -0,0 +1,18 @@
+import BigNumber from "bignumber.js";
+import { SuiPriceServiceConnection } from "../../pyth-sdk";
+import { Decimal } from "../_generated/suilend/decimal/structs";
+import { PoolRewardManager } from "../_generated/suilend/liquidity-mining/structs";
+import { Obligation } from "../_generated/suilend/obligation/structs";
+import { Reserve } from "../_generated/suilend/reserve/structs";
+export declare function calculateUtilizationRate(reserve: Reserve<string>): BigNumber;
+export declare function calculateBorrowApr(reserve: Reserve<string>): BigNumber;
+export declare function calculateSupplyApr(reserve: Reserve<string>): BigNumber;
+export declare function compoundReserveInterest(reserve: Reserve<string>, now: number): Reserve<string>;
+export declare function updatePoolRewardsManager(manager: PoolRewardManager, nowMs: number): PoolRewardManager;
+export declare function refreshReservePrice(reserves: Reserve<string>[], pythConnection: SuiPriceServiceConnection): Promise<Reserve<string>[]>;
+export declare function refreshObligation(unrefreshedObligation: Obligation<string>, refreshedReserves: Reserve<string>[]): Obligation<string>;
+export declare function numberToDecimal(value: number): Decimal;
+export declare function stringToDecimal(value: string): Decimal;
+export declare function decimalToBigNumber(value: Decimal): BigNumber;
+export declare function cTokenRatio(reserve: Reserve<string>): BigNumber;
+export declare function totalSupply(reserve: Reserve<string>): BigNumber;

package/mainnet/utils/simulate.js

@@ -0,0 +1,284 @@
+"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.totalSupply = exports.cTokenRatio = exports.decimalToBigNumber = exports.stringToDecimal = exports.numberToDecimal = exports.refreshObligation = exports.refreshReservePrice = exports.updatePoolRewardsManager = exports.compoundReserveInterest = exports.calculateSupplyApr = exports.calculateBorrowApr = exports.calculateUtilizationRate = 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 structs_1 = require("../_generated/suilend/decimal/structs");
+const structs_2 = require("../_generated/suilend/liquidity-mining/structs");
+function calculateUtilizationRate(reserve) {
+    // Units are decimal
+    const totalSupplyExcludingFees = new bignumber_js_1.default(reserve.availableAmount.toString()).plus(decimalToBigNumber(reserve.borrowedAmount));
+    if (totalSupplyExcludingFees.eq(new bignumber_js_1.default(0))) {
+        return new bignumber_js_1.default(0);
+    }
+    return decimalToBigNumber(reserve.borrowedAmount).dividedBy(totalSupplyExcludingFees);
+}
+exports.calculateUtilizationRate = calculateUtilizationRate;
+function calculateBorrowApr(reserve) {
+    const config = reserve.config.element;
+    const length = config.interestRateUtils.length;
+    const currentUtil = calculateUtilizationRate(reserve).toNumber();
+    let i = 1;
+    while (i < length) {
+        const leftUtil = config.interestRateUtils[i - 1] / 100;
+        const rightUtil = config.interestRateUtils[i] / 100;
+        if (currentUtil >= leftUtil && currentUtil <= rightUtil) {
+            const leftAPR = config.interestRateAprs[i - 1];
+            const rightAPR = config.interestRateAprs[i];
+            const weight = (currentUtil - leftUtil) / (rightUtil - leftUtil);
+            const aprDiff = rightAPR - leftAPR;
+            return new bignumber_js_1.default(new bignumber_js_1.default(leftAPR.toString())
+                .plus(new bignumber_js_1.default(weight).multipliedBy(new bignumber_js_1.default(aprDiff.toString())))
+                .toString()).dividedBy(new bignumber_js_1.default(100));
+        }
+        i = i + 1;
+    }
+    // Should never reach here
+    return new bignumber_js_1.default(0);
+}
+exports.calculateBorrowApr = calculateBorrowApr;
+function calculateSupplyApr(reserve) {
+    var _a, _b;
+    const borrowApr = calculateBorrowApr(reserve);
+    const currentUtil = calculateUtilizationRate(reserve);
+    const protocolTakePercentage = new bignumber_js_1.default(1).minus(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).dividedBy(10000));
+    return currentUtil.times(borrowApr).times(protocolTakePercentage);
+}
+exports.calculateSupplyApr = calculateSupplyApr;
+function 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(calculateBorrowApr(reserve).dividedBy(new bignumber_js_1.default(100 * 365 * 24 * 60 * 60)))
+        .pow(new bignumber_js_1.default(timeElapsedSeconds).toNumber());
+    const updatedReserve = Object.assign({}, reserve);
+    const oldBorrowedAmount = decimalToBigNumber(reserve.borrowedAmount);
+    const oldCumulativeBorrowRate = decimalToBigNumber(reserve.cumulativeBorrowRate);
+    const oldUnclaimedSpreadFees = decimalToBigNumber(reserve.unclaimedSpreadFees);
+    updatedReserve.cumulativeBorrowRate = 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 = stringToDecimal(oldUnclaimedSpreadFees
+        .plus(netNewDebt.multipliedBy(spreadFee.dividedBy(10000)))
+        .toString());
+    updatedReserve.borrowedAmount = stringToDecimal(oldBorrowedAmount.plus(netNewDebt).toString());
+    updatedReserve.interestLastUpdateTimestampS = BigInt(now);
+    updatedReserve.depositsPoolRewardManager = updatePoolRewardsManager(updatedReserve.depositsPoolRewardManager, now * 1000);
+    updatedReserve.borrowsPoolRewardManager = updatePoolRewardsManager(updatedReserve.borrowsPoolRewardManager, now * 1000);
+    return updatedReserve;
+}
+exports.compoundReserveInterest = compoundReserveInterest;
+function 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 = stringToDecimal(decimalToBigNumber(poolReward.allocatedRewards)
+            .plus(unlockedRewards)
+            .toString());
+        updatedPoolReward.cumulativeRewardsPerShare = stringToDecimal(decimalToBigNumber(poolReward.cumulativeRewardsPerShare)
+            .plus(unlockedRewards.dividedBy(Number(manager.totalShares)))
+            .toString());
+        return updatedPoolReward;
+    });
+    updatedManager.lastUpdateTimeMs = BigInt(nowMs);
+    return updatedManager;
+}
+exports.updatePoolRewardsManager = updatePoolRewardsManager;
+function 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 = stringToDecimal(priceData[i].getPriceUnchecked().getPriceAsNumberUnchecked().toString());
+            newReserve.smoothedPrice = stringToDecimal(priceData[i]
+                .getEmaPriceUnchecked()
+                .getPriceAsNumberUnchecked()
+                .toString());
+            newReserve.priceLastUpdateTimestampS = BigInt(priceData[i].getPriceUnchecked().publishTime);
+            updatedReserves.push(newReserve);
+        }
+        return updatedReserves;
+    });
+}
+exports.refreshReservePrice = refreshReservePrice;
+function 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 = decimalToBigNumber(poolReward.cumulativeRewardsPerShare)
+                .minus(decimalToBigNumber(oldReward.cumulativeRewardsPerShare))
+                .multipliedBy(new bignumber_js_1.default(Number(userRewardManager.share)));
+            reward.earnedRewards = stringToDecimal(decimalToBigNumber(oldReward.earnedRewards).plus(newRewards).toString());
+            reward.cumulativeRewardsPerShare = poolReward.cumulativeRewardsPerShare;
+            updatedUserRewardManager.rewards[i] = reward;
+        }
+        else {
+            if (userRewardManager.lastUpdateTimeMs <= poolReward.endTimeMs) {
+                updatedUserRewardManager.rewards[i] = structs_2.UserReward.fromFields({
+                    pool_reward_id: { bytes: poolReward.id.slice(2) },
+                    earned_rewards: stringToDecimal((userRewardManager.lastUpdateTimeMs <= poolReward.startTimeMs
+                        ? 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;
+}
+function 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] = updateUserRewardManager(reserve.depositsPoolRewardManager, obligation.userRewardManagers[deposit.userRewardManagerIndex], Date.now());
+        const marketValue = getCTokenMarketValue(reserve, new bignumber_js_1.default(deposit.depositedCtokenAmount.toString()));
+        const marketValueLowerBound = getCTokenMarketValueLowerBound(reserve, new bignumber_js_1.default(deposit.depositedCtokenAmount.toString()));
+        deposit.marketValue = 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 = stringToDecimal(unhealthyBorrowValueUsd.toString());
+    obligation.allowedBorrowValueUsd = stringToDecimal(allowedBorrowValueUsd.toString());
+    obligation.depositedValueUsd = 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({}, compoundDebt(unrefreshedBorrow, reserve));
+        obligation.userRewardManagers[borrow.userRewardManagerIndex] = updateUserRewardManager(reserve.borrowsPoolRewardManager, obligation.userRewardManagers[borrow.userRewardManagerIndex], Date.now());
+        const marketValue = decimalToBigNumber(borrow.borrowedAmount)
+            .multipliedBy(decimalToBigNumber(reserve.price))
+            .dividedBy(new bignumber_js_1.default(10 ** reserve.mintDecimals));
+        const upperBoundPrice = bignumber_js_1.default.max(decimalToBigNumber(reserve.price), decimalToBigNumber(reserve.smoothedPrice));
+        const marketValueUpperBound = decimalToBigNumber(reserve.borrowedAmount)
+            .multipliedBy(upperBoundPrice)
+            .dividedBy(new bignumber_js_1.default(10 ** reserve.mintDecimals));
+        borrow.marketValue = 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 = stringToDecimal(unweightedBorrowedValueUsd.toString());
+    obligation.weightedBorrowedValueUpperBoundUsd = stringToDecimal(weightedBorrowedValueUpperBoundUsd.toString());
+    obligation.weightedBorrowedValueUsd = stringToDecimal(weightedBorrowedValueUsd.toString());
+    return obligation;
+}
+exports.refreshObligation = refreshObligation;
+function numberToDecimal(value) {
+    const adjustedValue = Math.round(value * 10 ** 18);
+    return structs_1.Decimal.fromBcs(bcs_1.bcs.u256().serialize(adjustedValue).toBytes());
+}
+exports.numberToDecimal = numberToDecimal;
+function stringToDecimal(value) {
+    return numberToDecimal(new bignumber_js_1.default(value).toNumber());
+}
+exports.stringToDecimal = stringToDecimal;
+function decimalToBigNumber(value) {
+    return new bignumber_js_1.default(value.value.toString()).dividedBy(new bignumber_js_1.default(10 ** 18));
+}
+exports.decimalToBigNumber = decimalToBigNumber;
+function getCTokenMarketValue(reserve, depositedCTokenAmount) {
+    const liquidityAmount = depositedCTokenAmount.multipliedBy(cTokenRatio(reserve));
+    return decimalToBigNumber(reserve.price)
+        .multipliedBy(liquidityAmount)
+        .dividedBy(new bignumber_js_1.default(10 ** reserve.mintDecimals));
+}
+function getCTokenMarketValueLowerBound(reserve, depositedCTokenAmount) {
+    const liquidityAmount = depositedCTokenAmount.multipliedBy(cTokenRatio(reserve));
+    const price = bignumber_js_1.default.min(decimalToBigNumber(reserve.price), decimalToBigNumber(reserve.smoothedPrice));
+    return price
+        .multipliedBy(liquidityAmount)
+        .dividedBy(new bignumber_js_1.default(10 ** reserve.mintDecimals));
+}
+function cTokenRatio(reserve) {
+    if (reserve.ctokenSupply === BigInt(0)) {
+        return new bignumber_js_1.default(1);
+    }
+    return totalSupply(reserve).dividedBy(new bignumber_js_1.default(reserve.ctokenSupply.toString()));
+}
+exports.cTokenRatio = cTokenRatio;
+function totalSupply(reserve) {
+    return new bignumber_js_1.default(reserve.availableAmount.toString())
+        .plus(decimalToBigNumber(reserve.borrowedAmount))
+        .minus(decimalToBigNumber(reserve.unclaimedSpreadFees));
+}
+exports.totalSupply = totalSupply;
+function compoundDebt(borrow, reserve) {
+    const borrowCopy = Object.assign({}, borrow);
+    const newCumulativeBorrowRate = decimalToBigNumber(reserve.cumulativeBorrowRate);
+    const compoundedInterestRate = newCumulativeBorrowRate.dividedBy(decimalToBigNumber(borrow.cumulativeBorrowRate));
+    borrowCopy.borrowedAmount = stringToDecimal(decimalToBigNumber(borrow.borrowedAmount)
+        .multipliedBy(compoundedInterestRate)
+        .toString());
+    borrowCopy.cumulativeBorrowRate = stringToDecimal(newCumulativeBorrowRate.toString());
+    return borrowCopy;
+}