@suilend/sdk 1.0.0

package/mainnet/_generated/suilend/suilend/structs.js

@@ -0,0 +1,125 @@
+"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.MAIN_POOL = exports.isMAIN_POOL = void 0;
+const reified_1 = require("../../_framework/reified");
+const util_1 = require("../../_framework/util");
+const bcs_1 = require("@mysten/bcs");
+/* ============================== MAIN_POOL =============================== */
+function isMAIN_POOL(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return (type ===
+        "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::suilend::MAIN_POOL");
+}
+exports.isMAIN_POOL = isMAIN_POOL;
+class MAIN_POOL {
+    constructor(typeArgs, fields) {
+        this.$typeName = MAIN_POOL.$typeName;
+        this.$fullTypeName = (0, util_1.composeSuiType)(MAIN_POOL.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.dummyField = fields.dummyField;
+    }
+    static reified() {
+        return {
+            typeName: MAIN_POOL.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(MAIN_POOL.$typeName, ...[]),
+            typeArgs: [],
+            reifiedTypeArgs: [],
+            fromFields: (fields) => MAIN_POOL.fromFields(fields),
+            fromFieldsWithTypes: (item) => MAIN_POOL.fromFieldsWithTypes(item),
+            fromBcs: (data) => MAIN_POOL.fromBcs(data),
+            bcs: MAIN_POOL.bcs,
+            fromJSONField: (field) => MAIN_POOL.fromJSONField(field),
+            fromJSON: (json) => MAIN_POOL.fromJSON(json),
+            fromSuiParsedData: (content) => MAIN_POOL.fromSuiParsedData(content),
+            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return MAIN_POOL.fetch(client, id); }),
+            new: (fields) => {
+                return new MAIN_POOL([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return MAIN_POOL.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(MAIN_POOL.reified());
+    }
+    static get p() {
+        return MAIN_POOL.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("MAIN_POOL", {
+            dummy_field: bcs_1.bcs.bool(),
+        });
+    }
+    static fromFields(fields) {
+        return MAIN_POOL.reified().new({
+            dummyField: (0, reified_1.decodeFromFields)("bool", fields.dummy_field),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isMAIN_POOL(item.type)) {
+            throw new Error("not a MAIN_POOL type");
+        }
+        return MAIN_POOL.reified().new({
+            dummyField: (0, reified_1.decodeFromFieldsWithTypes)("bool", item.fields.dummy_field),
+        });
+    }
+    static fromBcs(data) {
+        return MAIN_POOL.fromFields(MAIN_POOL.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+    toJSON() {
+        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+    }
+    static fromJSONField(field) {
+        return MAIN_POOL.reified().new({
+            dummyField: (0, reified_1.decodeFromJSONField)("bool", field.dummyField),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== MAIN_POOL.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return MAIN_POOL.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isMAIN_POOL(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a MAIN_POOL object`);
+        }
+        return MAIN_POOL.fromFieldsWithTypes(content);
+    }
+    static fetch(client, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const res = yield client.getObject({ id, options: { showBcs: true } });
+            if (res.error) {
+                throw new Error(`error fetching MAIN_POOL object at id ${id}: ${res.error.code}`);
+            }
+            if (((_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.bcs) === null || _b === void 0 ? void 0 : _b.dataType) !== "moveObject" ||
+                !isMAIN_POOL(res.data.bcs.type)) {
+                throw new Error(`object at id ${id} is not a MAIN_POOL object`);
+            }
+            return MAIN_POOL.fromBcs((0, bcs_1.fromB64)(res.data.bcs.bcsBytes));
+        });
+    }
+}
+exports.MAIN_POOL = MAIN_POOL;
+MAIN_POOL.$typeName = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::suilend::MAIN_POOL";
+MAIN_POOL.$numTypeParams = 0;

package/mainnet/client.d.ts

@@ -0,0 +1,19 @@
+import { SuiClient } from "@mysten/sui.js/client";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { SuilendClient as BaseSuilendClient } from "../core/client";
+import { LendingMarket } from "./_generated/suilend/lending-market/structs";
+export declare const LENDING_MARKET_ID = "0x84030d26d85eaa7035084a057f2f11f701b7e2e4eda87551becbc7c97505ece1";
+export declare const LENDING_MARKET_TYPE = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::suilend::MAIN_POOL";
+export declare class SuilendClient<T extends string> extends BaseSuilendClient {
+    constructor(lendingMarket: LendingMarket<T>, client: SuiClient);
+    static initialize(lendingMarketId: string, lendingMarketType: string, client: SuiClient): Promise<BaseSuilendClient>;
+    static initializeWithLendingMarket(lendingMarket: LendingMarket<string>, client: SuiClient): Promise<BaseSuilendClient>;
+    static createNewLendingMarket(registryId: string, lendingMarketType: string, txb: TransactionBlock): Promise<{
+        index: number;
+        resultIndex: number;
+        kind: "NestedResult";
+    }>;
+    static getObligationOwnerCaps(ownerId: string, lendingMarketTypeArgs: string[], client: SuiClient): Promise<any[]>;
+    static getObligation(obligationId: string, lendingMarketTypeArgs: string[], client: SuiClient): Promise<any>;
+    static getLendingMarketOwnerCapId(ownerId: string, lendingMarketTypeArgs: string[], client: SuiClient): Promise<string | null>;
+}

package/mainnet/client.js

@@ -0,0 +1,108 @@
+"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 = exports.LENDING_MARKET_TYPE = exports.LENDING_MARKET_ID = void 0;
+const client_1 = require("../core/client");
+const reified_1 = require("./_generated/_framework/reified");
+const suilend_1 = require("./_generated/suilend");
+const functions_1 = require("./_generated/suilend/lending-market/functions");
+const structs_1 = require("./_generated/suilend/lending-market/structs");
+const functions_2 = require("./_generated/suilend/lending-market-registry/functions");
+const structs_2 = require("./_generated/suilend/obligation/structs");
+const functions_3 = require("./_generated/suilend/rate-limiter/functions");
+const functions_4 = require("./_generated/suilend/reserve-config/functions");
+exports.LENDING_MARKET_ID = "0x84030d26d85eaa7035084a057f2f11f701b7e2e4eda87551becbc7c97505ece1";
+exports.LENDING_MARKET_TYPE = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::suilend::MAIN_POOL";
+const deps = {
+    phantom: reified_1.phantom,
+    PACKAGE_ID: suilend_1.PACKAGE_ID,
+    PUBLISHED_AT: suilend_1.PUBLISHED_AT,
+    LendingMarket: structs_1.LendingMarket,
+    Obligation: structs_2.Obligation,
+    ObligationOwnerCap: structs_1.ObligationOwnerCap,
+    createLendingMarket: functions_2.createLendingMarket,
+    createReserveConfig: functions_4.createReserveConfig,
+    updateReserveConfig: functions_1.updateReserveConfig,
+    addReserve: functions_1.addReserve,
+    addPoolReward: functions_1.addPoolReward,
+    cancelPoolReward: functions_1.cancelPoolReward,
+    claimRewards: functions_1.claimRewards,
+    claimRewardsAndDeposit: functions_1.claimRewardsAndDeposit,
+    createRateLimiterConfig: functions_3.newConfig,
+    updateRateLimiterConfig: functions_1.updateRateLimiterConfig,
+    refreshReservePrice: functions_1.refreshReservePrice,
+    depositLiquidityAndMintCtokens: functions_1.depositLiquidityAndMintCtokens,
+    depositCtokensIntoObligation: functions_1.depositCtokensIntoObligation,
+    withdrawCtokens: functions_1.withdrawCtokens,
+    borrow: functions_1.borrow,
+    repay: functions_1.repay,
+    liquidate: functions_1.liquidate,
+};
+class SuilendClient extends client_1.SuilendClient {
+    constructor(lendingMarket, client) {
+        super(lendingMarket, client, deps);
+    }
+    static initialize(lendingMarketId, lendingMarketType, client) {
+        const _super = Object.create(null, {
+            initialize: { get: () => super.initialize }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.initialize.call(this, lendingMarketId, lendingMarketType, client, deps);
+        });
+    }
+    static initializeWithLendingMarket(lendingMarket, client) {
+        const _super = Object.create(null, {
+            initializeWithLendingMarket: { get: () => super.initializeWithLendingMarket }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.initializeWithLendingMarket.call(this, lendingMarket, client, deps);
+        });
+    }
+    static createNewLendingMarket(registryId, lendingMarketType, txb) {
+        const _super = Object.create(null, {
+            createNewLendingMarket: { get: () => super.createNewLendingMarket }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.createNewLendingMarket.call(this, registryId, lendingMarketType, txb, {
+                LendingMarket: structs_1.LendingMarket,
+                createLendingMarket: functions_2.createLendingMarket,
+            });
+        });
+    }
+    static getObligationOwnerCaps(ownerId, lendingMarketTypeArgs, client) {
+        const _super = Object.create(null, {
+            getObligationOwnerCaps: { get: () => super.getObligationOwnerCaps }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.getObligationOwnerCaps.call(this, ownerId, lendingMarketTypeArgs, client, { phantom: reified_1.phantom, PACKAGE_ID: suilend_1.PACKAGE_ID, ObligationOwnerCap: structs_1.ObligationOwnerCap });
+        });
+    }
+    static getObligation(obligationId, lendingMarketTypeArgs, client) {
+        const _super = Object.create(null, {
+            getObligation: { get: () => super.getObligation }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.getObligation.call(this, obligationId, lendingMarketTypeArgs, client, {
+                phantom: reified_1.phantom,
+                Obligation: structs_2.Obligation,
+            });
+        });
+    }
+    static getLendingMarketOwnerCapId(ownerId, lendingMarketTypeArgs, client) {
+        const _super = Object.create(null, {
+            getLendingMarketOwnerCapId: { get: () => super.getLendingMarketOwnerCapId }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.getLendingMarketOwnerCapId.call(this, ownerId, lendingMarketTypeArgs, client, { PACKAGE_ID: suilend_1.PACKAGE_ID });
+        });
+    }
+}
+exports.SuilendClient = SuilendClient;

package/mainnet/constants.d.ts

@@ -0,0 +1 @@
+export * from "../core/constants";

package/mainnet/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../core/constants"), exports);

package/mainnet/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./client";
+export * from "./types";

package/mainnet/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./types"), exports);

package/mainnet/parsers/lendingMarket.d.ts

@@ -0,0 +1,115 @@
+import { CoinMetadata } from "@mysten/sui.js/client";
+import { LendingMarket } from "../_generated/suilend/lending-market/structs";
+import { Reserve } from "../_generated/suilend/reserve/structs";
+export type ParsedLendingMarket = ReturnType<typeof parseLendingMarket>;
+export declare const parseLendingMarket: (lendingMarket: LendingMarket<string>, reserves: Reserve<string>[], coinMetadataMap: Record<string, CoinMetadata>, currentTime: number) => {
+    reserves: {
+        config: {
+            $typeName: any;
+            openLtvPct: any;
+            closeLtvPct: any;
+            maxCloseLtvPct: any;
+            borrowWeightBps: number;
+            depositLimit: import("bignumber.js").BigNumber;
+            borrowLimit: import("bignumber.js").BigNumber;
+            liquidationBonusBps: number;
+            maxLiquidationBonusBps: number;
+            depositLimitUsd: import("bignumber.js").BigNumber;
+            borrowLimitUsd: import("bignumber.js").BigNumber;
+            borrowFeeBps: number;
+            spreadFeeBps: number;
+            protocolLiquidationFeeBps: number;
+            isolated: any;
+            openAttributedBorrowLimitUsd: number;
+            closeAttributedBorrowLimitUsd: number;
+            interestRate: {
+                id: string;
+                utilPercent: import("bignumber.js").BigNumber;
+                aprPercent: import("bignumber.js").BigNumber;
+            }[];
+        };
+        $typeName: any;
+        id: any;
+        arrayIndex: any;
+        coinType: string;
+        mintDecimals: any;
+        priceIdentifier: string;
+        price: import("bignumber.js").BigNumber;
+        smoothedPrice: import("bignumber.js").BigNumber;
+        minPrice: import("bignumber.js").BigNumber;
+        maxPrice: import("bignumber.js").BigNumber;
+        priceLastUpdateTimestampS: any;
+        availableAmount: import("bignumber.js").BigNumber;
+        ctokenSupply: import("bignumber.js").BigNumber;
+        borrowedAmount: import("bignumber.js").BigNumber;
+        cumulativeBorrowRate: import("bignumber.js").BigNumber;
+        interestLastUpdateTimestampS: any;
+        unclaimedSpreadFees: import("bignumber.js").BigNumber;
+        attributedBorrowValue: import("bignumber.js").BigNumber;
+        depositsPoolRewardManager: {
+            $typeName: any;
+            id: any;
+            totalShares: any;
+            poolRewards: {
+                $typeName: any;
+                id: any;
+                rewardIndex: number;
+                poolRewardManagerId: any;
+                coinType: string;
+                startTimeMs: number;
+                endTimeMs: number;
+                totalRewards: import("bignumber.js").BigNumber;
+                allocatedRewards: import("bignumber.js").BigNumber;
+                cumulativeRewardsPerShare: import("bignumber.js").BigNumber;
+                numUserRewardManagers: any;
+                mintDecimals: number;
+                symbol: string;
+            }[];
+            lastUpdateTimeMs: any;
+        };
+        borrowsPoolRewardManager: {
+            $typeName: any;
+            id: any;
+            totalShares: any;
+            poolRewards: {
+                $typeName: any;
+                id: any;
+                rewardIndex: number;
+                poolRewardManagerId: any;
+                coinType: string;
+                startTimeMs: number;
+                endTimeMs: number;
+                totalRewards: import("bignumber.js").BigNumber;
+                allocatedRewards: import("bignumber.js").BigNumber;
+                cumulativeRewardsPerShare: import("bignumber.js").BigNumber;
+                numUserRewardManagers: any;
+                mintDecimals: number;
+                symbol: string;
+            }[];
+            lastUpdateTimeMs: any;
+        };
+        totalDeposits: import("bignumber.js").BigNumber;
+        cTokenExchangeRate: import("bignumber.js").BigNumber;
+        borrowAprPercent: import("bignumber.js").BigNumber;
+        depositAprPercent: import("bignumber.js").BigNumber;
+        utilizationPercent: import("bignumber.js").BigNumber;
+        symbol: string;
+        name: string;
+        iconUrl: string | null | undefined;
+        description: string;
+    }[];
+    rateLimiter: {
+        config: {
+            windowDuration: any;
+            maxOutflow: any;
+        };
+        $typeName: any;
+        prevQty: any;
+        windowStart: any;
+        curQty: any;
+        remainingOutflow: import("bignumber.js").BigNumber;
+    };
+    totalSupplyUsd: import("bignumber.js").BigNumber;
+    totalBorrowUsd: import("bignumber.js").BigNumber;
+    tvlUsd: import("bignumber.js").BigNumber;
+};

package/mainnet/parsers/lendingMarket.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLendingMarket = void 0;
+const core = __importStar(require("../../core/parsers/lendingMarket"));
+const structs_1 = require("../_generated/suilend/lending-market/structs");
+const structs_2 = require("../_generated/suilend/liquidity-mining/structs");
+const structs_3 = require("../_generated/suilend/rate-limiter/structs");
+const structs_4 = require("../_generated/suilend/reserve/structs");
+const simulate = __importStar(require("../utils/simulate"));
+const parseLendingMarket = (lendingMarket, reserves, coinMetadataMap, currentTime) => core.parseLendingMarket({
+    LendingMarket: (structs_1.LendingMarket),
+    Reserve: (structs_4.Reserve),
+    PoolRewardManager: structs_2.PoolRewardManager,
+    PoolReward: structs_2.PoolReward,
+    simulate,
+    RateLimiter: structs_3.RateLimiter,
+}, lendingMarket, reserves, coinMetadataMap, currentTime);
+exports.parseLendingMarket = parseLendingMarket;

package/mainnet/parsers/obligation.d.ts

@@ -0,0 +1,10 @@
+import * as core from "../../core/parsers/obligation";
+import { Obligation } from "../_generated/suilend/obligation/structs";
+import { ParsedReserve } from "./reserve";
+export type ParsedObligation = Omit<core.ParsedObligation, "original"> & {
+    original: Obligation<string>;
+};
+export type ParsedPosition = ParsedObligation["deposits"][0] | ParsedObligation["borrows"][0];
+export declare const parseObligation: (obligation: Obligation<string>, parsedReserveMap: {
+    [coinType: string]: ParsedReserve;
+}) => ParsedObligation;

package/mainnet/parsers/obligation.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseObligation = void 0;
+const core = __importStar(require("../../core/parsers/obligation"));
+const structs_1 = require("../_generated/suilend/obligation/structs");
+const parseObligation = (obligation, parsedReserveMap) => core.parseObligation({ Obligation: (structs_1.Obligation) }, obligation, parsedReserveMap);
+exports.parseObligation = parseObligation;

package/mainnet/parsers/rateLimiter.d.ts

@@ -0,0 +1,18 @@
+import { RateLimiter } from "../_generated/suilend/rate-limiter/structs";
+export type ParsedRateLimiter = ReturnType<typeof parseRateLimiter>;
+export type ParsedRateLimiterConfig = ReturnType<typeof parseRateLimiterConfig>;
+export declare const parseRateLimiter: (rateLimiter: RateLimiter, currentTime: number) => {
+    config: {
+        windowDuration: any;
+        maxOutflow: any;
+    };
+    $typeName: any;
+    prevQty: any;
+    windowStart: any;
+    curQty: any;
+    remainingOutflow: import("bignumber.js").BigNumber;
+};
+export declare const parseRateLimiterConfig: (rateLimiter: RateLimiter) => {
+    windowDuration: any;
+    maxOutflow: any;
+};

package/mainnet/parsers/rateLimiter.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRateLimiterConfig = exports.parseRateLimiter = void 0;
+const core = __importStar(require("../../core/parsers/rateLimiter"));
+const structs_1 = require("../_generated/suilend/rate-limiter/structs");
+const parseRateLimiter = (rateLimiter, currentTime) => core.parseRateLimiter({ RateLimiter: structs_1.RateLimiter }, rateLimiter, currentTime);
+exports.parseRateLimiter = parseRateLimiter;
+const parseRateLimiterConfig = (rateLimiter) => core.parseRateLimiterConfig({ RateLimiter: structs_1.RateLimiter }, rateLimiter);
+exports.parseRateLimiterConfig = parseRateLimiterConfig;