@suilend/sdk 1.0.7 → 1.0.8

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/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/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;
+};

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;