@suilend/sdk 1.0.0

package/mainnet/_generated/suilend/oracles/functions.d.ts

@@ -0,0 +1,8 @@
+import { ObjectArg } from "../../_framework/util";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+export interface GetPythPriceAndIdentifierArgs {
+    priceInfoObj: ObjectArg;
+    clock: ObjectArg;
+}
+export declare function getPythPriceAndIdentifier(txb: TransactionBlock, args: GetPythPriceAndIdentifierArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function parsePriceToDecimal(txb: TransactionBlock, price: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;

package/mainnet/_generated/suilend/oracles/functions.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePriceToDecimal = exports.getPythPriceAndIdentifier = void 0;
+const __1 = require("..");
+const util_1 = require("../../_framework/util");
+function getPythPriceAndIdentifier(txb, args) {
+    return txb.moveCall({
+        target: `${__1.PUBLISHED_AT}::oracles::get_pyth_price_and_identifier`,
+        arguments: [(0, util_1.obj)(txb, args.priceInfoObj), (0, util_1.obj)(txb, args.clock)],
+    });
+}
+exports.getPythPriceAndIdentifier = getPythPriceAndIdentifier;
+function parsePriceToDecimal(txb, price) {
+    return txb.moveCall({
+        target: `${__1.PUBLISHED_AT}::oracles::parse_price_to_decimal`,
+        arguments: [(0, util_1.obj)(txb, price)],
+    });
+}
+exports.parsePriceToDecimal = parsePriceToDecimal;

package/mainnet/_generated/suilend/rate-limiter/functions.d.ts

@@ -0,0 +1,33 @@
+import { ObjectArg } from "../../_framework/util";
+import { TransactionArgument, TransactionBlock } from "@mysten/sui.js/transactions";
+export interface NewArgs {
+    config: ObjectArg;
+    curTime: bigint | TransactionArgument;
+}
+export declare function new_(txb: TransactionBlock, args: NewArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface CurrentOutflowArgs {
+    rateLimiter: ObjectArg;
+    curTime: bigint | TransactionArgument;
+}
+export declare function currentOutflow(txb: TransactionBlock, args: CurrentOutflowArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface NewConfigArgs {
+    windowDuration: bigint | TransactionArgument;
+    maxOutflow: bigint | TransactionArgument;
+}
+export declare function newConfig(txb: TransactionBlock, args: NewConfigArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface ProcessQtyArgs {
+    rateLimiter: ObjectArg;
+    curTime: bigint | TransactionArgument;
+    qty: ObjectArg;
+}
+export declare function processQty(txb: TransactionBlock, args: ProcessQtyArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface RemainingOutflowArgs {
+    rateLimiter: ObjectArg;
+    curTime: bigint | TransactionArgument;
+}
+export declare function remainingOutflow(txb: TransactionBlock, args: RemainingOutflowArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface UpdateInternalArgs {
+    rateLimiter: ObjectArg;
+    curTime: bigint | TransactionArgument;
+}
+export declare function updateInternal(txb: TransactionBlock, args: UpdateInternalArgs): import("@mysten/sui.js/transactions").TransactionResult;

package/mainnet/_generated/suilend/rate-limiter/functions.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateInternal = exports.remainingOutflow = exports.processQty = exports.newConfig = exports.currentOutflow = exports.new_ = void 0;
+const __1 = require("..");
+const util_1 = require("../../_framework/util");
+function new_(txb, args) {
+    return txb.moveCall({
+        target: `${__1.PUBLISHED_AT}::rate_limiter::new`,
+        arguments: [(0, util_1.obj)(txb, args.config), (0, util_1.pure)(txb, args.curTime, `u64`)],
+    });
+}
+exports.new_ = new_;
+function currentOutflow(txb, args) {
+    return txb.moveCall({
+        target: `${__1.PUBLISHED_AT}::rate_limiter::current_outflow`,
+        arguments: [(0, util_1.obj)(txb, args.rateLimiter), (0, util_1.pure)(txb, args.curTime, `u64`)],
+    });
+}
+exports.currentOutflow = currentOutflow;
+function newConfig(txb, args) {
+    return txb.moveCall({
+        target: `${__1.PUBLISHED_AT}::rate_limiter::new_config`,
+        arguments: [
+            (0, util_1.pure)(txb, args.windowDuration, `u64`),
+            (0, util_1.pure)(txb, args.maxOutflow, `u64`),
+        ],
+    });
+}
+exports.newConfig = newConfig;
+function processQty(txb, args) {
+    return txb.moveCall({
+        target: `${__1.PUBLISHED_AT}::rate_limiter::process_qty`,
+        arguments: [
+            (0, util_1.obj)(txb, args.rateLimiter),
+            (0, util_1.pure)(txb, args.curTime, `u64`),
+            (0, util_1.obj)(txb, args.qty),
+        ],
+    });
+}
+exports.processQty = processQty;
+function remainingOutflow(txb, args) {
+    return txb.moveCall({
+        target: `${__1.PUBLISHED_AT}::rate_limiter::remaining_outflow`,
+        arguments: [(0, util_1.obj)(txb, args.rateLimiter), (0, util_1.pure)(txb, args.curTime, `u64`)],
+    });
+}
+exports.remainingOutflow = remainingOutflow;
+function updateInternal(txb, args) {
+    return txb.moveCall({
+        target: `${__1.PUBLISHED_AT}::rate_limiter::update_internal`,
+        arguments: [(0, util_1.obj)(txb, args.rateLimiter), (0, util_1.pure)(txb, args.curTime, `u64`)],
+    });
+}
+exports.updateInternal = updateInternal;

package/mainnet/_generated/suilend/rate-limiter/structs.d.ts

@@ -0,0 +1,132 @@
+import { PhantomReified, Reified, StructClass, ToField, ToTypeStr } from "../../_framework/reified";
+import { FieldsWithTypes } from "../../_framework/util";
+import { Decimal } from "../decimal/structs";
+import { SuiClient, SuiParsedData } from "@mysten/sui.js/client";
+export declare function isRateLimiter(type: string): boolean;
+export interface RateLimiterFields {
+    config: ToField<RateLimiterConfig>;
+    prevQty: ToField<Decimal>;
+    windowStart: ToField<"u64">;
+    curQty: ToField<Decimal>;
+}
+export type RateLimiterReified = Reified<RateLimiter, RateLimiterFields>;
+export declare class RateLimiter implements StructClass {
+    static readonly $typeName = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiter";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiter";
+    readonly $fullTypeName: "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiter";
+    readonly $typeArgs: [];
+    readonly config: ToField<RateLimiterConfig>;
+    readonly prevQty: ToField<Decimal>;
+    readonly windowStart: ToField<"u64">;
+    readonly curQty: ToField<Decimal>;
+    private constructor();
+    static reified(): RateLimiterReified;
+    static get r(): import("../../_framework/reified").StructClassReified<RateLimiter, RateLimiterFields>;
+    static phantom(): PhantomReified<ToTypeStr<RateLimiter>>;
+    static get p(): PhantomReified<"0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiter">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        config: {
+            window_duration: string;
+            max_outflow: string;
+        };
+        prev_qty: {
+            value: string;
+        };
+        window_start: string;
+        cur_qty: {
+            value: string;
+        };
+    }, {
+        config: {
+            window_duration: string | number | bigint;
+            max_outflow: string | number | bigint;
+        };
+        prev_qty: {
+            value: string | number | bigint;
+        };
+        window_start: string | number | bigint;
+        cur_qty: {
+            value: string | number | bigint;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): RateLimiter;
+    static fromFieldsWithTypes(item: FieldsWithTypes): RateLimiter;
+    static fromBcs(data: Uint8Array): RateLimiter;
+    toJSONField(): {
+        config: {
+            windowDuration: string;
+            maxOutflow: string;
+        };
+        prevQty: {
+            value: string;
+        };
+        windowStart: string;
+        curQty: {
+            value: string;
+        };
+    };
+    toJSON(): {
+        config: {
+            windowDuration: string;
+            maxOutflow: string;
+        };
+        prevQty: {
+            value: string;
+        };
+        windowStart: string;
+        curQty: {
+            value: string;
+        };
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): RateLimiter;
+    static fromJSON(json: Record<string, any>): RateLimiter;
+    static fromSuiParsedData(content: SuiParsedData): RateLimiter;
+    static fetch(client: SuiClient, id: string): Promise<RateLimiter>;
+}
+export declare function isRateLimiterConfig(type: string): boolean;
+export interface RateLimiterConfigFields {
+    windowDuration: ToField<"u64">;
+    maxOutflow: ToField<"u64">;
+}
+export type RateLimiterConfigReified = Reified<RateLimiterConfig, RateLimiterConfigFields>;
+export declare class RateLimiterConfig implements StructClass {
+    static readonly $typeName = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiterConfig";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiterConfig";
+    readonly $fullTypeName: "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiterConfig";
+    readonly $typeArgs: [];
+    readonly windowDuration: ToField<"u64">;
+    readonly maxOutflow: ToField<"u64">;
+    private constructor();
+    static reified(): RateLimiterConfigReified;
+    static get r(): import("../../_framework/reified").StructClassReified<RateLimiterConfig, RateLimiterConfigFields>;
+    static phantom(): PhantomReified<ToTypeStr<RateLimiterConfig>>;
+    static get p(): PhantomReified<"0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiterConfig">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        window_duration: string;
+        max_outflow: string;
+    }, {
+        window_duration: string | number | bigint;
+        max_outflow: string | number | bigint;
+    }>;
+    static fromFields(fields: Record<string, any>): RateLimiterConfig;
+    static fromFieldsWithTypes(item: FieldsWithTypes): RateLimiterConfig;
+    static fromBcs(data: Uint8Array): RateLimiterConfig;
+    toJSONField(): {
+        windowDuration: string;
+        maxOutflow: string;
+    };
+    toJSON(): {
+        windowDuration: string;
+        maxOutflow: string;
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): RateLimiterConfig;
+    static fromJSON(json: Record<string, any>): RateLimiterConfig;
+    static fromSuiParsedData(content: SuiParsedData): RateLimiterConfig;
+    static fetch(client: SuiClient, id: string): Promise<RateLimiterConfig>;
+}

package/mainnet/_generated/suilend/rate-limiter/structs.js

@@ -0,0 +1,260 @@
+"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.RateLimiterConfig = exports.isRateLimiterConfig = exports.RateLimiter = exports.isRateLimiter = void 0;
+const reified_1 = require("../../_framework/reified");
+const util_1 = require("../../_framework/util");
+const structs_1 = require("../decimal/structs");
+const bcs_1 = require("@mysten/bcs");
+/* ============================== RateLimiter =============================== */
+function isRateLimiter(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return (type ===
+        "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiter");
+}
+exports.isRateLimiter = isRateLimiter;
+class RateLimiter {
+    constructor(typeArgs, fields) {
+        this.$typeName = RateLimiter.$typeName;
+        this.$fullTypeName = (0, util_1.composeSuiType)(RateLimiter.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.config = fields.config;
+        this.prevQty = fields.prevQty;
+        this.windowStart = fields.windowStart;
+        this.curQty = fields.curQty;
+    }
+    static reified() {
+        return {
+            typeName: RateLimiter.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(RateLimiter.$typeName, ...[]),
+            typeArgs: [],
+            reifiedTypeArgs: [],
+            fromFields: (fields) => RateLimiter.fromFields(fields),
+            fromFieldsWithTypes: (item) => RateLimiter.fromFieldsWithTypes(item),
+            fromBcs: (data) => RateLimiter.fromBcs(data),
+            bcs: RateLimiter.bcs,
+            fromJSONField: (field) => RateLimiter.fromJSONField(field),
+            fromJSON: (json) => RateLimiter.fromJSON(json),
+            fromSuiParsedData: (content) => RateLimiter.fromSuiParsedData(content),
+            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return RateLimiter.fetch(client, id); }),
+            new: (fields) => {
+                return new RateLimiter([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return RateLimiter.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(RateLimiter.reified());
+    }
+    static get p() {
+        return RateLimiter.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("RateLimiter", {
+            config: RateLimiterConfig.bcs,
+            prev_qty: structs_1.Decimal.bcs,
+            window_start: bcs_1.bcs.u64(),
+            cur_qty: structs_1.Decimal.bcs,
+        });
+    }
+    static fromFields(fields) {
+        return RateLimiter.reified().new({
+            config: (0, reified_1.decodeFromFields)(RateLimiterConfig.reified(), fields.config),
+            prevQty: (0, reified_1.decodeFromFields)(structs_1.Decimal.reified(), fields.prev_qty),
+            windowStart: (0, reified_1.decodeFromFields)("u64", fields.window_start),
+            curQty: (0, reified_1.decodeFromFields)(structs_1.Decimal.reified(), fields.cur_qty),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isRateLimiter(item.type)) {
+            throw new Error("not a RateLimiter type");
+        }
+        return RateLimiter.reified().new({
+            config: (0, reified_1.decodeFromFieldsWithTypes)(RateLimiterConfig.reified(), item.fields.config),
+            prevQty: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.Decimal.reified(), item.fields.prev_qty),
+            windowStart: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.window_start),
+            curQty: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.Decimal.reified(), item.fields.cur_qty),
+        });
+    }
+    static fromBcs(data) {
+        return RateLimiter.fromFields(RateLimiter.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            config: this.config.toJSONField(),
+            prevQty: this.prevQty.toJSONField(),
+            windowStart: this.windowStart.toString(),
+            curQty: this.curQty.toJSONField(),
+        };
+    }
+    toJSON() {
+        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+    }
+    static fromJSONField(field) {
+        return RateLimiter.reified().new({
+            config: (0, reified_1.decodeFromJSONField)(RateLimiterConfig.reified(), field.config),
+            prevQty: (0, reified_1.decodeFromJSONField)(structs_1.Decimal.reified(), field.prevQty),
+            windowStart: (0, reified_1.decodeFromJSONField)("u64", field.windowStart),
+            curQty: (0, reified_1.decodeFromJSONField)(structs_1.Decimal.reified(), field.curQty),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== RateLimiter.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return RateLimiter.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isRateLimiter(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a RateLimiter object`);
+        }
+        return RateLimiter.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 RateLimiter 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" ||
+                !isRateLimiter(res.data.bcs.type)) {
+                throw new Error(`object at id ${id} is not a RateLimiter object`);
+            }
+            return RateLimiter.fromBcs((0, bcs_1.fromB64)(res.data.bcs.bcsBytes));
+        });
+    }
+}
+exports.RateLimiter = RateLimiter;
+RateLimiter.$typeName = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiter";
+RateLimiter.$numTypeParams = 0;
+/* ============================== RateLimiterConfig =============================== */
+function isRateLimiterConfig(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return (type ===
+        "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiterConfig");
+}
+exports.isRateLimiterConfig = isRateLimiterConfig;
+class RateLimiterConfig {
+    constructor(typeArgs, fields) {
+        this.$typeName = RateLimiterConfig.$typeName;
+        this.$fullTypeName = (0, util_1.composeSuiType)(RateLimiterConfig.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.windowDuration = fields.windowDuration;
+        this.maxOutflow = fields.maxOutflow;
+    }
+    static reified() {
+        return {
+            typeName: RateLimiterConfig.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(RateLimiterConfig.$typeName, ...[]),
+            typeArgs: [],
+            reifiedTypeArgs: [],
+            fromFields: (fields) => RateLimiterConfig.fromFields(fields),
+            fromFieldsWithTypes: (item) => RateLimiterConfig.fromFieldsWithTypes(item),
+            fromBcs: (data) => RateLimiterConfig.fromBcs(data),
+            bcs: RateLimiterConfig.bcs,
+            fromJSONField: (field) => RateLimiterConfig.fromJSONField(field),
+            fromJSON: (json) => RateLimiterConfig.fromJSON(json),
+            fromSuiParsedData: (content) => RateLimiterConfig.fromSuiParsedData(content),
+            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return RateLimiterConfig.fetch(client, id); }),
+            new: (fields) => {
+                return new RateLimiterConfig([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return RateLimiterConfig.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(RateLimiterConfig.reified());
+    }
+    static get p() {
+        return RateLimiterConfig.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("RateLimiterConfig", {
+            window_duration: bcs_1.bcs.u64(),
+            max_outflow: bcs_1.bcs.u64(),
+        });
+    }
+    static fromFields(fields) {
+        return RateLimiterConfig.reified().new({
+            windowDuration: (0, reified_1.decodeFromFields)("u64", fields.window_duration),
+            maxOutflow: (0, reified_1.decodeFromFields)("u64", fields.max_outflow),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isRateLimiterConfig(item.type)) {
+            throw new Error("not a RateLimiterConfig type");
+        }
+        return RateLimiterConfig.reified().new({
+            windowDuration: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.window_duration),
+            maxOutflow: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.max_outflow),
+        });
+    }
+    static fromBcs(data) {
+        return RateLimiterConfig.fromFields(RateLimiterConfig.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            windowDuration: this.windowDuration.toString(),
+            maxOutflow: this.maxOutflow.toString(),
+        };
+    }
+    toJSON() {
+        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+    }
+    static fromJSONField(field) {
+        return RateLimiterConfig.reified().new({
+            windowDuration: (0, reified_1.decodeFromJSONField)("u64", field.windowDuration),
+            maxOutflow: (0, reified_1.decodeFromJSONField)("u64", field.maxOutflow),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== RateLimiterConfig.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return RateLimiterConfig.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isRateLimiterConfig(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a RateLimiterConfig object`);
+        }
+        return RateLimiterConfig.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 RateLimiterConfig 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" ||
+                !isRateLimiterConfig(res.data.bcs.type)) {
+                throw new Error(`object at id ${id} is not a RateLimiterConfig object`);
+            }
+            return RateLimiterConfig.fromBcs((0, bcs_1.fromB64)(res.data.bcs.bcsBytes));
+        });
+    }
+}
+exports.RateLimiterConfig = RateLimiterConfig;
+RateLimiterConfig.$typeName = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiterConfig";
+RateLimiterConfig.$numTypeParams = 0;

package/mainnet/_generated/suilend/reserve/functions.d.ts

@@ -0,0 +1,138 @@
+import { ObjectArg } from "../../_framework/util";
+import { TransactionArgument, TransactionBlock } from "@mysten/sui.js/transactions";
+export declare function totalSupply(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function price(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function config(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function coinType(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function arrayIndex(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export interface AssertPriceIsFreshArgs {
+    reserve: ObjectArg;
+    clock: ObjectArg;
+}
+export declare function assertPriceIsFresh(txb: TransactionBlock, typeArg: string, args: AssertPriceIsFreshArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function availableAmount(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export interface BorrowLiquidityArgs {
+    reserve: ObjectArg;
+    amount: bigint | TransactionArgument;
+}
+export declare function borrowLiquidity(txb: TransactionBlock, typeArgs: [string, string], args: BorrowLiquidityArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function borrowedAmount(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function borrowsPoolRewardManager(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function borrowsPoolRewardManagerMut(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export interface CalculateBorrowFeeArgs {
+    reserve: ObjectArg;
+    borrowAmount: bigint | TransactionArgument;
+}
+export declare function calculateBorrowFee(txb: TransactionBlock, typeArg: string, args: CalculateBorrowFeeArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function calculateUtilizationRate(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function claimFees(txb: TransactionBlock, typeArgs: [string, string], reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export interface CompoundInterestArgs {
+    reserve: ObjectArg;
+    clock: ObjectArg;
+}
+export declare function compoundInterest(txb: TransactionBlock, typeArg: string, args: CompoundInterestArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface CreateReserveArgs {
+    lendingMarketId: string | TransactionArgument;
+    config: ObjectArg;
+    arrayIndex: bigint | TransactionArgument;
+    coinMetadata: ObjectArg;
+    priceInfoObj: ObjectArg;
+    clock: ObjectArg;
+}
+export declare function createReserve(txb: TransactionBlock, typeArgs: [string, string], args: CreateReserveArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface CtokenMarketValueArgs {
+    reserve: ObjectArg;
+    ctokenAmount: bigint | TransactionArgument;
+}
+export declare function ctokenMarketValue(txb: TransactionBlock, typeArg: string, args: CtokenMarketValueArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface CtokenMarketValueLowerBoundArgs {
+    reserve: ObjectArg;
+    ctokenAmount: bigint | TransactionArgument;
+}
+export declare function ctokenMarketValueLowerBound(txb: TransactionBlock, typeArg: string, args: CtokenMarketValueLowerBoundArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface CtokenMarketValueUpperBoundArgs {
+    reserve: ObjectArg;
+    ctokenAmount: bigint | TransactionArgument;
+}
+export declare function ctokenMarketValueUpperBound(txb: TransactionBlock, typeArg: string, args: CtokenMarketValueUpperBoundArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function ctokenRatio(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function cumulativeBorrowRate(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export interface DeductLiquidationFeeArgs {
+    reserve: ObjectArg;
+    ctokens: ObjectArg;
+}
+export declare function deductLiquidationFee(txb: TransactionBlock, typeArgs: [string, string], args: DeductLiquidationFeeArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface DepositCtokensArgs {
+    reserve: ObjectArg;
+    ctokens: ObjectArg;
+}
+export declare function depositCtokens(txb: TransactionBlock, typeArgs: [string, string], args: DepositCtokensArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface DepositLiquidityAndMintCtokensArgs {
+    reserve: ObjectArg;
+    liquidity: ObjectArg;
+}
+export declare function depositLiquidityAndMintCtokens(txb: TransactionBlock, typeArgs: [string, string], args: DepositLiquidityAndMintCtokensArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function depositsPoolRewardManager(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function depositsPoolRewardManagerMut(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export interface ForgiveDebtArgs {
+    reserve: ObjectArg;
+    forgiveAmount: ObjectArg;
+}
+export declare function forgiveDebt(txb: TransactionBlock, typeArg: string, args: ForgiveDebtArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function logReserveData(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export interface MarketValueArgs {
+    reserve: ObjectArg;
+    liquidityAmount: ObjectArg;
+}
+export declare function marketValue(txb: TransactionBlock, typeArg: string, args: MarketValueArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface MarketValueLowerBoundArgs {
+    reserve: ObjectArg;
+    liquidityAmount: ObjectArg;
+}
+export declare function marketValueLowerBound(txb: TransactionBlock, typeArg: string, args: MarketValueLowerBoundArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface MarketValueUpperBoundArgs {
+    reserve: ObjectArg;
+    liquidityAmount: ObjectArg;
+}
+export declare function marketValueUpperBound(txb: TransactionBlock, typeArg: string, args: MarketValueUpperBoundArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function maxBorrowAmount(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function maxRedeemAmount(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function priceLowerBound(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function priceUpperBound(txb: TransactionBlock, typeArg: string, reserve: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export interface RedeemCtokensArgs {
+    reserve: ObjectArg;
+    ctokens: ObjectArg;
+}
+export declare function redeemCtokens(txb: TransactionBlock, typeArgs: [string, string], args: RedeemCtokensArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface RepayLiquidityArgs {
+    reserve: ObjectArg;
+    liquidity: ObjectArg;
+    settleAmount: ObjectArg;
+}
+export declare function repayLiquidity(txb: TransactionBlock, typeArgs: [string, string], args: RepayLiquidityArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface UpdatePriceArgs {
+    reserve: ObjectArg;
+    clock: ObjectArg;
+    priceInfoObj: ObjectArg;
+}
+export declare function updatePrice(txb: TransactionBlock, typeArg: string, args: UpdatePriceArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface UpdateReserveConfigArgs {
+    reserve: ObjectArg;
+    config: ObjectArg;
+}
+export declare function updateReserveConfig(txb: TransactionBlock, typeArg: string, args: UpdateReserveConfigArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface UsdToTokenAmountLowerBoundArgs {
+    reserve: ObjectArg;
+    usdAmount: ObjectArg;
+}
+export declare function usdToTokenAmountLowerBound(txb: TransactionBlock, typeArg: string, args: UsdToTokenAmountLowerBoundArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface UsdToTokenAmountUpperBoundArgs {
+    reserve: ObjectArg;
+    usdAmount: ObjectArg;
+}
+export declare function usdToTokenAmountUpperBound(txb: TransactionBlock, typeArg: string, args: UsdToTokenAmountUpperBoundArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export interface WithdrawCtokensArgs {
+    reserve: ObjectArg;
+    amount: bigint | TransactionArgument;
+}
+export declare function withdrawCtokens(txb: TransactionBlock, typeArgs: [string, string], args: WithdrawCtokensArgs): import("@mysten/sui.js/transactions").TransactionResult;