@suilend/sdk 1.0.0

package/core/client.d.ts

@@ -0,0 +1,101 @@
+import { SuiClient } from "@mysten/sui.js/client";
+import { TransactionBlock, TransactionObjectArgument, TransactionResult } from "@mysten/sui.js/transactions";
+import { SuiPriceServiceConnection, SuiPythClient } from "../pyth-sdk";
+import { AddPoolRewardArgs, AddReserveArgs, BorrowArgs, CancelPoolRewardArgs, ClaimRewardsAndDepositArgs, ClaimRewardsArgs, CreateRateLimiterConfigArgs, CreateReserveConfigArgs, DepositCtokensIntoObligationArgs, DepositLiquidityAndMintCtokensArgs, LiquidateArgs, ObjectArg, PhantomReified, 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: (txb: TransactionBlock, typeArg: string, registry: ObjectArg) => TransactionResult;
+    createReserveConfig: (txb: TransactionBlock, args: CreateReserveConfigArgs) => TransactionResult;
+    updateReserveConfig: (txb: TransactionBlock, typeArgs: [string, string], args: UpdateReserveConfigArgs) => TransactionResult;
+    addReserve: (txb: TransactionBlock, typeArgs: [string, string], args: AddReserveArgs) => TransactionResult;
+    addPoolReward: (txb: TransactionBlock, typeArgs: [string, string], args: AddPoolRewardArgs) => TransactionResult;
+    cancelPoolReward: (txb: TransactionBlock, typeArgs: [string, string], args: CancelPoolRewardArgs) => TransactionResult;
+    claimRewards: (txb: TransactionBlock, typeArgs: [string, string], args: ClaimRewardsArgs) => TransactionResult;
+    claimRewardsAndDeposit: (txb: TransactionBlock, typeArgs: [string, string], args: ClaimRewardsAndDepositArgs) => TransactionResult;
+    createRateLimiterConfig: (txb: TransactionBlock, args: CreateRateLimiterConfigArgs) => TransactionResult;
+    updateRateLimiterConfig: (txb: TransactionBlock, typeArg: string, args: UpdateRateLimiterConfigArgs) => TransactionResult;
+    refreshReservePrice: (txb: TransactionBlock, typeArg: string, args: RefreshReservePriceArgs) => TransactionResult;
+    depositLiquidityAndMintCtokens: (txb: TransactionBlock, typeArgs: [string, string], args: DepositLiquidityAndMintCtokensArgs) => TransactionResult;
+    depositCtokensIntoObligation: (txb: TransactionBlock, typeArgs: [string, string], args: DepositCtokensIntoObligationArgs) => TransactionResult;
+    withdrawCtokens: (txb: TransactionBlock, typeArgs: [string, string], args: WithdrawCtokensArgs) => TransactionResult;
+    borrow: (txb: TransactionBlock, typeArgs: [string, string], args: BorrowArgs) => TransactionResult;
+    repay: (txb: TransactionBlock, typeArgs: [string, string], args: RepayArgs) => TransactionResult;
+    liquidate: (txb: TransactionBlock, typeArgs: [string, string, string], args: LiquidateArgs) => 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"];
+    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"];
+    constructor(lendingMarket: any, client: SuiClient, { phantom, PACKAGE_ID, PUBLISHED_AT, LendingMarket, Obligation, ObligationOwnerCap, createLendingMarket, createReserveConfig, updateReserveConfig, addReserve, addPoolReward, cancelPoolReward, claimRewards, claimRewardsAndDeposit, createRateLimiterConfig, updateRateLimiterConfig, refreshReservePrice, depositLiquidityAndMintCtokens, depositCtokensIntoObligation, withdrawCtokens, borrow, repay, liquidate, }: 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, txb: TransactionBlock, { LendingMarket, createLendingMarket, }: Pick<Deps, "LendingMarket" | "createLendingMarket">): Promise<{
+        index: number;
+        resultIndex: number;
+        kind: "NestedResult";
+    }>;
+    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, txb: TransactionBlock, 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, txb: TransactionBlock): Promise<TransactionResult>;
+    cancelReward(lendingMarketOwnerCapId: string, reserveArrayIndex: bigint, isDepositReward: boolean, rewardIndex: bigint, rewardCoinType: string, txb: TransactionBlock): TransactionResult;
+    claimReward(obligationOwnerCapId: string, reserveArrayIndex: bigint, rewardIndex: bigint, rewardType: string, side: Side, txb: TransactionBlock): TransactionResult;
+    claimRewardsAndDeposit(obligationId: string, rewardReserveArrayIndex: bigint, rewardIndex: bigint, rewardType: string, side: Side, depositReserveArrayIndex: bigint, txb: TransactionBlock): TransactionResult;
+    claimRewardsToObligation(ownerId: string, rewards: Array<{
+        obligationOwnerCapId: string;
+        reserveArrayIndex: bigint;
+        rewardIndex: bigint;
+        rewardType: string;
+        side: Side;
+    }>, txb: TransactionBlock): Promise<void>;
+    findReserveArrayIndex(coinType: string): bigint;
+    updateReserveConfig(ownerId: string, lendingMarketOwnerCapId: string, txb: TransactionBlock, coinType: string, createReserveConfigArgs: CreateReserveConfigArgs): Promise<TransactionResult>;
+    updateRateLimiterConfig(lendingMarketOwnerCapId: string, txb: TransactionBlock, newRateLimiterConfigArgs: CreateRateLimiterConfigArgs): Promise<TransactionResult>;
+    createObligation(txb: TransactionBlock): TransactionResult;
+    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>;
+    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>;
+    borrow(obligationOwnerCapId: string, obligationId: string, coinType: string, value: string, txb: TransactionBlock): Promise<TransactionResult>;
+    borrowFromObligation(ownerId: string, obligationOwnerCapId: string, obligationId: string, coinType: string, value: string, txb: TransactionBlock): Promise<void>;
+    repay(obligationId: string, coinType: string, coin: TransactionObjectArgument, txb: TransactionBlock): TransactionResult;
+    repayIntoObligation(ownerId: string, obligationId: string, coinType: string, value: string, txb: TransactionBlock): Promise<TransactionResult>;
+    liquidateAndRedeem(txb: TransactionBlock, obligation: typeof this.Obligation, repayCoinType: string, withdrawCoinType: string, repayCoinId: any): Promise<TransactionResult>;
+    liquidate(txb: TransactionBlock, obligation: typeof this.Obligation, repayCoinType: string, withdrawCoinType: string, repayCoinId: any): Promise<TransactionResult>;
+}
+export {};

package/core/client.js

@@ -0,0 +1,478 @@
+"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.SuilendClient = void 0;
+const bcs_1 = require("@mysten/bcs");
+const utils_1 = require("@mysten/sui.js/utils");
+const src_1 = require("../pyth-sdk");
+const types_1 = require("./types");
+const WORMHOLE_STATE_ID = "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c";
+const PYTH_STATE_ID = "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8";
+const SUI_COINTYPE = "0x2::sui::SUI";
+class SuilendClient {
+    constructor(lendingMarket, client, { phantom, PACKAGE_ID, PUBLISHED_AT, LendingMarket, Obligation, ObligationOwnerCap, createLendingMarket, createReserveConfig, updateReserveConfig, addReserve, addPoolReward, cancelPoolReward, claimRewards, claimRewardsAndDeposit, createRateLimiterConfig, updateRateLimiterConfig, refreshReservePrice, depositLiquidityAndMintCtokens, depositCtokensIntoObligation, withdrawCtokens, borrow, repay, liquidate, }) {
+        this.lendingMarket = lendingMarket;
+        this.client = client;
+        this.pythClient = new src_1.SuiPythClient(client, PYTH_STATE_ID, WORMHOLE_STATE_ID);
+        this.pythConnection = new src_1.SuiPriceServiceConnection("https://hermes.pyth.network");
+        this.phantom = phantom;
+        this.PACKAGE_ID = PACKAGE_ID;
+        this.PUBLISHED_AT = PUBLISHED_AT;
+        this.LendingMarket = LendingMarket;
+        this.Obligation = Obligation;
+        this.ObligationOwnerCap = ObligationOwnerCap;
+        this.createLendingMarketFunction = createLendingMarket;
+        this.createReserveConfigFunction = createReserveConfig;
+        this.updateReserveConfigFunction = updateReserveConfig;
+        this.addReserveFunction = addReserve;
+        this.addPoolRewardFunction = addPoolReward;
+        this.cancelPoolRewardFunction = cancelPoolReward;
+        this.claimRewardsFunction = claimRewards;
+        this.claimRewardsAndDepositFunction = claimRewardsAndDeposit;
+        this.createRateLimiterConfigFunction = createRateLimiterConfig;
+        this.updateRateLimiterConfigFunction = updateRateLimiterConfig;
+        this.refreshReservePriceFunction = refreshReservePrice;
+        this.depositLiquidityAndMintCtokensFunction =
+            depositLiquidityAndMintCtokens;
+        this.depositCtokensIntoObligationFunction = depositCtokensIntoObligation;
+        this.withdrawCtokensFunction = withdrawCtokens;
+        this.borrowFunction = borrow;
+        this.repayFunction = repay;
+        this.liquidateFunction = liquidate;
+    }
+    static initialize(lendingMarketId, lendingMarketType, client, deps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingMarket = yield deps.LendingMarket.fetch(client, deps.phantom(lendingMarketType), lendingMarketId);
+            return new SuilendClient(lendingMarket, client, deps);
+        });
+    }
+    static initializeWithLendingMarket(lendingMarket, client, deps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new SuilendClient(lendingMarket, client, deps);
+        });
+    }
+    static hasBetaPass(ownerId, client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const objs = yield client.getOwnedObjects({
+                owner: ownerId,
+                filter: {
+                    StructType: "0x02fb1289eb4e9ef987c6e383be4a9b298ef96d10a3f29060aaef39a0f9ecfbe6::suilend_beta_pass::SuilendBetaPass",
+                },
+            });
+            return objs.data.length > 0;
+        });
+    }
+    static createNewLendingMarket(registryId_1, lendingMarketType_1, txb_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (registryId, lendingMarketType, txb, { LendingMarket, createLendingMarket, }) {
+            const [ownerCap, lendingMarket] = createLendingMarket(txb, lendingMarketType, txb.object(registryId));
+            txb.moveCall({
+                target: `0x2::transfer::public_share_object`,
+                typeArguments: [`${LendingMarket.$typeName}<${lendingMarketType}>}`],
+                arguments: [lendingMarket],
+            });
+            return ownerCap;
+        });
+    }
+    static getObligationOwnerCaps(ownerId_1, lendingMarketTypeArgs_1, client_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (ownerId, lendingMarketTypeArgs, client, { phantom, PACKAGE_ID, ObligationOwnerCap, }) {
+            const objs = yield client.getOwnedObjects({
+                owner: ownerId,
+                filter: {
+                    StructType: `${PACKAGE_ID}::lending_market::ObligationOwnerCap<${lendingMarketTypeArgs[0]}>`,
+                },
+            });
+            if (objs.data.length > 0) {
+                const obligationOwnerCapObjs = yield Promise.all(objs.data.map((objData) => {
+                    var _a;
+                    return client.getObject({
+                        id: (_a = objData.data) === null || _a === void 0 ? void 0 : _a.objectId,
+                        options: { showBcs: true },
+                    });
+                }));
+                const obligationOwnerCaps = [];
+                obligationOwnerCapObjs.forEach((obj) => {
+                    var _a, _b, _c, _d;
+                    if (((_b = (_a = obj.data) === null || _a === void 0 ? void 0 : _a.bcs) === null || _b === void 0 ? void 0 : _b.dataType) !== "moveObject")
+                        throw new Error("Error: invalid data type");
+                    obligationOwnerCaps.push(ObligationOwnerCap.fromBcs(phantom(lendingMarketTypeArgs[0]), (0, bcs_1.fromB64)((_d = (_c = obj.data) === null || _c === void 0 ? void 0 : _c.bcs) === null || _d === void 0 ? void 0 : _d.bcsBytes)));
+                });
+                return obligationOwnerCaps;
+            }
+            else {
+                return [];
+            }
+        });
+    }
+    static getObligation(obligationId_1, lendingMarketTypeArgs_1, client_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (obligationId, lendingMarketTypeArgs, client, { phantom, Obligation }) {
+            var _b, _c;
+            const obligationData = yield client.getObject({
+                id: obligationId,
+                options: { showBcs: true },
+            });
+            if (((_c = (_b = obligationData.data) === null || _b === void 0 ? void 0 : _b.bcs) === null || _c === void 0 ? void 0 : _c.dataType) !== "moveObject") {
+                throw new Error("Error: invalid data type");
+            }
+            const obligation = Obligation.fromBcs(phantom(lendingMarketTypeArgs[0]), (0, bcs_1.fromB64)(obligationData.data.bcs.bcsBytes));
+            return obligation;
+        });
+    }
+    getObligation(obligationId) {
+        return SuilendClient.getObligation(obligationId, this.lendingMarket.$typeArgs, this.client, { phantom: this.phantom, Obligation: this.Obligation });
+    }
+    static getLendingMarketOwnerCapId(ownerId_1, lendingMarketTypeArgs_1, client_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (ownerId, lendingMarketTypeArgs, client, { PACKAGE_ID }) {
+            var _b;
+            const objs = yield client.getOwnedObjects({
+                owner: ownerId,
+                filter: {
+                    StructType: `${PACKAGE_ID}::lending_market::LendingMarketOwnerCap<${lendingMarketTypeArgs[0]}>`,
+                },
+            });
+            if (objs.data.length > 0)
+                return (_b = objs.data[0].data) === null || _b === void 0 ? void 0 : _b.objectId;
+            else
+                return null;
+        });
+    }
+    getLendingMarketOwnerCapId(ownerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return SuilendClient.getLendingMarketOwnerCapId(ownerId, this.lendingMarket.$typeArgs, this.client, { PACKAGE_ID: this.PACKAGE_ID });
+        });
+    }
+    createReserve(lendingMarketOwnerCapId, txb, pythPriceId, coinType, createReserveConfigArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [config] = this.createReserveConfigFunction(txb, createReserveConfigArgs);
+            const priceUpdateData = yield this.pythConnection.getPriceFeedsUpdateData([
+                pythPriceId,
+            ]);
+            const priceInfoObjectIds = yield this.pythClient.updatePriceFeeds(txb, priceUpdateData, [pythPriceId]);
+            const coin_metadata = yield this.client.getCoinMetadata({
+                coinType: coinType,
+            });
+            if (coin_metadata === null) {
+                throw new Error("Error: coin metadata not found");
+            }
+            return this.addReserveFunction(txb, [this.lendingMarket.$typeArgs[0], coinType], {
+                lendingMarketOwnerCap: lendingMarketOwnerCapId,
+                lendingMarket: this.lendingMarket.id,
+                priceInfo: priceInfoObjectIds[0],
+                config,
+                coinMetadata: coin_metadata.id,
+                clock: utils_1.SUI_CLOCK_OBJECT_ID,
+            });
+        });
+    }
+    addReward(ownerId, lendingMarketOwnerCapId, reserveArrayIndex, isDepositReward, rewardCoinType, rewardValue, startTimeMs, endTimeMs, txb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isSui = (0, utils_1.normalizeStructTag)(rewardCoinType) === (0, utils_1.normalizeStructTag)(SUI_COINTYPE);
+            const coins = (yield this.client.getCoins({
+                owner: ownerId,
+                coinType: rewardCoinType,
+            })).data;
+            const mergedCoin = coins[0];
+            if (coins.length > 1 && !isSui) {
+                txb.mergeCoins(txb.object(mergedCoin.coinObjectId), coins.map((c) => txb.object(c.coinObjectId)).slice(1));
+            }
+            const [rewardCoin] = txb.splitCoins(isSui ? txb.gas : txb.object(mergedCoin.coinObjectId), [txb.pure(rewardValue)]);
+            return this.addPoolRewardFunction(txb, [this.lendingMarket.$typeArgs[0], rewardCoinType], {
+                lendingMarketOwnerCap: lendingMarketOwnerCapId,
+                lendingMarket: this.lendingMarket.id,
+                reserveArrayIndex,
+                isDepositReward,
+                rewards: rewardCoin,
+                startTimeMs,
+                endTimeMs,
+                clock: utils_1.SUI_CLOCK_OBJECT_ID,
+            });
+        });
+    }
+    cancelReward(lendingMarketOwnerCapId, reserveArrayIndex, isDepositReward, rewardIndex, rewardCoinType, txb) {
+        return this.cancelPoolRewardFunction(txb, [this.lendingMarket.$typeArgs[0], rewardCoinType], {
+            lendingMarketOwnerCap: lendingMarketOwnerCapId,
+            lendingMarket: this.lendingMarket.id,
+            reserveArrayIndex,
+            isDepositReward,
+            rewardIndex,
+            clock: utils_1.SUI_CLOCK_OBJECT_ID,
+        });
+    }
+    claimReward(obligationOwnerCapId, reserveArrayIndex, rewardIndex, rewardType, side, txb) {
+        return this.claimRewardsFunction(txb, [this.lendingMarket.$typeArgs[0], rewardType], {
+            lendingMarket: txb.object(this.lendingMarket.id),
+            cap: txb.object(obligationOwnerCapId),
+            clock: utils_1.SUI_CLOCK_OBJECT_ID,
+            reserveId: reserveArrayIndex,
+            rewardIndex,
+            isDepositReward: side === types_1.Side.DEPOSIT,
+        });
+    }
+    claimRewardsAndDeposit(obligationId, rewardReserveArrayIndex, rewardIndex, rewardType, side, depositReserveArrayIndex, txb) {
+        return this.claimRewardsAndDepositFunction(txb, [this.lendingMarket.$typeArgs[0], rewardType], {
+            lendingMarket: txb.object(this.lendingMarket.id),
+            obligationId,
+            clock: txb.object(utils_1.SUI_CLOCK_OBJECT_ID),
+            rewardReserveId: rewardReserveArrayIndex,
+            rewardIndex,
+            isDepositReward: side === types_1.Side.DEPOSIT,
+            depositReserveId: depositReserveArrayIndex,
+        });
+    }
+    claimRewardsToObligation(ownerId, rewards, txb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const claimedCoins = rewards.map((r) => {
+                const [claimedCoin] = this.claimReward(r.obligationOwnerCapId, r.reserveArrayIndex, r.rewardIndex, r.rewardType, r.side, txb);
+                return claimedCoin;
+            });
+            const mergedCoin = claimedCoins[0];
+            if (claimedCoins.length > 1) {
+                txb.mergeCoins(mergedCoin, claimedCoins.slice(1));
+            }
+            txb.transferObjects([mergedCoin], txb.pure(ownerId));
+        });
+    }
+    findReserveArrayIndex(coinType) {
+        const normalizedCoinType = (0, utils_1.normalizeStructTag)(coinType);
+        const array_index = this.lendingMarket.reserves.findIndex((r) => (0, utils_1.normalizeStructTag)(r.coinType.name) == normalizedCoinType);
+        return BigInt(array_index);
+    }
+    updateReserveConfig(ownerId, lendingMarketOwnerCapId, txb, coinType, createReserveConfigArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [config] = this.createReserveConfigFunction(txb, createReserveConfigArgs);
+            return this.updateReserveConfigFunction(txb, [...this.lendingMarket.$typeArgs, coinType], {
+                lendingMarketOwnerCap: lendingMarketOwnerCapId,
+                lendingMarket: this.lendingMarket.id,
+                config,
+                reserveArrayIndex: this.findReserveArrayIndex(coinType),
+            });
+        });
+    }
+    updateRateLimiterConfig(lendingMarketOwnerCapId, txb, newRateLimiterConfigArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [config] = this.createRateLimiterConfigFunction(txb, newRateLimiterConfigArgs);
+            return this.updateRateLimiterConfigFunction(txb, this.lendingMarket.$typeArgs[0], {
+                lendingMarketOwnerCap: lendingMarketOwnerCapId,
+                lendingMarket: this.lendingMarket.id,
+                clock: utils_1.SUI_CLOCK_OBJECT_ID,
+                config,
+            });
+        });
+    }
+    createObligation(txb) {
+        return txb.moveCall({
+            target: `${this.PUBLISHED_AT}::lending_market::create_obligation`,
+            arguments: [txb.object(this.lendingMarket.id)],
+            typeArguments: this.lendingMarket.$typeArgs,
+        });
+    }
+    refreshAll(txb, obligation, extraReserveArrayIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const reserveArrayIndexToPriceId = new Map();
+            obligation.deposits.forEach((deposit) => {
+                const reserve = this.lendingMarket.reserves[deposit.reserveArrayIndex];
+                reserveArrayIndexToPriceId.set(deposit.reserveArrayIndex, (0, bcs_1.toHEX)(new Uint8Array(reserve.priceIdentifier.bytes)));
+            });
+            obligation.borrows.forEach((borrow) => {
+                const reserve = this.lendingMarket.reserves[borrow.reserveArrayIndex];
+                reserveArrayIndexToPriceId.set(borrow.reserveArrayIndex, (0, bcs_1.toHEX)(new Uint8Array(reserve.priceIdentifier.bytes)));
+            });
+            if (extraReserveArrayIndex != undefined &&
+                extraReserveArrayIndex >= 0 &&
+                extraReserveArrayIndex < this.lendingMarket.reserves.length) {
+                const reserve = this.lendingMarket.reserves[extraReserveArrayIndex];
+                reserveArrayIndexToPriceId.set(extraReserveArrayIndex, (0, bcs_1.toHEX)(new Uint8Array(reserve.priceIdentifier.bytes)));
+            }
+            const tuples = Array.from(reserveArrayIndexToPriceId.entries()).sort();
+            const priceIds = Array.from(new Set(tuples.map((tuple) => tuple[1])));
+            const priceUpdateData = yield this.pythConnection.getPriceFeedsUpdateData(priceIds);
+            const priceInfoObjectIds = yield this.pythClient.updatePriceFeeds(txb, priceUpdateData, priceIds);
+            for (let i = 0; i < tuples.length; i++) {
+                this.refreshReservePrices(txb, priceInfoObjectIds[i], tuples[i][0]);
+            }
+        });
+    }
+    refreshReservePrices(txb, priceInfoObjectId, reserveArrayIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (priceInfoObjectId == null) {
+                return;
+            }
+            this.refreshReservePriceFunction(txb, this.lendingMarket.$typeArgs[0], {
+                lendingMarket: this.lendingMarket.id,
+                clock: utils_1.SUI_CLOCK_OBJECT_ID,
+                priceInfo: priceInfoObjectId,
+                reserveArrayIndex,
+            });
+        });
+    }
+    deposit(sendCoin, coinType, obligationOwnerCap, txb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [ctokens] = this.depositLiquidityAndMintCtokensFunction(txb, [this.lendingMarket.$typeArgs[0], coinType], {
+                lendingMarket: this.lendingMarket.id,
+                clock: utils_1.SUI_CLOCK_OBJECT_ID,
+                deposit: sendCoin,
+                reserveArrayIndex: this.findReserveArrayIndex(coinType),
+            });
+            this.depositCtokensIntoObligationFunction(txb, [this.lendingMarket.$typeArgs[0], coinType], {
+                lendingMarket: this.lendingMarket.id,
+                obligationOwnerCap,
+                deposit: ctokens,
+                clock: utils_1.SUI_CLOCK_OBJECT_ID,
+                reserveArrayIndex: this.findReserveArrayIndex(coinType),
+            });
+        });
+    }
+    depositIntoObligation(ownerId, coinType, value, txb, obligationOwnerCapId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let createdObligationOwnerCap;
+            if (!obligationOwnerCapId) {
+                createdObligationOwnerCap = this.createObligation(txb)[0];
+            }
+            const isSui = (0, utils_1.normalizeStructTag)(coinType) === (0, utils_1.normalizeStructTag)(SUI_COINTYPE);
+            const coins = (yield this.client.getCoins({
+                owner: ownerId,
+                coinType,
+            })).data;
+            const mergedCoin = coins[0];
+            if (coins.length > 1 && !isSui) {
+                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));
+            }
+        });
+    }
+    withdraw(obligationOwnerCapId, obligationId, coinType, value, txb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const obligation = yield this.getObligation(obligationId);
+            if (!obligation)
+                throw new Error("Error: no obligation");
+            yield this.refreshAll(txb, obligation);
+            const [ctokens] = this.withdrawCtokensFunction(txb, [this.lendingMarket.$typeArgs[0], coinType], {
+                lendingMarket: this.lendingMarket.id,
+                obligationOwnerCap: obligationOwnerCapId,
+                clock: utils_1.SUI_CLOCK_OBJECT_ID,
+                amount: BigInt(value),
+                reserveArrayIndex: this.findReserveArrayIndex(coinType),
+            });
+            const [exemption] = txb.moveCall({
+                target: `0x1::option::none`,
+                typeArguments: [
+                    `${this.PACKAGE_ID}::lending_market::RateLimiterExemption<${this.lendingMarket.$typeArgs[0]}, ${coinType}>`,
+                ],
+                arguments: [],
+            });
+            return txb.moveCall({
+                target: `${this.PUBLISHED_AT}::lending_market::redeem_ctokens_and_withdraw_liquidity`,
+                typeArguments: [this.lendingMarket.$typeArgs[0], coinType],
+                arguments: [
+                    txb.object(this.lendingMarket.id),
+                    txb.pure(this.findReserveArrayIndex(coinType)),
+                    txb.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    ctokens,
+                    exemption,
+                ],
+            });
+        });
+    }
+    withdrawFromObligation(ownerId, obligationOwnerCapId, obligationId, coinType, value, txb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [withdrawCoin] = yield this.withdraw(obligationOwnerCapId, obligationId, coinType, value, txb);
+            txb.transferObjects([withdrawCoin], txb.pure(ownerId));
+        });
+    }
+    borrow(obligationOwnerCapId, obligationId, coinType, value, txb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const obligation = yield this.getObligation(obligationId);
+            if (!obligation)
+                throw new Error("Error: no obligation");
+            yield this.refreshAll(txb, obligation, this.findReserveArrayIndex(coinType));
+            const result = this.borrowFunction(txb, [this.lendingMarket.$typeArgs[0], coinType], {
+                lendingMarket: this.lendingMarket.id,
+                obligationOwnerCap: obligationOwnerCapId,
+                clock: utils_1.SUI_CLOCK_OBJECT_ID,
+                amount: BigInt(value),
+                reserveArrayIndex: this.findReserveArrayIndex(coinType),
+            });
+            return result;
+        });
+    }
+    borrowFromObligation(ownerId, obligationOwnerCapId, obligationId, coinType, value, txb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [borrowCoin] = yield this.borrow(obligationOwnerCapId, obligationId, coinType, value, txb);
+            txb.transferObjects([borrowCoin], txb.pure(ownerId));
+        });
+    }
+    repay(obligationId, coinType, coin, txb) {
+        return this.repayFunction(txb, [this.lendingMarket.$typeArgs[0], coinType], {
+            lendingMarket: this.lendingMarket.id,
+            obligationId: obligationId,
+            clock: utils_1.SUI_CLOCK_OBJECT_ID,
+            maxRepayCoins: coin,
+            reserveArrayIndex: this.findReserveArrayIndex(coinType),
+        });
+    }
+    repayIntoObligation(ownerId, obligationId, coinType, value, txb) {
+        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,
+                coinType,
+            })).data;
+            const mergedCoin = coins[0];
+            if (coins.length > 1 && !isSui) {
+                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)]);
+            const result = this.repay(obligationId, coinType, sendCoin, txb);
+            txb.transferObjects([sendCoin], ownerId);
+            return result;
+        });
+    }
+    liquidateAndRedeem(txb, obligation, repayCoinType, withdrawCoinType, repayCoinId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [ctokens, exemption] = yield this.liquidate(txb, obligation, repayCoinType, withdrawCoinType, repayCoinId);
+            const [optionalExemption] = txb.moveCall({
+                target: `0x1::option::some`,
+                typeArguments: [
+                    `${this.PUBLISHED_AT}::lending_market::RateLimiterExemption<${this.lendingMarket.$typeArgs[0]}, ${withdrawCoinType}>`,
+                ],
+                arguments: [exemption],
+            });
+            return txb.moveCall({
+                target: `${this.PUBLISHED_AT}::lending_market::redeem_ctokens_and_withdraw_liquidity`,
+                typeArguments: [this.lendingMarket.$typeArgs[0], withdrawCoinType],
+                arguments: [
+                    txb.object(this.lendingMarket.id),
+                    txb.pure(this.findReserveArrayIndex(withdrawCoinType)),
+                    txb.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    ctokens,
+                    optionalExemption,
+                ],
+            });
+        });
+    }
+    liquidate(txb, obligation, repayCoinType, withdrawCoinType, repayCoinId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.refreshAll(txb, obligation);
+            return this.liquidateFunction(txb, [this.lendingMarket.$typeArgs[0], repayCoinType, withdrawCoinType], {
+                lendingMarket: this.lendingMarket.id,
+                obligationId: obligation.id,
+                clock: utils_1.SUI_CLOCK_OBJECT_ID,
+                repayCoins: repayCoinId,
+                repayReserveArrayIndex: this.findReserveArrayIndex(repayCoinType),
+                withdrawReserveArrayIndex: this.findReserveArrayIndex(withdrawCoinType),
+            });
+        });
+    }
+}
+exports.SuilendClient = SuilendClient;

package/core/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const maxU64: bigint;
+export declare const WAD: bigint;

package/core/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WAD = exports.maxU64 = void 0;
+exports.maxU64 = BigInt(2) ** BigInt(64) - BigInt(1);
+exports.WAD = BigInt(10) ** BigInt(18);

package/core/parsers/deps.d.ts

@@ -0,0 +1,15 @@
+import BigNumber from "bignumber.js";
+export interface Deps {
+    LendingMarket: any;
+    Obligation: any;
+    Reserve: any;
+    PoolRewardManager: any;
+    PoolReward: any;
+    simulate: {
+        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/deps.js

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