@suilend/sdk 1.0.7 → 1.0.9

package/core/api/events.d.ts

@@ -1,2 +1,5 @@
 import { DownsampledApiReserveAssetDataEvent } from "../types";
+/**
+ * Note: This SDK function is experimental and may change or require authentication in the future.
+ */
 export declare const fetchDownsampledApiReserveAssetDataEvents: (reserveId: string, days: number, sampleIntervalS: number) => Promise<DownsampledApiReserveAssetDataEvent[]>;

package/core/api/events.js

@@ -10,6 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchDownsampledApiReserveAssetDataEvents = void 0;
+/**
+ * Note: This SDK function is experimental and may change or require authentication in the future.
+ */
 const fetchDownsampledApiReserveAssetDataEvents = (reserveId, days, sampleIntervalS) => __awaiter(void 0, void 0, void 0, function* () {
     const url = `https://api.suilend.fi/events/downsampled-reserve-asset-data?reserveId=${reserveId}&days=${days}&sampleIntervalS=${sampleIntervalS}`;
     const res = yield fetch(url);

package/core/client.d.ts

@@ -93,6 +93,7 @@ export declare class SuilendClient {
     refreshAll(txb: TransactionBlock, obligation: typeof this.Obligation, extraReserveArrayIndex?: bigint): Promise<void>;
     refreshReservePrices(txb: TransactionBlock, priceInfoObjectId: string, reserveArrayIndex: bigint): Promise<void>;
     deposit(sendCoin: ObjectArg, coinType: string, obligationOwnerCap: ObjectArg, txb: TransactionBlock): Promise<void>;
+    depositCoin(ownerId: string, sendCoin: ObjectArg, coinType: string, txb: TransactionBlock, obligationOwnerCapId?: string): Promise<void>;
     depositIntoObligation(ownerId: string, coinType: string, value: string, txb: TransactionBlock, obligationOwnerCapId?: string): Promise<void>;
     withdraw(obligationOwnerCapId: string, obligationId: string, coinType: string, value: string, txb: TransactionBlock): Promise<TransactionResult>;
     withdrawFromObligation(ownerId: string, obligationOwnerCapId: string, obligationId: string, coinType: string, value: string, txb: TransactionBlock): Promise<void>;

package/core/client.js

@@ -341,12 +341,20 @@ class SuilendClient {
             });
         });
     }
-    depositIntoObligation(ownerId, coinType, value, txb, obligationOwnerCapId) {
+    depositCoin(ownerId, sendCoin, coinType, txb, obligationOwnerCapId) {
         return __awaiter(this, void 0, void 0, function* () {
             let createdObligationOwnerCap;
             if (!obligationOwnerCapId) {
                 createdObligationOwnerCap = this.createObligation(txb)[0];
             }
+            this.deposit(sendCoin, coinType, (obligationOwnerCapId !== null && obligationOwnerCapId !== void 0 ? obligationOwnerCapId : createdObligationOwnerCap), txb);
+            if (createdObligationOwnerCap) {
+                txb.transferObjects([createdObligationOwnerCap], txb.pure(ownerId));
+            }
+        });
+    }
+    depositIntoObligation(ownerId, coinType, value, txb, obligationOwnerCapId) {
+        return __awaiter(this, void 0, void 0, function* () {
             const isSui = (0, utils_1.normalizeStructTag)(coinType) === (0, utils_1.normalizeStructTag)(SUI_COINTYPE);
             const coins = (yield this.client.getCoins({
                 owner: ownerId,
@@ -357,10 +365,7 @@ class SuilendClient {
                 txb.mergeCoins(txb.object(mergedCoin.coinObjectId), coins.map((c) => txb.object(c.coinObjectId)).slice(1));
             }
             const [sendCoin] = txb.splitCoins(isSui ? txb.gas : txb.object(mergedCoin.coinObjectId), [txb.pure(value)]);
-            this.deposit(sendCoin, coinType, (obligationOwnerCapId !== null && obligationOwnerCapId !== void 0 ? obligationOwnerCapId : createdObligationOwnerCap), txb);
-            if (createdObligationOwnerCap) {
-                txb.transferObjects([createdObligationOwnerCap], txb.pure(ownerId));
-            }
+            this.depositCoin(ownerId, sendCoin, coinType, txb, obligationOwnerCapId);
         });
     }
     withdraw(obligationOwnerCapId, obligationId, coinType, value, txb) {

package/core/constants.d.ts

@@ -1,3 +1,7 @@
 import BigNumber from "bignumber.js";
 export declare const maxU64: BigNumber;
 export declare const WAD: BigNumber;
+export declare enum SdkEnv {
+    BETA = "beta",
+    MAINNET = "mainnet"
+}

package/core/constants.js

@@ -3,7 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WAD = exports.maxU64 = void 0;
+exports.SdkEnv = exports.WAD = exports.maxU64 = void 0;
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
 exports.maxU64 = new bignumber_js_1.default(2).pow(64).minus(1);
 exports.WAD = new bignumber_js_1.default(10).pow(18);
+var SdkEnv;
+(function (SdkEnv) {
+    SdkEnv["BETA"] = "beta";
+    SdkEnv["MAINNET"] = "mainnet";
+})(SdkEnv || (exports.SdkEnv = SdkEnv = {}));

package/core/parsers/apiReserveAssetDataEvent.d.ts

@@ -4,20 +4,19 @@ import { ParsedReserve } from "./reserve";
 export type ParsedReserveAssetDataEvent = ReturnType<typeof parseReserveAssetDataEvent>;
 export declare const parseReserveAssetDataEvent: (event: ApiReserveAssetDataEvent, reserve: ParsedReserve) => {
     id: number;
-    lendingMarket: string;
+    lendingMarketId: string;
     coinType: string;
     reserveId: string;
+    availableAmount: BigNumber;
     depositedAmount: BigNumber;
     borrowedAmount: BigNumber;
-    availableAmount: BigNumber;
+    availableAmountUsd: BigNumber;
     depositedAmountUsd: BigNumber;
     borrowedAmountUsd: BigNumber;
-    availableAmountUsd: BigNumber;
-    utilizationPercent: BigNumber;
     borrowAprPercent: BigNumber;
     depositAprPercent: BigNumber;
     ctokenSupply: BigNumber;
-    cumulativeBorrowRate: string;
+    cumulativeBorrowRate: BigNumber;
     price: BigNumber;
     smoothedPrice: BigNumber;
     minPrice: BigNumber;
@@ -27,25 +26,25 @@ export declare const parseReserveAssetDataEvent: (event: ApiReserveAssetDataEven
     digest: string;
     eventIndex: number;
     sender: string;
+    utilizationPercent: BigNumber;
 };
 export type ParsedDownsampledApiReserveAssetDataEvent = ReturnType<typeof parseDownsampledApiReserveAssetDataEvent>;
 export declare const parseDownsampledApiReserveAssetDataEvent: (event: DownsampledApiReserveAssetDataEvent, reserve: ParsedReserve) => {
     sampleTimestampS: number;
     id: number;
-    lendingMarket: string;
+    lendingMarketId: string;
     coinType: string;
     reserveId: string;
+    availableAmount: BigNumber;
     depositedAmount: BigNumber;
     borrowedAmount: BigNumber;
-    availableAmount: BigNumber;
+    availableAmountUsd: BigNumber;
     depositedAmountUsd: BigNumber;
     borrowedAmountUsd: BigNumber;
-    availableAmountUsd: BigNumber;
-    utilizationPercent: BigNumber;
     borrowAprPercent: BigNumber;
     depositAprPercent: BigNumber;
     ctokenSupply: BigNumber;
-    cumulativeBorrowRate: string;
+    cumulativeBorrowRate: BigNumber;
     price: BigNumber;
     smoothedPrice: BigNumber;
     minPrice: BigNumber;
@@ -55,4 +54,5 @@ export declare const parseDownsampledApiReserveAssetDataEvent: (event: Downsampl
     digest: string;
     eventIndex: number;
     sender: string;
+    utilizationPercent: BigNumber;
 };

package/core/parsers/apiReserveAssetDataEvent.js

@@ -7,68 +7,48 @@ exports.parseDownsampledApiReserveAssetDataEvent = exports.parseReserveAssetData
 const utils_1 = require("@mysten/sui.js/utils");
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const constants_1 = require("../constants");
-const calculateBorrowAprPercent = (utilizationPercent, reserve) => {
-    const config = reserve.config;
-    let i = 1;
-    while (i < config.interestRate.length) {
-        const leftUtilPercent = config.interestRate[i - 1].utilPercent;
-        const leftAprPercent = config.interestRate[i - 1].aprPercent;
-        const rightUtilPercent = config.interestRate[i].utilPercent;
-        const rightAprPercent = config.interestRate[i].aprPercent;
-        if (utilizationPercent.gte(leftUtilPercent) &&
-            utilizationPercent.lte(rightUtilPercent)) {
-            const weight = new bignumber_js_1.default(utilizationPercent.minus(leftUtilPercent)).div(rightUtilPercent.minus(leftUtilPercent));
-            return leftAprPercent.plus(weight.times(rightAprPercent.minus(leftAprPercent)));
-        }
-        i = i + 1;
-    }
-    // Should never reach here
-    return new bignumber_js_1.default(0);
-};
 const parseReserveAssetDataEvent = (event, reserve) => {
-    const depositedAmount = new bignumber_js_1.default(event.supplyAmount)
+    const availableAmount = new bignumber_js_1.default(event.availableAmount)
         .div(constants_1.WAD)
         .div(10 ** reserve.mintDecimals);
-    const borrowedAmount = new bignumber_js_1.default(event.borrowedAmount)
+    const depositedAmount = new bignumber_js_1.default(event.supplyAmount)
         .div(constants_1.WAD)
         .div(10 ** reserve.mintDecimals);
-    const availableAmount = new bignumber_js_1.default(event.availableAmount)
+    const borrowedAmount = new bignumber_js_1.default(event.borrowedAmount)
         .div(constants_1.WAD)
         .div(10 ** reserve.mintDecimals);
+    const availableAmountUsd = new bignumber_js_1.default(event.availableAmountUsdEstimate).div(constants_1.WAD);
+    const depositedAmountUsd = new bignumber_js_1.default(event.supplyAmountUsdEstimate).div(constants_1.WAD);
+    const borrowedAmountUsd = new bignumber_js_1.default(event.borrowedAmountUsdEstimate).div(constants_1.WAD);
+    const borrowAprPercent = new bignumber_js_1.default(event.borrowApr).div(constants_1.WAD).times(100);
+    const depositAprPercent = new bignumber_js_1.default(event.supplyApr).div(constants_1.WAD).times(100);
     const ctokenSupply = new bignumber_js_1.default(event.ctokenSupply).div(10 ** reserve.mintDecimals);
-    const utilizationPercent = depositedAmount.eq(0)
-        ? new bignumber_js_1.default(0)
-        : borrowedAmount.div(depositedAmount).times(100);
-    const borrowAprPercent = calculateBorrowAprPercent(utilizationPercent, reserve);
-    const depositAprPercent = utilizationPercent
-        .div(100)
-        .times(borrowAprPercent.div(100))
-        .times(new bignumber_js_1.default(100).minus(new bignumber_js_1.default(reserve.config.spreadFeeBps).div(100)));
+    const cumulativeBorrowRate = new bignumber_js_1.default(event.cumulativeBorrowRate).div(constants_1.WAD);
     const price = new bignumber_js_1.default(event.price).div(constants_1.WAD);
     const smoothedPrice = new bignumber_js_1.default(event.smoothedPrice).div(constants_1.WAD);
     const minPrice = bignumber_js_1.default.min(price, smoothedPrice);
     const maxPrice = bignumber_js_1.default.max(price, smoothedPrice);
-    const depositedAmountUsd = depositedAmount.times(price);
-    const borrowedAmountUsd = borrowedAmount.times(price);
-    const availableAmountUsd = availableAmount.times(price);
+    // Custom
+    const utilizationPercent = depositedAmount.eq(0)
+        ? new bignumber_js_1.default(0)
+        : borrowedAmount.div(depositedAmount).times(100);
     return {
         id: event.id,
-        lendingMarket: event.lendingMarketId,
+        lendingMarketId: event.lendingMarketId,
         coinType: (0, utils_1.normalizeStructTag)(event.coinType),
         reserveId: event.reserveId,
+        availableAmount,
         depositedAmount,
         borrowedAmount,
-        availableAmount,
+        availableAmountUsd,
         depositedAmountUsd,
         borrowedAmountUsd,
-        availableAmountUsd,
-        utilizationPercent: utilizationPercent,
-        borrowAprPercent: borrowAprPercent,
-        depositAprPercent: depositAprPercent,
-        ctokenSupply: ctokenSupply,
-        cumulativeBorrowRate: event.cumulativeBorrowRate,
-        price: price,
-        smoothedPrice: smoothedPrice,
+        borrowAprPercent,
+        depositAprPercent,
+        ctokenSupply,
+        cumulativeBorrowRate,
+        price,
+        smoothedPrice,
         minPrice,
         maxPrice,
         priceLastUpdateTimestampS: event.priceLastUpdateTimestampS,
@@ -76,6 +56,7 @@ const parseReserveAssetDataEvent = (event, reserve) => {
         digest: event.digest,
         eventIndex: event.eventIndex,
         sender: event.sender,
+        utilizationPercent,
     };
 };
 exports.parseReserveAssetDataEvent = parseReserveAssetDataEvent;

package/core/parsers/deps.d.ts

@@ -6,10 +6,10 @@ export interface Deps {
     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;
-        calculateBorrowApr: (reserve: Deps["Reserve"]) => BigNumber;
-        calculateSupplyApr: (reserve: Deps["Reserve"]) => BigNumber;
-        calculateUtilizationRate: (reserve: Deps["Reserve"]) => BigNumber;
     };
     RateLimiter: any;
 }

package/core/parsers/obligation.d.ts

@@ -15,6 +15,8 @@ export declare const parseObligation: ({ Obligation }: Pick<Deps, "Obligation">,
     borrowLimitUsd: BigNumber;
     minPriceBorrowLimitUsd: BigNumber;
     unhealthyBorrowValueUsd: BigNumber;
+    depositPositionCount: number;
+    borrowPositionCount: number;
     positionCount: number;
     deposits: {
         coinType: string;

package/core/parsers/obligation.js

@@ -15,13 +15,14 @@ const parseObligation = ({ Obligation }, obligation, parsedReserveMap) => {
     let borrowLimitUsd = new bignumber_js_1.default(0);
     let minPriceBorrowLimitUsd = new bignumber_js_1.default(0);
     let unhealthyBorrowValueUsd = new bignumber_js_1.default(0);
-    let positionCount = 0;
+    let depositPositionCount = 0;
+    let borrowPositionCount = 0;
     const deposits = obligation.deposits.map((deposit) => {
         const coinType = (0, utils_1.normalizeStructTag)(deposit.coinType.name);
         const reserve = parsedReserveMap[coinType];
         if (!reserve)
             throw new Error(`Reserve with coinType ${deposit.coinType.name} not found`);
-        positionCount++;
+        depositPositionCount++;
         const depositedCtokenAmount = new bignumber_js_1.default(deposit.depositedCtokenAmount.toString()).div(10 ** reserve.mintDecimals);
         const depositedAmount = depositedCtokenAmount.times(reserve.cTokenExchangeRate);
         const depositedAmountUsd = depositedAmount.times(reserve.price);
@@ -50,7 +51,7 @@ const parseObligation = ({ Obligation }, obligation, parsedReserveMap) => {
         const reserve = parsedReserveMap[coinType];
         if (!reserve)
             throw new Error(`Reserve with coinType ${borrow.coinType.name} not found`);
-        positionCount++;
+        borrowPositionCount++;
         const cumulativeBorrowRate = new bignumber_js_1.default(borrow.cumulativeBorrowRate.value.toString()).div(constants_1.WAD);
         const borrowedAmountInitial = new bignumber_js_1.default(borrow.borrowedAmount.value.toString())
             .div(constants_1.WAD)
@@ -90,7 +91,9 @@ const parseObligation = ({ Obligation }, obligation, parsedReserveMap) => {
         borrowLimitUsd,
         minPriceBorrowLimitUsd,
         unhealthyBorrowValueUsd,
-        positionCount,
+        depositPositionCount,
+        borrowPositionCount,
+        positionCount: depositPositionCount + borrowPositionCount,
         deposits,
         borrows,
         weightedConservativeBorrowUtilizationPercent,

package/core/parsers/rateLimiter.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRateLimiterConfig = exports.parseRateLimiter = void 0;
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const constants_1 = require("../constants");
 const parseRateLimiter = ({ RateLimiter }, rateLimiter, currentTime) => {
     const config = (0, exports.parseRateLimiterConfig)({ RateLimiter }, rateLimiter);
     const $typeName = rateLimiter.$typeName;
@@ -18,7 +19,7 @@ const parseRateLimiter = ({ RateLimiter }, rateLimiter, currentTime) => {
     const currentOutflow = prevWeight
         .times(new bignumber_js_1.default(prevQty.toString()))
         .plus(new bignumber_js_1.default(curQty.toString()))
-        .div(10 ** 18);
+        .div(constants_1.WAD);
     const remainingOutflow = currentOutflow.gt(config.maxOutflow.toString())
         ? new bignumber_js_1.default(0)
         : new bignumber_js_1.default(config.maxOutflow.toString()).minus(currentOutflow);

package/core/parsers/reserve.js

@@ -44,11 +44,9 @@ const parseReserve = ({ Reserve, PoolRewardManager, PoolReward, simulate, }, res
         .minus(unclaimedSpreadFees);
     const depositedAmountUsd = depositedAmount.times(price);
     const cTokenExchangeRate = simulate.cTokenRatio(reserve);
-    const borrowAprPercent = simulate.calculateBorrowApr(reserve);
-    const depositAprPercent = simulate.calculateSupplyApr(reserve);
-    const utilizationPercent = simulate
-        .calculateUtilizationRate(reserve)
-        .times(100);
+    const borrowAprPercent = simulate.calculateBorrowAprPercent(reserve);
+    const depositAprPercent = simulate.calculateDepositAprPercent(reserve);
+    const utilizationPercent = simulate.calculateUtilizationPercent(reserve);
     const symbol = coinMetadata.symbol;
     const name = coinMetadata.name;
     const iconUrl = coinMetadata.iconUrl;

package/core/types.d.ts

@@ -672,6 +672,27 @@ export interface MigrateArgs {
     lendingMarketOwnerCap: ObjectArg;
     lendingMarket: ObjectArg;
 }
+export type ApiInterestUpdateEvent = {
+    id: number;
+    lendingMarketId: string;
+    coinType: string;
+    reserveId: string;
+    cumulativeBorrowRate: string;
+    availableAmount: string;
+    borrowedAmount: string;
+    unclaimedSpreadFees: string;
+    ctokenSupply: string;
+    borrowInterestPaid: string;
+    spreadFee: string;
+    supplyInterestEarned: string;
+    borrowInterestPaidUsdEstimate: string;
+    protocolFeeUsdEstimate: string;
+    supplyInterestEarnedUsdEstimate: string;
+    timestamp: number;
+    digest: string;
+    eventIndex: number;
+    sender: string;
+};
 export type ApiReserveAssetDataEvent = {
     id: number;
     lendingMarketId: string;
@@ -698,3 +719,146 @@ export type ApiReserveAssetDataEvent = {
 export type DownsampledApiReserveAssetDataEvent = ApiReserveAssetDataEvent & {
     sampletimestamp: number;
 };
+export type ApiMintEvent = {
+    id: number;
+    lendingMarketId: string;
+    coinType: string;
+    reserveId: string;
+    liquidityAmount: string;
+    ctokenAmount: string;
+    timestamp: number;
+    digest: string;
+    eventIndex: number;
+    sender: string;
+};
+export type ApiRedeemEvent = {
+    id: number;
+    lendingMarketId: string;
+    coinType: string;
+    reserveId: string;
+    ctokenAmount: string;
+    liquidityAmount: string;
+    timestamp: number;
+    digest: string;
+    eventIndex: number;
+    sender: string;
+};
+export type ApiDepositEvent = {
+    id: number;
+    lendingMarketId: string;
+    coinType: string;
+    reserveId: string;
+    obligationId: string;
+    ctokenAmount: string;
+    timestamp: number;
+    digest: string;
+    eventIndex: number;
+    sender: string;
+};
+export type ApiWithdrawEvent = {
+    id: number;
+    lendingMarketId: string;
+    coinType: string;
+    reserveId: string;
+    obligationId: string;
+    ctokenAmount: string;
+    timestamp: number;
+    digest: string;
+    eventIndex: number;
+    sender: string;
+};
+export type ApiBorrowEvent = {
+    id: number;
+    lendingMarketId: string;
+    coinType: string;
+    reserveId: string;
+    obligationId: string;
+    liquidityAmount: string;
+    originationFeeAmount: string;
+    timestamp: number;
+    digest: string;
+    eventIndex: number;
+    sender: string;
+};
+export type ApiRepayEvent = {
+    id: number;
+    lendingMarketId: string;
+    coinType: string;
+    reserveId: string;
+    obligationId: string;
+    liquidityAmount: string;
+    timestamp: number;
+    digest: string;
+    eventIndex: number;
+    sender: string;
+};
+export type ApiLiquidateEvent = {
+    id: number;
+    lendingMarketId: string;
+    repayReserveId: string;
+    withdrawReserveId: string;
+    obligationId: string;
+    repayAmount: string;
+    withdrawAmount: string;
+    protocolFeeAmount: string;
+    liquidatorBonusAmount: string;
+    timestamp: number;
+    digest: string;
+    eventIndex: number;
+    sender: string;
+};
+export type ApiClaimRewardEvent = {
+    id: number;
+    lendingMarketId: string;
+    reserveId: string;
+    obligationId: string;
+    isDepositReward: boolean;
+    poolRewardId: string;
+    coinType: string;
+    liquidityAmount: string;
+    timestamp: number;
+    digest: string;
+    eventIndex: number;
+    sender: string;
+};
+export type ApiObligationDataEvent = {
+    id: number;
+    lendingMarketId: string;
+    obligationId: string;
+    depositedValueUsd: string;
+    allowedBorrowValueUsd: string;
+    unhealthyBorrowValueUsd: string;
+    superUnhealthyBorrowValueUsd: string;
+    unweightedBorrowedValueUsd: string;
+    weightedBorrowedValueUsd: string;
+    weightedBorrowedValueUpperBoundUsd: string;
+    borrowingIsolatedAsset: boolean;
+    badDebtUsd: string;
+    closable: boolean;
+    timestamp: number;
+    digest: string;
+    eventIndex: number;
+    sender: string;
+    /**
+     * {
+     *  coin_type: TypeName;
+     *  reserve_array_index: u64;
+     *  deposited_ctoken_amount: u64;
+     *  market_value: Decimal;
+     *  user_reward_manager_index: u64;
+     *  attributed_borrow_value: Decimal;
+     * }[]
+     */
+    depositsJson: string;
+    /**
+     * {
+     *  coin_type: TypeName;
+     *  reserve_array_index: u64;
+     *  borrowed_amount: Decimal;
+     *  cumulative_borrow_rate: Decimal;
+     *  market_value: Decimal;
+     *  user_reward_manager_index: u64;
+     * }[]
+     */
+    borrowsJson: string;
+};