@suilend/sdk 1.1.1 → 1.1.3

package/utils/simulate.js

@@ -0,0 +1,316 @@
+"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.compoundDebt = exports.totalSupply = exports.cTokenRatio = exports.getCTokenMarketValueLowerBound = exports.getCTokenMarketValue = exports.decimalToBigNumber = exports.stringToDecimal = exports.numberToDecimal = exports.refreshObligation = exports.updateUserRewardManager = exports.refreshReservePrice = exports.updatePoolRewardsManager = exports.compoundReserveInterest = exports.calculateDepositAprPercent = exports.calculateSupplyApr = exports.calculateBorrowAprPercent = exports.calculateBorrowApr = exports.calculateUtilizationPercent = exports.calculateUtilizationRate = void 0;
+const bcs_1 = require("@mysten/sui/bcs");
+const utils_1 = require("@mysten/sui/utils");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const uuid_1 = require("uuid");
+const structs_1 = require("../_generated/suilend/decimal/structs");
+const structs_2 = require("../_generated/suilend/liquidity-mining/structs");
+const constants_1 = require("../constants");
+const utils_2 = require("../utils");
+/**
+ * @deprecated since version 1.0.8. Use `calculateUtilizationPercent` instead.
+ */
+const calculateUtilizationRate = (reserve) => {
+    const { mintDecimals } = reserve;
+    // From 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);
+};
+exports.calculateUtilizationRate = calculateUtilizationRate;
+const calculateUtilizationPercent = (reserve) => {
+    return (0, exports.calculateUtilizationRate)(reserve).times(100);
+};
+exports.calculateUtilizationPercent = calculateUtilizationPercent;
+/**
+ * @deprecated since version 1.0.8. Use `calculateBorrowAprPercent` instead.
+ */
+const calculateBorrowApr = (reserve) => {
+    const config = reserve.config.element;
+    const utilizationPercent = (0, exports.calculateUtilizationPercent)(reserve);
+    // From 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);
+};
+exports.calculateBorrowApr = calculateBorrowApr;
+const calculateBorrowAprPercent = (reserve) => {
+    return (0, exports.calculateBorrowApr)(reserve);
+};
+exports.calculateBorrowAprPercent = calculateBorrowAprPercent;
+/**
+ * @deprecated since version 1.0.8. Use `calculateDepositAprPercent` instead.
+ */
+const calculateSupplyApr = (reserve) => {
+    const config = reserve.config.element;
+    const utilizationPercent = (0, exports.calculateUtilizationPercent)(reserve);
+    const borrowAprPercent = (0, exports.calculateBorrowAprPercent)(reserve);
+    // From 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);
+};
+exports.calculateSupplyApr = calculateSupplyApr;
+const calculateDepositAprPercent = (reserve) => {
+    return (0, exports.calculateSupplyApr)(reserve);
+};
+exports.calculateDepositAprPercent = calculateDepositAprPercent;
+const 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((0, exports.calculateBorrowAprPercent)(reserve)
+        .div(100)
+        .div(365 * 24 * 60 * 60))
+        .pow(new bignumber_js_1.default(timeElapsedSeconds).toNumber());
+    const updatedReserve = Object.assign({}, reserve);
+    const oldBorrowedAmount = (0, exports.decimalToBigNumber)(reserve.borrowedAmount);
+    const oldCumulativeBorrowRate = (0, exports.decimalToBigNumber)(reserve.cumulativeBorrowRate);
+    const oldUnclaimedSpreadFees = (0, exports.decimalToBigNumber)(reserve.unclaimedSpreadFees);
+    updatedReserve.cumulativeBorrowRate = (0, exports.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 = (0, exports.stringToDecimal)(oldUnclaimedSpreadFees
+        .plus(netNewDebt.multipliedBy(spreadFee.dividedBy(10000)))
+        .toString());
+    updatedReserve.borrowedAmount = (0, exports.stringToDecimal)(oldBorrowedAmount.plus(netNewDebt).toString());
+    updatedReserve.interestLastUpdateTimestampS = BigInt(now);
+    updatedReserve.depositsPoolRewardManager = (0, exports.updatePoolRewardsManager)(updatedReserve.depositsPoolRewardManager, now * 1000);
+    updatedReserve.borrowsPoolRewardManager = (0, exports.updatePoolRewardsManager)(updatedReserve.borrowsPoolRewardManager, now * 1000);
+    return updatedReserve;
+};
+exports.compoundReserveInterest = compoundReserveInterest;
+const 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 = (0, exports.stringToDecimal)((0, exports.decimalToBigNumber)(poolReward.allocatedRewards)
+            .plus(unlockedRewards)
+            .toString());
+        updatedPoolReward.cumulativeRewardsPerShare = (0, exports.stringToDecimal)((0, exports.decimalToBigNumber)(poolReward.cumulativeRewardsPerShare)
+            .plus(unlockedRewards.dividedBy(Number(manager.totalShares)))
+            .toString());
+        return updatedPoolReward;
+    });
+    updatedManager.lastUpdateTimeMs = BigInt(nowMs);
+    return updatedManager;
+};
+exports.updatePoolRewardsManager = updatePoolRewardsManager;
+const refreshReservePrice = (reserves, pythConnection) => __awaiter(void 0, 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 = (0, exports.stringToDecimal)(priceData[i].getPriceUnchecked().getPriceAsNumberUnchecked().toString());
+        newReserve.smoothedPrice = (0, exports.stringToDecimal)(priceData[i]
+            .getEmaPriceUnchecked()
+            .getPriceAsNumberUnchecked()
+            .toString());
+        newReserve.priceLastUpdateTimestampS = BigInt(priceData[i].getPriceUnchecked().publishTime);
+        updatedReserves.push(newReserve);
+    }
+    return updatedReserves;
+});
+exports.refreshReservePrice = refreshReservePrice;
+const 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 = (0, exports.decimalToBigNumber)(poolReward.cumulativeRewardsPerShare)
+                .minus((0, exports.decimalToBigNumber)(oldReward.cumulativeRewardsPerShare))
+                .multipliedBy(new bignumber_js_1.default(Number(userRewardManager.share)));
+            reward.earnedRewards = (0, exports.stringToDecimal)((0, exports.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: (0, exports.stringToDecimal)((userRewardManager.lastUpdateTimeMs <= poolReward.startTimeMs
+                        ? (0, exports.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;
+};
+exports.updateUserRewardManager = updateUserRewardManager;
+const 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[Number(deposit.userRewardManagerIndex)] =
+            (0, exports.updateUserRewardManager)(reserve.depositsPoolRewardManager, obligation.userRewardManagers[Number(deposit.userRewardManagerIndex)], Date.now());
+        const marketValue = (0, exports.getCTokenMarketValue)(reserve, new bignumber_js_1.default(deposit.depositedCtokenAmount.toString()));
+        const marketValueLowerBound = (0, exports.getCTokenMarketValueLowerBound)(reserve, new bignumber_js_1.default(deposit.depositedCtokenAmount.toString()));
+        deposit.marketValue = (0, exports.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 = (0, exports.stringToDecimal)(unhealthyBorrowValueUsd.toString());
+    obligation.allowedBorrowValueUsd = (0, exports.stringToDecimal)(allowedBorrowValueUsd.toString());
+    obligation.depositedValueUsd = (0, exports.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({}, (0, exports.compoundDebt)(unrefreshedBorrow, reserve));
+        obligation.userRewardManagers[Number(borrow.userRewardManagerIndex)] =
+            (0, exports.updateUserRewardManager)(reserve.borrowsPoolRewardManager, obligation.userRewardManagers[Number(borrow.userRewardManagerIndex)], Date.now());
+        const marketValue = (0, exports.decimalToBigNumber)(borrow.borrowedAmount)
+            .multipliedBy((0, exports.decimalToBigNumber)(reserve.price))
+            .dividedBy(new bignumber_js_1.default(10 ** reserve.mintDecimals));
+        const upperBoundPrice = bignumber_js_1.default.max((0, exports.decimalToBigNumber)(reserve.price), (0, exports.decimalToBigNumber)(reserve.smoothedPrice));
+        const marketValueUpperBound = (0, exports.decimalToBigNumber)(reserve.borrowedAmount)
+            .multipliedBy(upperBoundPrice)
+            .dividedBy(new bignumber_js_1.default(10 ** reserve.mintDecimals));
+        borrow.marketValue = (0, exports.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 = (0, exports.stringToDecimal)(unweightedBorrowedValueUsd.toString());
+    obligation.weightedBorrowedValueUpperBoundUsd = (0, exports.stringToDecimal)(weightedBorrowedValueUpperBoundUsd.toString());
+    obligation.weightedBorrowedValueUsd = (0, exports.stringToDecimal)(weightedBorrowedValueUsd.toString());
+    return obligation;
+};
+exports.refreshObligation = refreshObligation;
+const numberToDecimal = (value) => {
+    const adjustedValue = Math.round(value * +constants_1.WAD);
+    return structs_1.Decimal.fromBcs(bcs_1.bcs.u256().serialize(adjustedValue).toBytes());
+};
+exports.numberToDecimal = numberToDecimal;
+const stringToDecimal = (value) => {
+    return (0, exports.numberToDecimal)(new bignumber_js_1.default(value).toNumber());
+};
+exports.stringToDecimal = stringToDecimal;
+const decimalToBigNumber = (value) => {
+    return new bignumber_js_1.default(value.value.toString()).div(constants_1.WAD);
+};
+exports.decimalToBigNumber = decimalToBigNumber;
+const getCTokenMarketValue = (reserve, depositedCTokenAmount) => {
+    const liquidityAmount = depositedCTokenAmount.multipliedBy((0, exports.cTokenRatio)(reserve));
+    return (0, exports.decimalToBigNumber)(reserve.price)
+        .multipliedBy(liquidityAmount)
+        .dividedBy(new bignumber_js_1.default(10 ** reserve.mintDecimals));
+};
+exports.getCTokenMarketValue = getCTokenMarketValue;
+const getCTokenMarketValueLowerBound = (reserve, depositedCTokenAmount) => {
+    const liquidityAmount = depositedCTokenAmount.multipliedBy((0, exports.cTokenRatio)(reserve));
+    const price = bignumber_js_1.default.min((0, exports.decimalToBigNumber)(reserve.price), (0, exports.decimalToBigNumber)(reserve.smoothedPrice));
+    return price
+        .multipliedBy(liquidityAmount)
+        .dividedBy(new bignumber_js_1.default(10 ** reserve.mintDecimals));
+};
+exports.getCTokenMarketValueLowerBound = getCTokenMarketValueLowerBound;
+const cTokenRatio = (reserve) => {
+    if (reserve.ctokenSupply === BigInt(0)) {
+        return new bignumber_js_1.default(1);
+    }
+    return (0, exports.totalSupply)(reserve).dividedBy(new bignumber_js_1.default(reserve.ctokenSupply.toString()));
+};
+exports.cTokenRatio = cTokenRatio;
+const totalSupply = (reserve) => {
+    return new bignumber_js_1.default(reserve.availableAmount.toString())
+        .plus((0, exports.decimalToBigNumber)(reserve.borrowedAmount))
+        .minus((0, exports.decimalToBigNumber)(reserve.unclaimedSpreadFees));
+};
+exports.totalSupply = totalSupply;
+const compoundDebt = (borrow, reserve) => {
+    const borrowCopy = Object.assign({}, borrow);
+    const newCumulativeBorrowRate = (0, exports.decimalToBigNumber)(reserve.cumulativeBorrowRate);
+    const compoundedInterestRate = newCumulativeBorrowRate.dividedBy((0, exports.decimalToBigNumber)(borrow.cumulativeBorrowRate));
+    borrowCopy.borrowedAmount = (0, exports.stringToDecimal)((0, exports.decimalToBigNumber)(borrow.borrowedAmount)
+        .multipliedBy(compoundedInterestRate)
+        .toString());
+    borrowCopy.cumulativeBorrowRate = (0, exports.stringToDecimal)(newCumulativeBorrowRate.toString());
+    return borrowCopy;
+};
+exports.compoundDebt = compoundDebt;

package/core/client.d.ts

@@ -1,114 +0,0 @@
-import { SuiClient } from "@mysten/sui/client";
-import { Transaction, TransactionObjectInput, TransactionResult } from "@mysten/sui/transactions";
-import { SuiPriceServiceConnection, SuiPythClient } from "@pythnetwork/pyth-sui-js";
-import { AddPoolRewardArgs, AddReserveArgs, BorrowArgs, CancelPoolRewardArgs, ClaimFeesArgs, ClaimRewardsAndDepositArgs, ClaimRewardsArgs, ClosePoolRewardArgs, CreateRateLimiterConfigArgs, CreateReserveConfigArgs, DepositCtokensIntoObligationArgs, DepositLiquidityAndMintCtokensArgs, LiquidateArgs, MigrateArgs, PhantomReified, RedeemCtokensAndWithdrawLiquidityArgs, RefreshReservePriceArgs, RepayArgs, Side, UpdateRateLimiterConfigArgs, UpdateReserveConfigArgs, WithdrawCtokensArgs } from "./types";
-interface Deps {
-    phantom: (phantomType: string) => PhantomReified<string>;
-    PACKAGE_ID: string;
-    PUBLISHED_AT: string;
-    LendingMarket: any;
-    Obligation: any;
-    ObligationOwnerCap: any;
-    createLendingMarket: (transaction: Transaction, typeArg: string, registry: TransactionObjectInput) => TransactionResult;
-    createReserveConfig: (transaction: Transaction, args: CreateReserveConfigArgs) => TransactionResult;
-    updateReserveConfig: (transaction: Transaction, typeArgs: [string, string], args: UpdateReserveConfigArgs) => TransactionResult;
-    addReserve: (transaction: Transaction, typeArgs: [string, string], args: AddReserveArgs) => TransactionResult;
-    addPoolReward: (transaction: Transaction, typeArgs: [string, string], args: AddPoolRewardArgs) => TransactionResult;
-    cancelPoolReward: (transaction: Transaction, typeArgs: [string, string], args: CancelPoolRewardArgs) => TransactionResult;
-    closePoolReward: (transaction: Transaction, typeArgs: [string, string], args: ClosePoolRewardArgs) => TransactionResult;
-    claimRewards: (transaction: Transaction, typeArgs: [string, string], args: ClaimRewardsArgs) => TransactionResult;
-    claimRewardsAndDeposit: (transaction: Transaction, typeArgs: [string, string], args: ClaimRewardsAndDepositArgs) => TransactionResult;
-    createRateLimiterConfig: (transaction: Transaction, args: CreateRateLimiterConfigArgs) => TransactionResult;
-    updateRateLimiterConfig: (transaction: Transaction, typeArg: string, args: UpdateRateLimiterConfigArgs) => TransactionResult;
-    refreshReservePrice: (transaction: Transaction, typeArg: string, args: RefreshReservePriceArgs) => TransactionResult;
-    depositLiquidityAndMintCtokens: (transaction: Transaction, typeArgs: [string, string], args: DepositLiquidityAndMintCtokensArgs) => TransactionResult;
-    depositCtokensIntoObligation: (transaction: Transaction, typeArgs: [string, string], args: DepositCtokensIntoObligationArgs) => TransactionResult;
-    withdrawCtokens: (transaction: Transaction, typeArgs: [string, string], args: WithdrawCtokensArgs) => TransactionResult;
-    borrow: (transaction: Transaction, typeArgs: [string, string], args: BorrowArgs) => TransactionResult;
-    repay: (transaction: Transaction, typeArgs: [string, string], args: RepayArgs) => TransactionResult;
-    liquidate: (transaction: Transaction, typeArgs: [string, string, string], args: LiquidateArgs) => TransactionResult;
-    migrate: (transaction: Transaction, typeArg: string, args: MigrateArgs) => TransactionResult;
-    claimFees: (transaction: Transaction, typeArgs: [string, string], args: ClaimFeesArgs) => TransactionResult;
-    redeemCtokensAndWithdrawLiquidity: (transaction: Transaction, typeArgs: [string, string], args: RedeemCtokensAndWithdrawLiquidityArgs) => TransactionResult;
-}
-export declare class SuilendClient {
-    lendingMarket: any;
-    client: SuiClient;
-    pythClient: SuiPythClient;
-    pythConnection: SuiPriceServiceConnection;
-    phantom: Deps["phantom"];
-    PACKAGE_ID: Deps["PACKAGE_ID"];
-    PUBLISHED_AT: Deps["PUBLISHED_AT"];
-    LendingMarket: Deps["LendingMarket"];
-    Obligation: Deps["Obligation"];
-    ObligationOwnerCap: Deps["ObligationOwnerCap"];
-    createLendingMarketFunction: Deps["createLendingMarket"];
-    createReserveConfigFunction: Deps["createReserveConfig"];
-    updateReserveConfigFunction: Deps["updateReserveConfig"];
-    addReserveFunction: Deps["addReserve"];
-    addPoolRewardFunction: Deps["addPoolReward"];
-    cancelPoolRewardFunction: Deps["cancelPoolReward"];
-    closePoolRewardFunction: Deps["closePoolReward"];
-    claimRewardsFunction: Deps["claimRewards"];
-    claimRewardsAndDepositFunction: Deps["claimRewardsAndDeposit"];
-    createRateLimiterConfigFunction: Deps["createRateLimiterConfig"];
-    updateRateLimiterConfigFunction: Deps["updateRateLimiterConfig"];
-    refreshReservePriceFunction: Deps["refreshReservePrice"];
-    depositLiquidityAndMintCtokensFunction: Deps["depositLiquidityAndMintCtokens"];
-    depositCtokensIntoObligationFunction: Deps["depositCtokensIntoObligation"];
-    withdrawCtokensFunction: Deps["withdrawCtokens"];
-    borrowFunction: Deps["borrow"];
-    repayFunction: Deps["repay"];
-    liquidateFunction: Deps["liquidate"];
-    migrateFunction: Deps["migrate"];
-    claimFeesFunction: Deps["claimFees"];
-    redeemCtokensAndWithdrawLiquidityFunction: Deps["redeemCtokensAndWithdrawLiquidity"];
-    constructor(lendingMarket: any, client: SuiClient, { phantom, PACKAGE_ID, PUBLISHED_AT, LendingMarket, Obligation, ObligationOwnerCap, createLendingMarket, createReserveConfig, updateReserveConfig, addReserve, addPoolReward, cancelPoolReward, closePoolReward, claimRewards, claimRewardsAndDeposit, createRateLimiterConfig, updateRateLimiterConfig, refreshReservePrice, depositLiquidityAndMintCtokens, depositCtokensIntoObligation, withdrawCtokens, borrow, repay, liquidate, migrate, claimFees, redeemCtokensAndWithdrawLiquidity, }: Deps);
-    static initialize(lendingMarketId: string, lendingMarketType: string, client: SuiClient, deps: Deps): Promise<SuilendClient>;
-    static initializeWithLendingMarket(lendingMarket: any, client: SuiClient, deps: Deps): Promise<SuilendClient>;
-    static hasBetaPass(ownerId: string, client: SuiClient): Promise<boolean>;
-    static createNewLendingMarket(registryId: string, lendingMarketType: string, transaction: Transaction, { LendingMarket, createLendingMarket, }: Pick<Deps, "LendingMarket" | "createLendingMarket">): Promise<{
-        $kind: "NestedResult";
-        NestedResult: [number, number];
-    }>;
-    static getObligationOwnerCaps(ownerId: string, lendingMarketTypeArgs: string[], client: SuiClient, { phantom, PACKAGE_ID, ObligationOwnerCap, }: Pick<Deps, "phantom" | "PACKAGE_ID" | "ObligationOwnerCap">): Promise<any[]>;
-    static getObligation(obligationId: string, lendingMarketTypeArgs: string[], client: SuiClient, { phantom, Obligation }: Pick<Deps, "phantom" | "Obligation">): Promise<any>;
-    getObligation(obligationId: string): Promise<any>;
-    static getLendingMarketOwnerCapId(ownerId: string, lendingMarketTypeArgs: string[], client: SuiClient, { PACKAGE_ID }: Pick<Deps, "PACKAGE_ID">): Promise<string | null>;
-    getLendingMarketOwnerCapId(ownerId: string): Promise<string | null>;
-    createReserve(lendingMarketOwnerCapId: string, transaction: Transaction, pythPriceId: string, coinType: string, createReserveConfigArgs: CreateReserveConfigArgs): Promise<TransactionResult>;
-    addReward(ownerId: string, lendingMarketOwnerCapId: string, reserveArrayIndex: bigint, isDepositReward: boolean, rewardCoinType: string, rewardValue: string, startTimeMs: bigint, endTimeMs: bigint, transaction: Transaction): Promise<TransactionResult>;
-    cancelReward(lendingMarketOwnerCapId: string, reserveArrayIndex: bigint, isDepositReward: boolean, rewardIndex: bigint, rewardCoinType: string, transaction: Transaction): TransactionResult;
-    closeReward(lendingMarketOwnerCapId: string, reserveArrayIndex: bigint, isDepositReward: boolean, rewardIndex: bigint, rewardCoinType: string, transaction: Transaction): TransactionResult;
-    claimReward(obligationOwnerCapId: string, reserveArrayIndex: bigint, rewardIndex: bigint, rewardType: string, side: Side, transaction: Transaction): TransactionResult;
-    claimRewardsAndDeposit(obligationId: string, rewardReserveArrayIndex: bigint, rewardIndex: bigint, rewardType: string, side: Side, depositReserveArrayIndex: bigint, transaction: Transaction): TransactionResult;
-    claimRewardsToObligation(ownerId: string, rewards: Array<{
-        obligationOwnerCapId: string;
-        reserveArrayIndex: bigint;
-        rewardIndex: bigint;
-        rewardType: string;
-        side: Side;
-    }>, transaction: Transaction): Promise<void>;
-    findReserveArrayIndex(coinType: string): bigint;
-    updateReserveConfig(ownerId: string, lendingMarketOwnerCapId: string, transaction: Transaction, coinType: string, createReserveConfigArgs: CreateReserveConfigArgs): Promise<TransactionResult>;
-    updateRateLimiterConfig(lendingMarketOwnerCapId: string, transaction: Transaction, newRateLimiterConfigArgs: CreateRateLimiterConfigArgs): Promise<TransactionResult>;
-    createObligation(transaction: Transaction): TransactionResult;
-    refreshAll(transaction: Transaction, obligation: typeof this.Obligation, extraReserveArrayIndex?: bigint): Promise<void>;
-    refreshReservePrices(transaction: Transaction, priceInfoObjectId: string, reserveArrayIndex: bigint): Promise<void>;
-    deposit(sendCoin: TransactionObjectInput, coinType: string, obligationOwnerCap: TransactionObjectInput, transaction: Transaction): Promise<void>;
-    depositCoin(ownerId: string, sendCoin: TransactionObjectInput, coinType: string, transaction: Transaction, obligationOwnerCapId?: string): Promise<void>;
-    depositIntoObligation(ownerId: string, coinType: string, value: string, transaction: Transaction, obligationOwnerCapId?: string): Promise<void>;
-    depositLiquidityAndGetCTokens(ownerId: string, coinType: string, value: string, transaction: Transaction): Promise<void>;
-    withdraw(obligationOwnerCapId: string, obligationId: string, coinType: string, value: string, transaction: Transaction): Promise<TransactionResult>;
-    withdrawFromObligation(ownerId: string, obligationOwnerCapId: string, obligationId: string, coinType: string, value: string, transaction: Transaction): Promise<void>;
-    borrow(obligationOwnerCapId: string, obligationId: string, coinType: string, value: string, transaction: Transaction): Promise<TransactionResult>;
-    borrowFromObligation(ownerId: string, obligationOwnerCapId: string, obligationId: string, coinType: string, value: string, transaction: Transaction): Promise<void>;
-    repay(obligationId: string, coinType: string, coin: TransactionObjectInput, transaction: Transaction): TransactionResult;
-    repayIntoObligation(ownerId: string, obligationId: string, coinType: string, value: string, transaction: Transaction): Promise<TransactionResult>;
-    liquidateAndRedeem(transaction: Transaction, obligation: typeof this.Obligation, repayCoinType: string, withdrawCoinType: string, repayCoinId: any): Promise<TransactionResult>;
-    liquidate(transaction: Transaction, obligation: typeof this.Obligation, repayCoinType: string, withdrawCoinType: string, repayCoinId: any): Promise<TransactionResult>;
-    migrate(transaction: Transaction, lendingMarketOwnerCapId: string): TransactionResult;
-    claimFees(transaction: Transaction, coinType: string): TransactionResult;
-    redeemCtokensAndWithdrawLiquidity(ownerId: string, ctokenCoinTypes: string[], transaction: Transaction): Promise<void>;
-}
-export {};

package/core/parsers/deps.d.ts

@@ -1,15 +0,0 @@
-import BigNumber from "bignumber.js";
-export interface Deps {
-    LendingMarket: any;
-    Obligation: any;
-    Reserve: any;
-    PoolRewardManager: any;
-    PoolReward: any;
-    simulate: {
-        calculateUtilizationPercent: (reserve: Deps["Reserve"]) => BigNumber;
-        calculateBorrowAprPercent: (reserve: Deps["Reserve"]) => BigNumber;
-        calculateDepositAprPercent: (reserve: Deps["Reserve"]) => BigNumber;
-        cTokenRatio: (reserve: Deps["Reserve"]) => BigNumber;
-    };
-    RateLimiter: any;
-}

package/core/parsers/deps.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/core/parsers/rateLimiter.d.ts

@@ -1,19 +0,0 @@
-import BigNumber from "bignumber.js";
-import { Deps } from "./deps";
-export type ParsedRateLimiter = ReturnType<typeof parseRateLimiter>;
-export type ParsedRateLimiterConfig = ReturnType<typeof parseRateLimiterConfig>;
-export declare const parseRateLimiter: ({ RateLimiter }: Pick<Deps, "RateLimiter">, rateLimiter: any, currentTime: number) => {
-    config: {
-        windowDuration: any;
-        maxOutflow: any;
-    };
-    $typeName: any;
-    prevQty: any;
-    windowStart: any;
-    curQty: any;
-    remainingOutflow: BigNumber;
-};
-export declare const parseRateLimiterConfig: ({ RateLimiter }: Pick<Deps, "RateLimiter">, rateLimiter: any) => {
-    windowDuration: any;
-    maxOutflow: any;
-};