@suilend/sdk 3.0.8 → 5.0.0

package/client.js

@@ -1,15 +1,6 @@
-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());
-    });
-};
 import { SUI_CLOCK_OBJECT_ID, SUI_SYSTEM_STATE_OBJECT_ID, normalizeStructTag, toHex, } from "@mysten/sui/utils";
 import { SuiPriceServiceConnection, SuiPythClient, } from "@pythnetwork/pyth-sui-js";
-import { extractCTokenCoinType, getAllCoins, getSpendableCoin, } from "@suilend/sui-fe";
+import { extractCTokenCoinType, getAllCoins, getSpendableCoin, } from "@suilend/sui-core";
 import { PriceInfoObject } from "./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-info/structs.js";
 import { phantom } from "./_generated/_framework/reified.js";
 import { PKG_V10, setPublishedAt } from "./_generated/suilend/index.js";
@@ -55,16 +46,18 @@ export const [STEAMM_LM_LENDING_MARKET_ID, STEAMM_LM_LENDING_MARKET_TYPE] = proc
         "0xc1888ec1b81a414e427a44829310508352aec38252ee0daa9f8b181b6947de9f",
         "0x0a071f4976abae1a7f722199cf0bfcbe695ef9408a878e7d12a7ca87b7e582a6::lp_rewards::LP_REWARDS",
     ];
-function getLatestPackageId(suiGrpcClient, upgradeCapId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { object } = yield suiGrpcClient.getObject({
-            objectId: upgradeCapId,
-            include: { json: true },
-        });
-        return object.json.package;
+async function getLatestPackageId(suiGrpcClient, upgradeCapId) {
+    const { object } = await suiGrpcClient.getObject({
+        objectId: upgradeCapId,
+        include: { json: true },
     });
+    return object.json.package;
 }
 export class SuilendClient {
+    lendingMarket;
+    suiGrpcClient;
+    pythClient;
+    pythConnection;
     constructor(lendingMarket, suiGrpcClient) {
         this.lendingMarket = lendingMarket;
         this.suiGrpcClient = suiGrpcClient;
@@ -74,35 +67,30 @@ export class SuilendClient {
             timeout: 30 * 1000,
         });
     }
-    static initialize(lendingMarketId, lendingMarketType, suiGrpcClient, logPackageId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const lendingMarket = yield LendingMarket.fetch(suiGrpcClient, phantom(lendingMarketType), lendingMarketId);
-            const publishedAt = yield getLatestPackageId(suiGrpcClient, SUILEND_UPGRADE_CAP_ID);
-            if (logPackageId)
-                console.log("@suilend/sdk | publishedAt:", publishedAt);
-            setPublishedAt(publishedAt);
-            return new SuilendClient(lendingMarket, suiGrpcClient);
-        });
-    }
-    static getFeeReceivers(suiGrpcClient, lendingMarketId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const { dynamicField } = yield suiGrpcClient.getDynamicField({
-                parentId: lendingMarketId,
-                name: {
-                    type: `${PKG_V10}::lending_market::FeeReceiversKey`,
-                    bcs: new Uint8Array([0]),
-                },
-            });
-            const { object } = yield suiGrpcClient.getObject({
-                objectId: dynamicField.fieldId,
-                include: { json: true },
-            });
-            const json = object.json;
-            const receivers = (_a = json === null || json === void 0 ? void 0 : json.value) === null || _a === void 0 ? void 0 : _a.receivers;
-            const weights = (_b = json === null || json === void 0 ? void 0 : json.value) === null || _b === void 0 ? void 0 : _b.weights;
-            return { receivers, weights };
+    static async initialize(lendingMarketId, lendingMarketType, suiGrpcClient, logPackageId) {
+        const lendingMarket = await LendingMarket.fetch(suiGrpcClient, phantom(lendingMarketType), lendingMarketId);
+        const publishedAt = await getLatestPackageId(suiGrpcClient, SUILEND_UPGRADE_CAP_ID);
+        if (logPackageId)
+            console.log("@suilend/sdk | publishedAt:", publishedAt);
+        setPublishedAt(publishedAt);
+        return new SuilendClient(lendingMarket, suiGrpcClient);
+    }
+    static async getFeeReceivers(suiGrpcClient, lendingMarketId) {
+        const { dynamicField } = await suiGrpcClient.getDynamicField({
+            parentId: lendingMarketId,
+            name: {
+                type: `${PKG_V10}::lending_market::FeeReceiversKey`,
+                bcs: new Uint8Array([0]),
+            },
+        });
+        const { object } = await suiGrpcClient.getObject({
+            objectId: dynamicField.fieldId,
+            include: { json: true },
         });
+        const json = object.json;
+        const receivers = json?.value?.receivers;
+        const weights = json?.value?.weights;
+        return { receivers, weights };
     }
     static createNewLendingMarket(registryId, lendingMarketType, transaction) {
         const [ownerCap, lendingMarket] = createLendingMarket(transaction, lendingMarketType, transaction.object(registryId));
@@ -113,96 +101,82 @@ export class SuilendClient {
         });
         return ownerCap;
     }
-    static getObligationOwnerCaps(ownerId, lendingMarketTypeArgs, suiGrpcClient) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const allObjs = [];
-            let cursor = null;
-            let hasNextPage = true;
-            while (hasNextPage) {
-                const objs = yield suiGrpcClient.listOwnedObjects({
-                    owner: ownerId,
-                    cursor,
-                    type: `${PACKAGE_ID}::lending_market::ObligationOwnerCap<${lendingMarketTypeArgs[0]}>`,
-                    include: { content: true },
-                });
-                allObjs.push(...objs.objects);
-                cursor = objs.cursor;
-                hasNextPage = objs.hasNextPage;
-            }
-            return allObjs.map((obj) => ObligationOwnerCap.fromBcs(phantom(lendingMarketTypeArgs[0]), obj.content));
-        });
-    }
-    static getObligation(obligationId, lendingMarketTypeArgs, suiGrpcClient) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield suiGrpcClient.getObject({
-                objectId: obligationId,
+    static async getObligationOwnerCaps(ownerId, lendingMarketTypeArgs, suiGrpcClient) {
+        const allObjs = [];
+        let cursor = null;
+        let hasNextPage = true;
+        while (hasNextPage) {
+            const objs = await suiGrpcClient.listOwnedObjects({
+                owner: ownerId,
+                cursor,
+                type: `${PACKAGE_ID}::lending_market::ObligationOwnerCap<${lendingMarketTypeArgs[0]}>`,
                 include: { content: true },
             });
-            return Obligation.fromBcs(phantom(lendingMarketTypeArgs[0]), object.content);
+            allObjs.push(...objs.objects);
+            cursor = objs.cursor;
+            hasNextPage = objs.hasNextPage;
+        }
+        return allObjs.map((obj) => ObligationOwnerCap.fromBcs(phantom(lendingMarketTypeArgs[0]), obj.content));
+    }
+    static async getObligation(obligationId, lendingMarketTypeArgs, suiGrpcClient) {
+        const { object } = await suiGrpcClient.getObject({
+            objectId: obligationId,
+            include: { content: true },
         });
+        return Obligation.fromBcs(phantom(lendingMarketTypeArgs[0]), object.content);
     }
-    getObligation(obligationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return SuilendClient.getObligation(obligationId, this.lendingMarket.$typeArgs, this.suiGrpcClient);
+    async getObligation(obligationId) {
+        return SuilendClient.getObligation(obligationId, this.lendingMarket.$typeArgs, this.suiGrpcClient);
+    }
+    static async getLendingMarketOwnerCapId(ownerId, lendingMarketTypeArgs, suiGrpcClient) {
+        const objs = await suiGrpcClient.listOwnedObjects({
+            owner: ownerId,
+            type: `${PACKAGE_ID}::lending_market::LendingMarketOwnerCap<${lendingMarketTypeArgs[0]}>`,
         });
+        if (objs.objects.length > 0)
+            return objs.objects[0].objectId;
+        else
+            return undefined;
     }
-    static getLendingMarketOwnerCapId(ownerId, lendingMarketTypeArgs, suiGrpcClient) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const objs = yield suiGrpcClient.listOwnedObjects({
-                owner: ownerId,
-                type: `${PACKAGE_ID}::lending_market::LendingMarketOwnerCap<${lendingMarketTypeArgs[0]}>`,
-            });
-            if (objs.objects.length > 0)
-                return objs.objects[0].objectId;
-            else
-                return undefined;
-        });
-    }
-    getLendingMarketOwnerCapId(ownerId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return SuilendClient.getLendingMarketOwnerCapId(ownerId, this.lendingMarket.$typeArgs, this.suiGrpcClient);
-        });
-    }
-    createReserve(lendingMarketOwnerCapId, transaction, pythPriceId, coinType, createReserveConfigArgs, useV2) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [config] = createReserveConfig(transaction, createReserveConfigArgs);
-            // Assumes the pyth price feed exists
-            const priceUpdateData = yield this.pythConnection.getPriceFeedsUpdateData([
-                pythPriceId,
-            ]);
-            const priceInfoObjectIds = yield this.pythClient.updatePriceFeeds(transaction, priceUpdateData, [pythPriceId]);
-            const { coinMetadata } = yield this.suiGrpcClient.getCoinMetadata({
-                coinType: coinType,
-            });
-            console.log("[createReserve] coinMetadata", coinMetadata);
-            if (!coinMetadata)
-                throw new Error("Error: CoinMetadata not found");
-            if (!coinMetadata.id)
-                throw new Error("Error: CoinMetadata.id not found");
-            const addReserveFn = useV2 ? addReserveV2 : addReserve;
-            return addReserveFn(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
-                lendingMarketOwnerCap: transaction.object(lendingMarketOwnerCapId),
-                lendingMarket: transaction.object(this.lendingMarket.id),
-                priceInfo: transaction.object(priceInfoObjectIds[0]),
-                config: transaction.object(config),
-                coinMetadata: transaction.object(coinMetadata.id),
-                clock: transaction.object(SUI_CLOCK_OBJECT_ID),
-            });
+    async getLendingMarketOwnerCapId(ownerId) {
+        return SuilendClient.getLendingMarketOwnerCapId(ownerId, this.lendingMarket.$typeArgs, this.suiGrpcClient);
+    }
+    async createReserve(lendingMarketOwnerCapId, transaction, pythPriceId, coinType, createReserveConfigArgs, useV2) {
+        const [config] = createReserveConfig(transaction, createReserveConfigArgs);
+        // Assumes the pyth price feed exists
+        const priceUpdateData = await this.pythConnection.getPriceFeedsUpdateData([
+            pythPriceId,
+        ]);
+        const priceInfoObjectIds = await this.pythClient.updatePriceFeeds(transaction, priceUpdateData, [pythPriceId]);
+        const { coinMetadata } = await this.suiGrpcClient.getCoinMetadata({
+            coinType: coinType,
+        });
+        console.log("[createReserve] coinMetadata", coinMetadata);
+        if (!coinMetadata)
+            throw new Error("Error: CoinMetadata not found");
+        if (!coinMetadata.id)
+            throw new Error("Error: CoinMetadata.id not found");
+        const addReserveFn = useV2 ? addReserveV2 : addReserve;
+        return addReserveFn(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
+            lendingMarketOwnerCap: transaction.object(lendingMarketOwnerCapId),
+            lendingMarket: transaction.object(this.lendingMarket.id),
+            priceInfo: transaction.object(priceInfoObjectIds[0]),
+            config: transaction.object(config),
+            coinMetadata: transaction.object(coinMetadata.id),
+            clock: transaction.object(SUI_CLOCK_OBJECT_ID),
         });
     }
-    addReward(ownerId_1, lendingMarketOwnerCapId_1, reserveArrayIndex_1, isDepositReward_1, rewardCoinType_1, rewardValue_1, startTimeMs_1, endTimeMs_1, transaction_1) {
-        return __awaiter(this, arguments, void 0, function* (ownerId, lendingMarketOwnerCapId, reserveArrayIndex, isDepositReward, rewardCoinType, rewardValue, startTimeMs, endTimeMs, transaction, mergeCoins = true) {
-            const rewardCoin = yield getSpendableCoin(this.suiGrpcClient, ownerId, rewardCoinType, rewardValue, transaction, mergeCoins);
-            return addPoolReward(transaction, [this.lendingMarket.$typeArgs[0], rewardCoinType], {
-                lendingMarketOwnerCap: transaction.object(lendingMarketOwnerCapId),
-                lendingMarket: transaction.object(this.lendingMarket.id),
-                reserveArrayIndex: transaction.pure.u64(reserveArrayIndex),
-                isDepositReward: transaction.pure.bool(isDepositReward),
-                rewards: transaction.object(rewardCoin),
-                startTimeMs: transaction.pure.u64(startTimeMs),
-                endTimeMs: transaction.pure.u64(endTimeMs),
-                clock: transaction.object(SUI_CLOCK_OBJECT_ID),
-            });
+    async addReward(ownerId, lendingMarketOwnerCapId, reserveArrayIndex, isDepositReward, rewardCoinType, rewardValue, startTimeMs, endTimeMs, transaction, mergeCoins = true) {
+        const rewardCoin = await getSpendableCoin(this.suiGrpcClient, ownerId, rewardCoinType, rewardValue, transaction, mergeCoins);
+        return addPoolReward(transaction, [this.lendingMarket.$typeArgs[0], rewardCoinType], {
+            lendingMarketOwnerCap: transaction.object(lendingMarketOwnerCapId),
+            lendingMarket: transaction.object(this.lendingMarket.id),
+            reserveArrayIndex: transaction.pure.u64(reserveArrayIndex),
+            isDepositReward: transaction.pure.bool(isDepositReward),
+            rewards: transaction.object(rewardCoin),
+            startTimeMs: transaction.pure.u64(startTimeMs),
+            endTimeMs: transaction.pure.u64(endTimeMs),
+            clock: transaction.object(SUI_CLOCK_OBJECT_ID),
         });
     }
     cancelReward(lendingMarketOwnerCapId, reserveArrayIndex, isDepositReward, rewardIndex, rewardCoinType, transaction) {
@@ -307,19 +281,17 @@ export class SuilendClient {
             config: transaction.object(config),
         });
     }
-    changeReservePriceFeed(lendingMarketOwnerCapId, coinType, pythPriceId, transaction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const priceUpdateData = yield this.pythConnection.getPriceFeedsUpdateData([
-                pythPriceId,
-            ]);
-            const priceInfoObjectIds = yield this.pythClient.updatePriceFeeds(transaction, priceUpdateData, [pythPriceId]);
-            return changeReservePriceFeed(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
-                lendingMarketOwnerCap: transaction.object(lendingMarketOwnerCapId),
-                lendingMarket: transaction.object(this.lendingMarket.id),
-                reserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(coinType)),
-                priceInfoObj: transaction.object(priceInfoObjectIds[0]),
-                clock: transaction.object(SUI_CLOCK_OBJECT_ID),
-            });
+    async changeReservePriceFeed(lendingMarketOwnerCapId, coinType, pythPriceId, transaction) {
+        const priceUpdateData = await this.pythConnection.getPriceFeedsUpdateData([
+            pythPriceId,
+        ]);
+        const priceInfoObjectIds = await this.pythClient.updatePriceFeeds(transaction, priceUpdateData, [pythPriceId]);
+        return changeReservePriceFeed(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
+            lendingMarketOwnerCap: transaction.object(lendingMarketOwnerCapId),
+            lendingMarket: transaction.object(this.lendingMarket.id),
+            reserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(coinType)),
+            priceInfoObj: transaction.object(priceInfoObjectIds[0]),
+            clock: transaction.object(SUI_CLOCK_OBJECT_ID),
         });
     }
     createObligation(transaction) {
@@ -329,67 +301,63 @@ export class SuilendClient {
             typeArguments: this.lendingMarket.$typeArgs,
         });
     }
-    refreshAll(transaction, obligation, coinTypes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const reserveArrayIndexToPriceId = new Map();
-            if (obligation) {
-                obligation.deposits.forEach((deposit) => {
-                    const reserve = this.lendingMarket.reserves[Number(deposit.reserveArrayIndex)];
-                    reserveArrayIndexToPriceId.set(deposit.reserveArrayIndex, toHex(new Uint8Array(reserve.priceIdentifier.bytes)));
-                });
-                obligation.borrows.forEach((borrow) => {
-                    const reserve = this.lendingMarket.reserves[Number(borrow.reserveArrayIndex)];
-                    reserveArrayIndexToPriceId.set(borrow.reserveArrayIndex, toHex(new Uint8Array(reserve.priceIdentifier.bytes)));
-                });
-            }
-            if (coinTypes !== undefined) {
-                for (const coinType of coinTypes) {
-                    const reserveArrayIndex = this.findReserveArrayIndex(coinType);
-                    if (reserveArrayIndex >= 0 &&
-                        reserveArrayIndex < BigInt(this.lendingMarket.reserves.length)) {
-                        const reserve = this.lendingMarket.reserves[Number(reserveArrayIndex)];
-                        reserveArrayIndexToPriceId.set(reserveArrayIndex, toHex(new Uint8Array(reserve.priceIdentifier.bytes)));
-                    }
-                }
-            }
-            const tuples = Array.from(reserveArrayIndexToPriceId.entries()).sort();
-            const reserveArrayIndexes = tuples.map((tuple) => tuple[0]);
-            const priceIdentifiers = tuples.map((tuple) => tuple[1]);
-            const priceInfoObjectIds = {};
-            yield Promise.all(priceIdentifiers.map((_, i) => (() => __awaiter(this, void 0, void 0, function* () {
-                const priceInfoObjectId = yield this.pythClient.getPriceFeedObjectId(priceIdentifiers[i]);
-                priceInfoObjectIds[i] = priceInfoObjectId;
-            }))()));
-            const stalePriceIdentifiers = [];
-            yield Promise.all(Object.entries(priceInfoObjectIds).map(([i, priceInfoObjectId]) => (() => __awaiter(this, void 0, void 0, function* () {
-                const priceInfoObject = yield PriceInfoObject.fetch(this.suiGrpcClient, priceInfoObjectId);
-                const publishTime = priceInfoObject.priceInfo.priceFeed.price.timestamp;
-                const stalenessSeconds = Date.now() / 1000 - Number(publishTime);
-                if (stalenessSeconds > 20) {
-                    const reserve = this.lendingMarket.reserves[Number(reserveArrayIndexes[+i])];
-                    stalePriceIdentifiers.push(priceIdentifiers[+i]);
+    async refreshAll(transaction, obligation, coinTypes) {
+        const reserveArrayIndexToPriceId = new Map();
+        if (obligation) {
+            obligation.deposits.forEach((deposit) => {
+                const reserve = this.lendingMarket.reserves[Number(deposit.reserveArrayIndex)];
+                reserveArrayIndexToPriceId.set(deposit.reserveArrayIndex, toHex(new Uint8Array(reserve.priceIdentifier.bytes)));
+            });
+            obligation.borrows.forEach((borrow) => {
+                const reserve = this.lendingMarket.reserves[Number(borrow.reserveArrayIndex)];
+                reserveArrayIndexToPriceId.set(borrow.reserveArrayIndex, toHex(new Uint8Array(reserve.priceIdentifier.bytes)));
+            });
+        }
+        if (coinTypes !== undefined) {
+            for (const coinType of coinTypes) {
+                const reserveArrayIndex = this.findReserveArrayIndex(coinType);
+                if (reserveArrayIndex >= 0 &&
+                    reserveArrayIndex < BigInt(this.lendingMarket.reserves.length)) {
+                    const reserve = this.lendingMarket.reserves[Number(reserveArrayIndex)];
+                    reserveArrayIndexToPriceId.set(reserveArrayIndex, toHex(new Uint8Array(reserve.priceIdentifier.bytes)));
                 }
-            }))()));
-            if (stalePriceIdentifiers.length > 0) {
-                const stalePriceUpdateData = yield this.pythConnection.getPriceFeedsUpdateData(stalePriceIdentifiers);
-                yield this.pythClient.updatePriceFeeds(transaction, stalePriceUpdateData, stalePriceIdentifiers);
             }
-            for (let i = 0; i < reserveArrayIndexes.length; i++) {
-                this.refreshReservePrices(transaction, priceInfoObjectIds[i], reserveArrayIndexes[i]);
+        }
+        const tuples = Array.from(reserveArrayIndexToPriceId.entries()).sort();
+        const reserveArrayIndexes = tuples.map((tuple) => tuple[0]);
+        const priceIdentifiers = tuples.map((tuple) => tuple[1]);
+        const priceInfoObjectIds = {};
+        await Promise.all(priceIdentifiers.map((_, i) => (async () => {
+            const priceInfoObjectId = await this.pythClient.getPriceFeedObjectId(priceIdentifiers[i]);
+            priceInfoObjectIds[i] = priceInfoObjectId;
+        })()));
+        const stalePriceIdentifiers = [];
+        await Promise.all(Object.entries(priceInfoObjectIds).map(([i, priceInfoObjectId]) => (async () => {
+            const priceInfoObject = await PriceInfoObject.fetch(this.suiGrpcClient, priceInfoObjectId);
+            const publishTime = priceInfoObject.priceInfo.priceFeed.price.timestamp;
+            const stalenessSeconds = Date.now() / 1000 - Number(publishTime);
+            if (stalenessSeconds > 20) {
+                const reserve = this.lendingMarket.reserves[Number(reserveArrayIndexes[+i])];
+                stalePriceIdentifiers.push(priceIdentifiers[+i]);
             }
-        });
+        })()));
+        if (stalePriceIdentifiers.length > 0) {
+            const stalePriceUpdateData = await this.pythConnection.getPriceFeedsUpdateData(stalePriceIdentifiers);
+            await this.pythClient.updatePriceFeeds(transaction, stalePriceUpdateData, stalePriceIdentifiers);
+        }
+        for (let i = 0; i < reserveArrayIndexes.length; i++) {
+            this.refreshReservePrices(transaction, priceInfoObjectIds[i], reserveArrayIndexes[i]);
+        }
     }
-    refreshReservePrices(transaction, priceInfoObjectId, reserveArrayIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (priceInfoObjectId == null) {
-                return;
-            }
-            refreshReservePrice(transaction, this.lendingMarket.$typeArgs[0], {
-                lendingMarket: transaction.object(this.lendingMarket.id),
-                reserveArrayIndex: transaction.pure.u64(reserveArrayIndex),
-                clock: transaction.object(SUI_CLOCK_OBJECT_ID),
-                priceInfo: transaction.object(priceInfoObjectId),
-            });
+    async refreshReservePrices(transaction, priceInfoObjectId, reserveArrayIndex) {
+        if (priceInfoObjectId == null) {
+            return;
+        }
+        refreshReservePrice(transaction, this.lendingMarket.$typeArgs[0], {
+            lendingMarket: transaction.object(this.lendingMarket.id),
+            reserveArrayIndex: transaction.pure.u64(reserveArrayIndex),
+            clock: transaction.object(SUI_CLOCK_OBJECT_ID),
+            priceInfo: transaction.object(priceInfoObjectId),
         });
     }
     deposit(sendCoin, coinType, obligationOwnerCap, transaction) {
@@ -414,48 +382,42 @@ export class SuilendClient {
             });
         }
     }
-    depositIntoObligation(ownerId, coinType, value, transaction, obligationOwnerCap) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sendCoin = yield getSpendableCoin(this.suiGrpcClient, ownerId, coinType, value, transaction);
-            this.deposit(sendCoin, coinType, obligationOwnerCap, transaction);
-        });
+    async depositIntoObligation(ownerId, coinType, value, transaction, obligationOwnerCap) {
+        const sendCoin = await getSpendableCoin(this.suiGrpcClient, ownerId, coinType, value, transaction);
+        this.deposit(sendCoin, coinType, obligationOwnerCap, transaction);
     }
-    depositLiquidityAndGetCTokens(ownerId, coinType, value, transaction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sendCoin = yield getSpendableCoin(this.suiGrpcClient, ownerId, coinType, value, transaction);
-            const [ctokens] = depositLiquidityAndMintCtokens(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
-                lendingMarket: transaction.object(this.lendingMarket.id),
-                reserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(coinType)),
-                clock: transaction.object(SUI_CLOCK_OBJECT_ID),
-                deposit: sendCoin,
-            });
-            transaction.transferObjects([ctokens], transaction.pure.address(ownerId));
+    async depositLiquidityAndGetCTokens(ownerId, coinType, value, transaction) {
+        const sendCoin = await getSpendableCoin(this.suiGrpcClient, ownerId, coinType, value, transaction);
+        const [ctokens] = depositLiquidityAndMintCtokens(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
+            lendingMarket: transaction.object(this.lendingMarket.id),
+            reserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(coinType)),
+            clock: transaction.object(SUI_CLOCK_OBJECT_ID),
+            deposit: sendCoin,
         });
+        transaction.transferObjects([ctokens], transaction.pure.address(ownerId));
     }
-    withdraw(obligationOwnerCap_1, obligationId_1, coinType_1, value_1, transaction_1) {
-        return __awaiter(this, arguments, void 0, function* (obligationOwnerCap, obligationId, coinType, value, transaction, addRefreshCalls = true) {
-            if (addRefreshCalls) {
-                const obligation = yield this.getObligation(obligationId);
-                if (!obligation)
-                    throw new Error("Error: no obligation");
-                yield this.refreshAll(transaction, obligation);
-            }
-            const [ctokens] = withdrawCtokens(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
-                lendingMarket: transaction.object(this.lendingMarket.id),
-                reserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(coinType)),
-                obligationOwnerCap,
-                clock: transaction.object(SUI_CLOCK_OBJECT_ID),
-                amount: BigInt(value),
-            });
-            const [exemption] = transaction.moveCall({
-                target: `0x1::option::none`,
-                typeArguments: [
-                    `${PACKAGE_ID}::lending_market::RateLimiterExemption<${this.lendingMarket.$typeArgs[0]}, ${coinType}>`,
-                ],
-                arguments: [],
-            });
-            return this.redeem(ctokens, coinType, exemption, transaction);
+    async withdraw(obligationOwnerCap, obligationId, coinType, value, transaction, addRefreshCalls = true) {
+        if (addRefreshCalls) {
+            const obligation = await this.getObligation(obligationId);
+            if (!obligation)
+                throw new Error("Error: no obligation");
+            await this.refreshAll(transaction, obligation);
+        }
+        const [ctokens] = withdrawCtokens(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
+            lendingMarket: transaction.object(this.lendingMarket.id),
+            reserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(coinType)),
+            obligationOwnerCap,
+            clock: transaction.object(SUI_CLOCK_OBJECT_ID),
+            amount: BigInt(value),
+        });
+        const [exemption] = transaction.moveCall({
+            target: `0x1::option::none`,
+            typeArguments: [
+                `${PACKAGE_ID}::lending_market::RateLimiterExemption<${this.lendingMarket.$typeArgs[0]}, ${coinType}>`,
+            ],
+            arguments: [],
         });
+        return this.redeem(ctokens, coinType, exemption, transaction);
     }
     redeem(ctokens, coinType, exemption, transaction) {
         const [liquidityRequest] = redeemCtokensAndWithdrawLiquidityRequest(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
@@ -479,47 +441,41 @@ export class SuilendClient {
             liquidityRequest,
         });
     }
-    withdrawAndSendToUser(ownerId, obligationOwnerCap, obligationId, coinType, value, transaction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [withdrawCoin] = yield this.withdraw(obligationOwnerCap, obligationId, coinType, value, transaction);
-            transaction.transferObjects([withdrawCoin], transaction.pure.address(ownerId));
-        });
+    async withdrawAndSendToUser(ownerId, obligationOwnerCap, obligationId, coinType, value, transaction) {
+        const [withdrawCoin] = await this.withdraw(obligationOwnerCap, obligationId, coinType, value, transaction);
+        transaction.transferObjects([withdrawCoin], transaction.pure.address(ownerId));
     }
-    borrow(obligationOwnerCap_1, obligationId_1, coinType_1, value_1, transaction_1) {
-        return __awaiter(this, arguments, void 0, function* (obligationOwnerCap, obligationId, coinType, value, transaction, addRefreshCalls = true) {
-            if (addRefreshCalls) {
-                const obligation = yield this.getObligation(obligationId);
-                if (!obligation)
-                    throw new Error("Error: no obligation");
-                yield this.refreshAll(transaction, obligation, [coinType]);
-            }
-            const [liquidityRequest] = borrowRequest(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
-                lendingMarket: transaction.object(this.lendingMarket.id),
-                reserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(coinType)),
-                obligationOwnerCap,
-                clock: transaction.object(SUI_CLOCK_OBJECT_ID),
-                amount: BigInt(value),
-            });
-            if (isSui(coinType)) {
-                unstakeSuiFromStaker(transaction, this.lendingMarket.$typeArgs[0], {
-                    lendingMarket: transaction.object(this.lendingMarket.id),
-                    suiReserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(coinType)),
-                    liquidityRequest,
-                    systemState: transaction.object(SUI_SYSTEM_STATE_OBJECT_ID),
-                });
-            }
-            return fulfillLiquidityRequest(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
+    async borrow(obligationOwnerCap, obligationId, coinType, value, transaction, addRefreshCalls = true) {
+        if (addRefreshCalls) {
+            const obligation = await this.getObligation(obligationId);
+            if (!obligation)
+                throw new Error("Error: no obligation");
+            await this.refreshAll(transaction, obligation, [coinType]);
+        }
+        const [liquidityRequest] = borrowRequest(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
+            lendingMarket: transaction.object(this.lendingMarket.id),
+            reserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(coinType)),
+            obligationOwnerCap,
+            clock: transaction.object(SUI_CLOCK_OBJECT_ID),
+            amount: BigInt(value),
+        });
+        if (isSui(coinType)) {
+            unstakeSuiFromStaker(transaction, this.lendingMarket.$typeArgs[0], {
                 lendingMarket: transaction.object(this.lendingMarket.id),
-                reserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(coinType)),
+                suiReserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(coinType)),
                 liquidityRequest,
+                systemState: transaction.object(SUI_SYSTEM_STATE_OBJECT_ID),
             });
+        }
+        return fulfillLiquidityRequest(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
+            lendingMarket: transaction.object(this.lendingMarket.id),
+            reserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(coinType)),
+            liquidityRequest,
         });
     }
-    borrowAndSendToUser(ownerId, obligationOwnerCap, obligationId, coinType, value, transaction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [borrowCoin] = yield this.borrow(obligationOwnerCap, obligationId, coinType, value, transaction);
-            transaction.transferObjects([borrowCoin], transaction.pure.address(ownerId));
-        });
+    async borrowAndSendToUser(ownerId, obligationOwnerCap, obligationId, coinType, value, transaction) {
+        const [borrowCoin] = await this.borrow(obligationOwnerCap, obligationId, coinType, value, transaction);
+        transaction.transferObjects([borrowCoin], transaction.pure.address(ownerId));
     }
     repay(obligationId, coinType, coin, transaction) {
         return repay(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
@@ -530,38 +486,32 @@ export class SuilendClient {
             maxRepayCoins: coin,
         });
     }
-    repayIntoObligation(ownerId, obligationId, coinType, value, transaction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sendCoin = yield getSpendableCoin(this.suiGrpcClient, ownerId, coinType, value, transaction);
-            const result = this.repay(obligationId, coinType, sendCoin, transaction);
-            transaction.transferObjects([sendCoin], transaction.pure.address(ownerId));
-            return result;
-        });
+    async repayIntoObligation(ownerId, obligationId, coinType, value, transaction) {
+        const sendCoin = await getSpendableCoin(this.suiGrpcClient, ownerId, coinType, value, transaction);
+        const result = this.repay(obligationId, coinType, sendCoin, transaction);
+        transaction.transferObjects([sendCoin], transaction.pure.address(ownerId));
+        return result;
     }
-    liquidateAndRedeem(transaction, obligation, repayCoinType, withdrawCoinType, repayCoinId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [ctokens, exemption] = yield this.liquidate(transaction, obligation, repayCoinType, withdrawCoinType, repayCoinId);
-            const [optionalExemption] = transaction.moveCall({
-                target: `0x1::option::some`,
-                typeArguments: [
-                    `${PUBLISHED_AT}::lending_market::RateLimiterExemption<${this.lendingMarket.$typeArgs[0]}, ${withdrawCoinType}>`,
-                ],
-                arguments: [exemption],
-            });
-            return this.redeem(ctokens, withdrawCoinType, optionalExemption, transaction);
+    async liquidateAndRedeem(transaction, obligation, repayCoinType, withdrawCoinType, repayCoinId) {
+        const [ctokens, exemption] = await this.liquidate(transaction, obligation, repayCoinType, withdrawCoinType, repayCoinId);
+        const [optionalExemption] = transaction.moveCall({
+            target: `0x1::option::some`,
+            typeArguments: [
+                `${PUBLISHED_AT}::lending_market::RateLimiterExemption<${this.lendingMarket.$typeArgs[0]}, ${withdrawCoinType}>`,
+            ],
+            arguments: [exemption],
         });
+        return this.redeem(ctokens, withdrawCoinType, optionalExemption, transaction);
     }
-    liquidate(transaction, obligation, repayCoinType, withdrawCoinType, repayCoinId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.refreshAll(transaction, obligation);
-            return liquidate(transaction, [this.lendingMarket.$typeArgs[0], repayCoinType, withdrawCoinType], {
-                lendingMarket: transaction.object(this.lendingMarket.id),
-                obligationId: obligation.id,
-                repayReserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(repayCoinType)),
-                withdrawReserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(withdrawCoinType)),
-                clock: transaction.object(SUI_CLOCK_OBJECT_ID),
-                repayCoins: repayCoinId,
-            });
+    async liquidate(transaction, obligation, repayCoinType, withdrawCoinType, repayCoinId) {
+        await this.refreshAll(transaction, obligation);
+        return liquidate(transaction, [this.lendingMarket.$typeArgs[0], repayCoinType, withdrawCoinType], {
+            lendingMarket: transaction.object(this.lendingMarket.id),
+            obligationId: obligation.id,
+            repayReserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(repayCoinType)),
+            withdrawReserveArrayIndex: transaction.pure.u64(this.findReserveArrayIndex(withdrawCoinType)),
+            clock: transaction.object(SUI_CLOCK_OBJECT_ID),
+            repayCoins: repayCoinId,
         });
     }
     migrate(transaction, lendingMarketOwnerCapId) {
@@ -585,25 +535,23 @@ export class SuilendClient {
             weights,
         });
     }
-    redeemCtokensAndWithdrawLiquidity(ownerId, ctokenCoinTypes, transaction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const ctokenCoinType of ctokenCoinTypes) {
-                const coins = yield getAllCoins(this.suiGrpcClient, ownerId, ctokenCoinType);
-                const totalBalance = coins.reduce((sum, c) => sum + BigInt(c.balance), BigInt(0));
-                if (totalBalance === BigInt(0))
-                    throw new Error(`No ${ctokenCoinType} coins found for redeem`);
-                const ctokenCoin = yield getSpendableCoin(this.suiGrpcClient, ownerId, ctokenCoinType, totalBalance.toString(), transaction);
-                const coinType = extractCTokenCoinType(ctokenCoinType);
-                const [exemption] = transaction.moveCall({
-                    target: `0x1::option::none`,
-                    typeArguments: [
-                        `${PACKAGE_ID}::lending_market::RateLimiterExemption<${this.lendingMarket.$typeArgs[0]}, ${coinType}>`,
-                    ],
-                    arguments: [],
-                });
-                const [redeemCoin] = this.redeem(ctokenCoin, coinType, exemption, transaction);
-                transaction.transferObjects([redeemCoin], transaction.pure.address(ownerId));
-            }
-        });
+    async redeemCtokensAndWithdrawLiquidity(ownerId, ctokenCoinTypes, transaction) {
+        for (const ctokenCoinType of ctokenCoinTypes) {
+            const coins = await getAllCoins(this.suiGrpcClient, ownerId, ctokenCoinType);
+            const totalBalance = coins.reduce((sum, c) => sum + BigInt(c.balance), BigInt(0));
+            if (totalBalance === BigInt(0))
+                throw new Error(`No ${ctokenCoinType} coins found for redeem`);
+            const ctokenCoin = await getSpendableCoin(this.suiGrpcClient, ownerId, ctokenCoinType, totalBalance.toString(), transaction);
+            const coinType = extractCTokenCoinType(ctokenCoinType);
+            const [exemption] = transaction.moveCall({
+                target: `0x1::option::none`,
+                typeArguments: [
+                    `${PACKAGE_ID}::lending_market::RateLimiterExemption<${this.lendingMarket.$typeArgs[0]}, ${coinType}>`,
+                ],
+                arguments: [],
+            });
+            const [redeemCoin] = this.redeem(ctokenCoin, coinType, exemption, transaction);
+            transaction.transferObjects([redeemCoin], transaction.pure.address(ownerId));
+        }
     }
 }