@suilend/sdk 1.0.9 → 1.1.1

package/core/client.js

@@ -10,19 +10,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 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 utils_1 = require("@mysten/sui/utils");
+const pyth_sui_js_1 = require("@pythnetwork/pyth-sui-js");
 const types_1 = require("./types");
+const utils_2 = require("./utils");
 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, closePoolReward, claimRewards, claimRewardsAndDeposit, createRateLimiterConfig, updateRateLimiterConfig, refreshReservePrice, depositLiquidityAndMintCtokens, depositCtokensIntoObligation, withdrawCtokens, borrow, repay, liquidate, migrate, }) {
+    constructor(lendingMarket, client, { phantom, PACKAGE_ID, PUBLISHED_AT, LendingMarket, Obligation, ObligationOwnerCap, createLendingMarket, createReserveConfig, updateReserveConfig, addReserve, addPoolReward, cancelPoolReward, closePoolReward, claimRewards, claimRewardsAndDeposit, createRateLimiterConfig, updateRateLimiterConfig, refreshReservePrice, depositLiquidityAndMintCtokens, depositCtokensIntoObligation, withdrawCtokens, borrow, repay, liquidate, migrate, claimFees, redeemCtokensAndWithdrawLiquidity, }) {
         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.pythClient = new pyth_sui_js_1.SuiPythClient(client, PYTH_STATE_ID, WORMHOLE_STATE_ID);
+        this.pythConnection = new pyth_sui_js_1.SuiPriceServiceConnection("https://hermes.pyth.network");
         this.phantom = phantom;
         this.PACKAGE_ID = PACKAGE_ID;
         this.PUBLISHED_AT = PUBLISHED_AT;
@@ -49,6 +49,9 @@ class SuilendClient {
         this.repayFunction = repay;
         this.liquidateFunction = liquidate;
         this.migrateFunction = migrate;
+        this.claimFeesFunction = claimFees;
+        this.redeemCtokensAndWithdrawLiquidityFunction =
+            redeemCtokensAndWithdrawLiquidity;
     }
     static initialize(lendingMarketId, lendingMarketType, client, deps) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -72,10 +75,10 @@ class SuilendClient {
             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({
+    static createNewLendingMarket(registryId_1, lendingMarketType_1, transaction_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (registryId, lendingMarketType, transaction, { LendingMarket, createLendingMarket, }) {
+            const [ownerCap, lendingMarket] = createLendingMarket(transaction, lendingMarketType, transaction.object(registryId));
+            transaction.moveCall({
                 target: `0x2::transfer::public_share_object`,
                 typeArguments: [`${LendingMarket.$typeName}<${lendingMarketType}>}`],
                 arguments: [lendingMarket],
@@ -104,7 +107,7 @@ class SuilendClient {
                     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)));
+                    obligationOwnerCaps.push(ObligationOwnerCap.fromBcs(phantom(lendingMarketTypeArgs[0]), (0, utils_1.fromBase64)((_d = (_c = obj.data) === null || _c === void 0 ? void 0 : _c.bcs) === null || _d === void 0 ? void 0 : _d.bcsBytes)));
                 });
                 return obligationOwnerCaps;
             }
@@ -123,7 +126,7 @@ class SuilendClient {
             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));
+            const obligation = Obligation.fromBcs(phantom(lendingMarketTypeArgs[0]), (0, utils_1.fromBase64)(obligationData.data.bcs.bcsBytes));
             return obligation;
         });
     }
@@ -150,20 +153,20 @@ class SuilendClient {
             return SuilendClient.getLendingMarketOwnerCapId(ownerId, this.lendingMarket.$typeArgs, this.client, { PACKAGE_ID: this.PACKAGE_ID });
         });
     }
-    createReserve(lendingMarketOwnerCapId, txb, pythPriceId, coinType, createReserveConfigArgs) {
+    createReserve(lendingMarketOwnerCapId, transaction, pythPriceId, coinType, createReserveConfigArgs) {
         return __awaiter(this, void 0, void 0, function* () {
-            const [config] = this.createReserveConfigFunction(txb, createReserveConfigArgs);
+            const [config] = this.createReserveConfigFunction(transaction, createReserveConfigArgs);
             const priceUpdateData = yield this.pythConnection.getPriceFeedsUpdateData([
                 pythPriceId,
             ]);
-            const priceInfoObjectIds = yield this.pythClient.updatePriceFeeds(txb, priceUpdateData, [pythPriceId]);
+            const priceInfoObjectIds = yield this.pythClient.updatePriceFeeds(transaction, 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], {
+            return this.addReserveFunction(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
                 lendingMarketOwnerCap: lendingMarketOwnerCapId,
                 lendingMarket: this.lendingMarket.id,
                 priceInfo: priceInfoObjectIds[0],
@@ -173,19 +176,19 @@ class SuilendClient {
             });
         });
     }
-    addReward(ownerId, lendingMarketOwnerCapId, reserveArrayIndex, isDepositReward, rewardCoinType, rewardValue, startTimeMs, endTimeMs, txb) {
+    addReward(ownerId, lendingMarketOwnerCapId, reserveArrayIndex, isDepositReward, rewardCoinType, rewardValue, startTimeMs, endTimeMs, transaction) {
         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];
+            const mergeCoin = coins[0];
             if (coins.length > 1 && !isSui) {
-                txb.mergeCoins(txb.object(mergedCoin.coinObjectId), coins.map((c) => txb.object(c.coinObjectId)).slice(1));
+                transaction.mergeCoins(transaction.object(mergeCoin.coinObjectId), coins.map((c) => transaction.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], {
+            const [rewardCoin] = transaction.splitCoins(isSui ? transaction.gas : transaction.object(mergeCoin.coinObjectId), [rewardValue]);
+            return this.addPoolRewardFunction(transaction, [this.lendingMarket.$typeArgs[0], rewardCoinType], {
                 lendingMarketOwnerCap: lendingMarketOwnerCapId,
                 lendingMarket: this.lendingMarket.id,
                 reserveArrayIndex,
@@ -197,8 +200,8 @@ class SuilendClient {
             });
         });
     }
-    cancelReward(lendingMarketOwnerCapId, reserveArrayIndex, isDepositReward, rewardIndex, rewardCoinType, txb) {
-        return this.cancelPoolRewardFunction(txb, [this.lendingMarket.$typeArgs[0], rewardCoinType], {
+    cancelReward(lendingMarketOwnerCapId, reserveArrayIndex, isDepositReward, rewardIndex, rewardCoinType, transaction) {
+        return this.cancelPoolRewardFunction(transaction, [this.lendingMarket.$typeArgs[0], rewardCoinType], {
             lendingMarketOwnerCap: lendingMarketOwnerCapId,
             lendingMarket: this.lendingMarket.id,
             reserveArrayIndex,
@@ -207,8 +210,8 @@ class SuilendClient {
             clock: utils_1.SUI_CLOCK_OBJECT_ID,
         });
     }
-    closeReward(lendingMarketOwnerCapId, reserveArrayIndex, isDepositReward, rewardIndex, rewardCoinType, txb) {
-        return this.closePoolRewardFunction(txb, [this.lendingMarket.$typeArgs[0], rewardCoinType], {
+    closeReward(lendingMarketOwnerCapId, reserveArrayIndex, isDepositReward, rewardIndex, rewardCoinType, transaction) {
+        return this.closePoolRewardFunction(transaction, [this.lendingMarket.$typeArgs[0], rewardCoinType], {
             lendingMarketOwnerCap: lendingMarketOwnerCapId,
             lendingMarket: this.lendingMarket.id,
             reserveArrayIndex,
@@ -217,38 +220,43 @@ class SuilendClient {
             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),
+    claimReward(obligationOwnerCapId, reserveArrayIndex, rewardIndex, rewardType, side, transaction) {
+        return this.claimRewardsFunction(transaction, [this.lendingMarket.$typeArgs[0], rewardType], {
+            lendingMarket: transaction.object(this.lendingMarket.id),
+            cap: transaction.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),
+    claimRewardsAndDeposit(obligationId, rewardReserveArrayIndex, rewardIndex, rewardType, side, depositReserveArrayIndex, transaction) {
+        return this.claimRewardsAndDepositFunction(transaction, [this.lendingMarket.$typeArgs[0], rewardType], {
+            lendingMarket: transaction.object(this.lendingMarket.id),
             obligationId,
-            clock: txb.object(utils_1.SUI_CLOCK_OBJECT_ID),
+            clock: transaction.object(utils_1.SUI_CLOCK_OBJECT_ID),
             rewardReserveId: rewardReserveArrayIndex,
             rewardIndex,
             isDepositReward: side === types_1.Side.DEPOSIT,
             depositReserveId: depositReserveArrayIndex,
         });
     }
-    claimRewardsToObligation(ownerId, rewards, txb) {
+    claimRewardsToObligation(ownerId, rewards, transaction) {
         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));
+            const mergeCoinsMap = {};
+            for (const reward of rewards) {
+                const [claimedCoin] = this.claimReward(reward.obligationOwnerCapId, reward.reserveArrayIndex, reward.rewardIndex, reward.rewardType, reward.side, transaction);
+                if (mergeCoinsMap[reward.rewardType] === undefined)
+                    mergeCoinsMap[reward.rewardType] = [];
+                mergeCoinsMap[reward.rewardType].push(claimedCoin);
+            }
+            for (const mergeCoins of Object.values(mergeCoinsMap)) {
+                const mergeCoin = mergeCoins[0];
+                if (mergeCoins.length > 1) {
+                    transaction.mergeCoins(mergeCoin, mergeCoins.slice(1));
+                }
+                transaction.transferObjects([mergeCoin], transaction.pure.address(ownerId));
             }
-            txb.transferObjects([mergedCoin], txb.pure(ownerId));
         });
     }
     findReserveArrayIndex(coinType) {
@@ -256,21 +264,21 @@ class SuilendClient {
         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) {
+    updateReserveConfig(ownerId, lendingMarketOwnerCapId, transaction, coinType, createReserveConfigArgs) {
         return __awaiter(this, void 0, void 0, function* () {
-            const [config] = this.createReserveConfigFunction(txb, createReserveConfigArgs);
-            return this.updateReserveConfigFunction(txb, [...this.lendingMarket.$typeArgs, coinType], {
+            const [config] = this.createReserveConfigFunction(transaction, createReserveConfigArgs);
+            return this.updateReserveConfigFunction(transaction, [...this.lendingMarket.$typeArgs, coinType], {
                 lendingMarketOwnerCap: lendingMarketOwnerCapId,
                 lendingMarket: this.lendingMarket.id,
-                config,
                 reserveArrayIndex: this.findReserveArrayIndex(coinType),
+                config,
             });
         });
     }
-    updateRateLimiterConfig(lendingMarketOwnerCapId, txb, newRateLimiterConfigArgs) {
+    updateRateLimiterConfig(lendingMarketOwnerCapId, transaction, newRateLimiterConfigArgs) {
         return __awaiter(this, void 0, void 0, function* () {
-            const [config] = this.createRateLimiterConfigFunction(txb, newRateLimiterConfigArgs);
-            return this.updateRateLimiterConfigFunction(txb, this.lendingMarket.$typeArgs[0], {
+            const [config] = this.createRateLimiterConfigFunction(transaction, newRateLimiterConfigArgs);
+            return this.updateRateLimiterConfigFunction(transaction, this.lendingMarket.$typeArgs[0], {
                 lendingMarketOwnerCap: lendingMarketOwnerCapId,
                 lendingMarket: this.lendingMarket.id,
                 clock: utils_1.SUI_CLOCK_OBJECT_ID,
@@ -278,225 +286,281 @@ class SuilendClient {
             });
         });
     }
-    createObligation(txb) {
-        return txb.moveCall({
+    createObligation(transaction) {
+        return transaction.moveCall({
             target: `${this.PUBLISHED_AT}::lending_market::create_obligation`,
-            arguments: [txb.object(this.lendingMarket.id)],
+            arguments: [transaction.object(this.lendingMarket.id)],
             typeArguments: this.lendingMarket.$typeArgs,
         });
     }
-    refreshAll(txb, obligation, extraReserveArrayIndex) {
+    refreshAll(transaction, 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)));
+                reserveArrayIndexToPriceId.set(deposit.reserveArrayIndex, (0, utils_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)));
+                reserveArrayIndexToPriceId.set(borrow.reserveArrayIndex, (0, utils_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)));
+                reserveArrayIndexToPriceId.set(extraReserveArrayIndex, (0, utils_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 priceIds = Array.from(tuples.map((tuple) => tuple[1]));
             const priceUpdateData = yield this.pythConnection.getPriceFeedsUpdateData(priceIds);
-            const priceInfoObjectIds = yield this.pythClient.updatePriceFeeds(txb, priceUpdateData, priceIds);
+            const priceInfoObjectIds = yield this.pythClient.updatePriceFeeds(transaction, priceUpdateData, priceIds);
             for (let i = 0; i < tuples.length; i++) {
-                this.refreshReservePrices(txb, priceInfoObjectIds[i], tuples[i][0]);
+                this.refreshReservePrices(transaction, priceInfoObjectIds[i], tuples[i][0]);
             }
         });
     }
-    refreshReservePrices(txb, priceInfoObjectId, reserveArrayIndex) {
+    refreshReservePrices(transaction, priceInfoObjectId, reserveArrayIndex) {
         return __awaiter(this, void 0, void 0, function* () {
             if (priceInfoObjectId == null) {
                 return;
             }
-            this.refreshReservePriceFunction(txb, this.lendingMarket.$typeArgs[0], {
+            this.refreshReservePriceFunction(transaction, this.lendingMarket.$typeArgs[0], {
                 lendingMarket: this.lendingMarket.id,
+                reserveArrayIndex,
                 clock: utils_1.SUI_CLOCK_OBJECT_ID,
                 priceInfo: priceInfoObjectId,
-                reserveArrayIndex,
             });
         });
     }
-    deposit(sendCoin, coinType, obligationOwnerCap, txb) {
+    deposit(sendCoin, coinType, obligationOwnerCap, transaction) {
         return __awaiter(this, void 0, void 0, function* () {
-            const [ctokens] = this.depositLiquidityAndMintCtokensFunction(txb, [this.lendingMarket.$typeArgs[0], coinType], {
+            const [ctokens] = this.depositLiquidityAndMintCtokensFunction(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
                 lendingMarket: this.lendingMarket.id,
+                reserveArrayIndex: this.findReserveArrayIndex(coinType),
                 clock: utils_1.SUI_CLOCK_OBJECT_ID,
                 deposit: sendCoin,
-                reserveArrayIndex: this.findReserveArrayIndex(coinType),
             });
-            this.depositCtokensIntoObligationFunction(txb, [this.lendingMarket.$typeArgs[0], coinType], {
+            this.depositCtokensIntoObligationFunction(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
                 lendingMarket: this.lendingMarket.id,
+                reserveArrayIndex: this.findReserveArrayIndex(coinType),
                 obligationOwnerCap,
-                deposit: ctokens,
                 clock: utils_1.SUI_CLOCK_OBJECT_ID,
-                reserveArrayIndex: this.findReserveArrayIndex(coinType),
+                deposit: ctokens,
             });
         });
     }
-    depositCoin(ownerId, sendCoin, coinType, txb, obligationOwnerCapId) {
+    depositCoin(ownerId, sendCoin, coinType, transaction, obligationOwnerCapId) {
         return __awaiter(this, void 0, void 0, function* () {
             let createdObligationOwnerCap;
             if (!obligationOwnerCapId) {
-                createdObligationOwnerCap = this.createObligation(txb)[0];
+                createdObligationOwnerCap = this.createObligation(transaction)[0];
             }
-            this.deposit(sendCoin, coinType, (obligationOwnerCapId !== null && obligationOwnerCapId !== void 0 ? obligationOwnerCapId : createdObligationOwnerCap), txb);
+            this.deposit(sendCoin, coinType, (obligationOwnerCapId !== null && obligationOwnerCapId !== void 0 ? obligationOwnerCapId : createdObligationOwnerCap), transaction);
             if (createdObligationOwnerCap) {
-                txb.transferObjects([createdObligationOwnerCap], txb.pure(ownerId));
+                transaction.transferObjects([createdObligationOwnerCap], transaction.pure.address(ownerId));
             }
         });
     }
-    depositIntoObligation(ownerId, coinType, value, txb, obligationOwnerCapId) {
+    depositIntoObligation(ownerId, coinType, value, transaction, obligationOwnerCapId) {
         return __awaiter(this, void 0, void 0, function* () {
             const isSui = (0, utils_1.normalizeStructTag)(coinType) === (0, utils_1.normalizeStructTag)(SUI_COINTYPE);
             const coins = (yield this.client.getCoins({
                 owner: ownerId,
                 coinType,
             })).data;
-            const mergedCoin = coins[0];
+            const mergeCoin = coins[0];
             if (coins.length > 1 && !isSui) {
-                txb.mergeCoins(txb.object(mergedCoin.coinObjectId), coins.map((c) => txb.object(c.coinObjectId)).slice(1));
+                transaction.mergeCoins(transaction.object(mergeCoin.coinObjectId), coins.map((c) => transaction.object(c.coinObjectId)).slice(1));
             }
-            const [sendCoin] = txb.splitCoins(isSui ? txb.gas : txb.object(mergedCoin.coinObjectId), [txb.pure(value)]);
-            this.depositCoin(ownerId, sendCoin, coinType, txb, obligationOwnerCapId);
+            const [sendCoin] = transaction.splitCoins(isSui ? transaction.gas : transaction.object(mergeCoin.coinObjectId), [value]);
+            this.depositCoin(ownerId, sendCoin, coinType, transaction, obligationOwnerCapId);
         });
     }
-    withdraw(obligationOwnerCapId, obligationId, coinType, value, txb) {
+    depositLiquidityAndGetCTokens(ownerId, coinType, value, transaction) {
+        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 mergeCoin = coins[0];
+            if (coins.length > 1 && !isSui) {
+                transaction.mergeCoins(transaction.object(mergeCoin.coinObjectId), coins.map((c) => transaction.object(c.coinObjectId)).slice(1));
+            }
+            const [sendCoin] = transaction.splitCoins(isSui ? transaction.gas : transaction.object(mergeCoin.coinObjectId), [value]);
+            const [ctokens] = this.depositLiquidityAndMintCtokensFunction(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
+                lendingMarket: this.lendingMarket.id,
+                reserveArrayIndex: this.findReserveArrayIndex(coinType),
+                clock: utils_1.SUI_CLOCK_OBJECT_ID,
+                deposit: sendCoin,
+            });
+            transaction.transferObjects([ctokens], transaction.pure.address(ownerId));
+        });
+    }
+    withdraw(obligationOwnerCapId, obligationId, coinType, value, transaction) {
         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], {
+            yield this.refreshAll(transaction, obligation);
+            const [ctokens] = this.withdrawCtokensFunction(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
                 lendingMarket: this.lendingMarket.id,
+                reserveArrayIndex: this.findReserveArrayIndex(coinType),
                 obligationOwnerCap: obligationOwnerCapId,
                 clock: utils_1.SUI_CLOCK_OBJECT_ID,
                 amount: BigInt(value),
-                reserveArrayIndex: this.findReserveArrayIndex(coinType),
             });
-            const [exemption] = txb.moveCall({
+            const [exemption] = transaction.moveCall({
                 target: `0x1::option::none`,
                 typeArguments: [
                     `${this.PACKAGE_ID}::lending_market::RateLimiterExemption<${this.lendingMarket.$typeArgs[0]}, ${coinType}>`,
                 ],
                 arguments: [],
             });
-            return txb.moveCall({
+            return transaction.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),
+                    transaction.object(this.lendingMarket.id),
+                    transaction.pure.u64(this.findReserveArrayIndex(coinType)),
+                    transaction.object(utils_1.SUI_CLOCK_OBJECT_ID),
                     ctokens,
                     exemption,
                 ],
             });
         });
     }
-    withdrawFromObligation(ownerId, obligationOwnerCapId, obligationId, coinType, value, txb) {
+    withdrawFromObligation(ownerId, obligationOwnerCapId, obligationId, coinType, value, transaction) {
         return __awaiter(this, void 0, void 0, function* () {
-            const [withdrawCoin] = yield this.withdraw(obligationOwnerCapId, obligationId, coinType, value, txb);
-            txb.transferObjects([withdrawCoin], txb.pure(ownerId));
+            const [withdrawCoin] = yield this.withdraw(obligationOwnerCapId, obligationId, coinType, value, transaction);
+            transaction.transferObjects([withdrawCoin], transaction.pure.address(ownerId));
         });
     }
-    borrow(obligationOwnerCapId, obligationId, coinType, value, txb) {
+    borrow(obligationOwnerCapId, obligationId, coinType, value, transaction) {
         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], {
+            yield this.refreshAll(transaction, obligation, this.findReserveArrayIndex(coinType));
+            const result = this.borrowFunction(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
                 lendingMarket: this.lendingMarket.id,
+                reserveArrayIndex: this.findReserveArrayIndex(coinType),
                 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) {
+    borrowFromObligation(ownerId, obligationOwnerCapId, obligationId, coinType, value, transaction) {
         return __awaiter(this, void 0, void 0, function* () {
-            const [borrowCoin] = yield this.borrow(obligationOwnerCapId, obligationId, coinType, value, txb);
-            txb.transferObjects([borrowCoin], txb.pure(ownerId));
+            const [borrowCoin] = yield this.borrow(obligationOwnerCapId, obligationId, coinType, value, transaction);
+            transaction.transferObjects([borrowCoin], transaction.pure.address(ownerId));
         });
     }
-    repay(obligationId, coinType, coin, txb) {
-        return this.repayFunction(txb, [this.lendingMarket.$typeArgs[0], coinType], {
+    repay(obligationId, coinType, coin, transaction) {
+        return this.repayFunction(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
             lendingMarket: this.lendingMarket.id,
+            reserveArrayIndex: this.findReserveArrayIndex(coinType),
             obligationId: obligationId,
             clock: utils_1.SUI_CLOCK_OBJECT_ID,
             maxRepayCoins: coin,
-            reserveArrayIndex: this.findReserveArrayIndex(coinType),
         });
     }
-    repayIntoObligation(ownerId, obligationId, coinType, value, txb) {
+    repayIntoObligation(ownerId, obligationId, coinType, value, transaction) {
         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];
+            const mergeCoin = coins[0];
             if (coins.length > 1 && !isSui) {
-                txb.mergeCoins(txb.object(mergedCoin.coinObjectId), coins.map((c) => txb.object(c.coinObjectId)).slice(1));
+                transaction.mergeCoins(transaction.object(mergeCoin.coinObjectId), coins.map((c) => transaction.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);
+            const [sendCoin] = transaction.splitCoins(isSui ? transaction.gas : transaction.object(mergeCoin.coinObjectId), [value]);
+            const result = this.repay(obligationId, coinType, sendCoin, transaction);
+            transaction.transferObjects([sendCoin], ownerId);
             return result;
         });
     }
-    liquidateAndRedeem(txb, obligation, repayCoinType, withdrawCoinType, repayCoinId) {
+    liquidateAndRedeem(transaction, 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({
+            const [ctokens, exemption] = yield this.liquidate(transaction, obligation, repayCoinType, withdrawCoinType, repayCoinId);
+            const [optionalExemption] = transaction.moveCall({
                 target: `0x1::option::some`,
                 typeArguments: [
                     `${this.PUBLISHED_AT}::lending_market::RateLimiterExemption<${this.lendingMarket.$typeArgs[0]}, ${withdrawCoinType}>`,
                 ],
                 arguments: [exemption],
             });
-            return txb.moveCall({
+            return transaction.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),
+                    transaction.object(this.lendingMarket.id),
+                    transaction.pure.u64(this.findReserveArrayIndex(withdrawCoinType)),
+                    transaction.object(utils_1.SUI_CLOCK_OBJECT_ID),
                     ctokens,
                     optionalExemption,
                 ],
             });
         });
     }
-    liquidate(txb, obligation, repayCoinType, withdrawCoinType, repayCoinId) {
+    liquidate(transaction, 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], {
+            yield this.refreshAll(transaction, obligation);
+            return this.liquidateFunction(transaction, [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),
+                clock: utils_1.SUI_CLOCK_OBJECT_ID,
+                repayCoins: repayCoinId,
             });
         });
     }
-    migrate(txb, lendingMarketOwnerCapId) {
+    migrate(transaction, lendingMarketOwnerCapId) {
+        return this.migrateFunction(transaction, this.lendingMarket.$typeArgs[0], {
+            lendingMarketOwnerCap: lendingMarketOwnerCapId,
+            lendingMarket: this.lendingMarket.id,
+        });
+    }
+    claimFees(transaction, coinType) {
+        return this.claimFeesFunction(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
+            lendingMarket: this.lendingMarket.id,
+            reserveArrayIndex: this.findReserveArrayIndex(coinType),
+        });
+    }
+    redeemCtokensAndWithdrawLiquidity(ownerId, ctokenCoinTypes, transaction) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.migrateFunction(txb, this.lendingMarket.$typeArgs[0], {
-                lendingMarket: this.lendingMarket.id,
-                lendingMarketOwnerCap: lendingMarketOwnerCapId,
-            });
+            const mergeCoinsMap = {};
+            for (const ctokenCoinType of ctokenCoinTypes) {
+                const coins = (yield this.client.getCoins({
+                    owner: ownerId,
+                    coinType: ctokenCoinType,
+                })).data;
+                if (coins.length === 0)
+                    continue;
+                if (mergeCoinsMap[ctokenCoinType] === undefined)
+                    mergeCoinsMap[ctokenCoinType] = [];
+                mergeCoinsMap[ctokenCoinType].push(...coins);
+            }
+            for (const [ctokenCoinType, mergeCoins] of Object.entries(mergeCoinsMap)) {
+                const mergeCoin = mergeCoins[0];
+                if (mergeCoins.length > 1) {
+                    transaction.mergeCoins(transaction.object(mergeCoin.coinObjectId), mergeCoins.map((mc) => transaction.object(mc.coinObjectId)).slice(1));
+                }
+                const coinType = (0, utils_2.extractCTokenCoinType)(ctokenCoinType);
+                const [redeemCoin] = this.redeemCtokensAndWithdrawLiquidityFunction(transaction, [this.lendingMarket.$typeArgs[0], coinType], {
+                    lendingMarket: this.lendingMarket.id,
+                    reserveArrayIndex: this.findReserveArrayIndex(coinType),
+                    clock: utils_1.SUI_CLOCK_OBJECT_ID,
+                    ctokens: transaction.object(mergeCoin.coinObjectId),
+                    rateLimiterExemption: null,
+                });
+                transaction.transferObjects([redeemCoin], transaction.pure.address(ownerId));
+            }
         });
     }
 }

package/core/parsers/apiReserveAssetDataEvent.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDownsampledApiReserveAssetDataEvent = exports.parseReserveAssetDataEvent = void 0;
-const utils_1 = require("@mysten/sui.js/utils");
+const utils_1 = require("@mysten/sui/utils");
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const constants_1 = require("../constants");
 const parseReserveAssetDataEvent = (event, reserve) => {

package/core/parsers/lendingMarket.d.ts

@@ -1,4 +1,4 @@
-import { CoinMetadata } from "@mysten/sui.js/client";
+import { CoinMetadata } from "@mysten/sui/client";
 import BigNumber from "bignumber.js";
 import { Deps } from "./deps";
 export type ParsedLendingMarket = ReturnType<typeof parseLendingMarket>;
@@ -21,7 +21,7 @@ export declare const parseLendingMarket: ({ LendingMarket, Reserve, PoolRewardMa
             borrowFeeBps: number;
             spreadFeeBps: number;
             protocolLiquidationFeeBps: number;
-            isolated: any;
+            isolated: boolean;
             openAttributedBorrowLimitUsd: number;
             closeAttributedBorrowLimitUsd: number;
             interestRate: {

package/core/parsers/lendingMarket.js

@@ -10,7 +10,19 @@ const reserve_1 = require("./reserve");
 const parseLendingMarket = ({ LendingMarket, Reserve, PoolRewardManager, PoolReward, simulate, RateLimiter, }, lendingMarket, reserves, coinMetadataMap, currentTime) => {
     const id = lendingMarket.id;
     const version = lendingMarket.version;
-    const parsedReserves = reserves.map((reserve) => (0, reserve_1.parseReserve)({ Reserve, PoolRewardManager, PoolReward, simulate }, reserve, coinMetadataMap));
+    const parsedReserves = reserves
+        .map((reserve) => (0, reserve_1.parseReserve)({ Reserve, PoolRewardManager, PoolReward, simulate }, reserve, coinMetadataMap))
+        .sort((a, b) => {
+        const customOrder = ["SUI", "wUSDC", "USDC"];
+        const aCustomOrderIndex = customOrder.indexOf(a.symbol);
+        const bCustomOrderIndex = customOrder.indexOf(b.symbol);
+        if (aCustomOrderIndex > -1 && bCustomOrderIndex > -1)
+            return aCustomOrderIndex - bCustomOrderIndex;
+        else if (aCustomOrderIndex === -1 && bCustomOrderIndex === -1)
+            return 0;
+        else
+            return aCustomOrderIndex > -1 ? -1 : 1;
+    });
     const obligations = lendingMarket.obligations;
     const parsedRateLimiter = (0, rateLimiter_1.parseRateLimiter)({ RateLimiter }, lendingMarket.rateLimiter, currentTime);
     const feeReceiver = lendingMarket.feeReceiver;