@suilend/sdk 12.7.0 → 13.0.0-next.g122801a

package/_generated/suilend/reserve/structs.js

@@ -1,25 +1,607 @@
-import * as reified from "../../_framework/reified.js";
-import { TypeName } from "../../_dependencies/source/0x1/type-name/structs.js";
-import { Balance, Supply, } from "../../_dependencies/source/0x2/balance/structs.js";
-import { ID, UID } from "../../_dependencies/source/0x2/object/structs.js";
-import { PriceIdentifier } from "../../_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-identifier/structs.js";
-import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, phantom, } from "../../_framework/reified.js";
-import { composeSuiType, compressSuiType, } from "../../_framework/util.js";
-import { Cell } from "../cell/structs.js";
-import { Decimal } from "../decimal/structs.js";
-import { PKG_V1, PKG_V8 } from "../index.js";
-import { PoolRewardManager } from "../liquidity-mining/structs.js";
-import { ReserveConfig } from "../reserve-config/structs.js";
-import { bcs } from "@mysten/sui/bcs";
-import { fromHex, toHex } from "@mysten/sui/utils";
+/** The reserve module holds the coins of a certain type for a given lending market. */
+import { bcs } from '@mysten/sui/bcs';
+import { fromHex, toHex } from '@mysten/sui/utils';
+import { PriceIdentifier } from '../../_dependencies/pyth-2/price-identifier/structs.js';
+import { TypeName } from '../../_dependencies/std/type-name/structs.js';
+import { Balance, Supply } from '../../_dependencies/sui/balance/structs.js';
+import { ID, UID } from '../../_dependencies/sui/object/structs.js';
+import { getTypeOrigin } from '../../_envs/index.js';
+import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, phantom, } from '../../_framework/reified.js';
+import { composeSuiType, compressSuiType, parseTypeName, } from '../../_framework/util.js';
+import { Cell } from '../cell/structs.js';
+import { Decimal } from '../decimal/structs.js';
+import { PoolRewardManager } from '../liquidity-mining/structs.js';
+import { ReserveConfig } from '../reserve-config/structs.js';
+/* ============================== Reserve =============================== */
+export function isReserve(type) {
+    type = compressSuiType(type);
+    return type.startsWith(`${getTypeOrigin('suilend', 'reserve::Reserve')}::reserve::Reserve` + '<');
+}
+export class Reserve {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::Reserve')}::reserve::Reserve`;
+    }
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = Reserve.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = Reserve.$isPhantom;
+    id;
+    lendingMarketId;
+    arrayIndex;
+    coinType;
+    config;
+    mintDecimals;
+    priceIdentifier;
+    price;
+    smoothedPrice;
+    priceLastUpdateTimestampS;
+    availableAmount;
+    ctokenSupply;
+    borrowedAmount;
+    cumulativeBorrowRate;
+    interestLastUpdateTimestampS;
+    unclaimedSpreadFees;
+    /** unused */
+    attributedBorrowValue;
+    depositsPoolRewardManager;
+    borrowsPoolRewardManager;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(Reserve.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.id = fields.id;
+        this.lendingMarketId = fields.lendingMarketId;
+        this.arrayIndex = fields.arrayIndex;
+        this.coinType = fields.coinType;
+        this.config = fields.config;
+        this.mintDecimals = fields.mintDecimals;
+        this.priceIdentifier = fields.priceIdentifier;
+        this.price = fields.price;
+        this.smoothedPrice = fields.smoothedPrice;
+        this.priceLastUpdateTimestampS = fields.priceLastUpdateTimestampS;
+        this.availableAmount = fields.availableAmount;
+        this.ctokenSupply = fields.ctokenSupply;
+        this.borrowedAmount = fields.borrowedAmount;
+        this.cumulativeBorrowRate = fields.cumulativeBorrowRate;
+        this.interestLastUpdateTimestampS = fields.interestLastUpdateTimestampS;
+        this.unclaimedSpreadFees = fields.unclaimedSpreadFees;
+        this.attributedBorrowValue = fields.attributedBorrowValue;
+        this.depositsPoolRewardManager = fields.depositsPoolRewardManager;
+        this.borrowsPoolRewardManager = fields.borrowsPoolRewardManager;
+    }
+    static reified(P) {
+        const reifiedBcs = Reserve.bcs;
+        return {
+            get typeName() {
+                return Reserve.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(Reserve.$typeName, ...[extractType(P)]);
+            },
+            get typeArgs() {
+                return [extractType(P)];
+            },
+            isPhantom: Reserve.$isPhantom,
+            reifiedTypeArgs: [P],
+            fromFields: (fields) => Reserve.fromFields(P, fields),
+            fromFieldsWithTypes: (item) => Reserve.fromFieldsWithTypes(P, item),
+            fromBcs: (data) => Reserve.fromFields(P, reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => Reserve.fromJSONField(P, field),
+            fromJSON: (json) => Reserve.fromJSON(P, json),
+            fromCoreObject: (obj) => Reserve.fromCoreObject(P, obj),
+            fetch: async (client, id) => Reserve.fetch(client, P, id),
+            new: (fields) => {
+                return new Reserve([extractType(P)], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return Reserve.reified;
+    }
+    static phantom(P) {
+        return phantom(Reserve.reified(P));
+    }
+    static get p() {
+        return Reserve.phantom;
+    }
+    static instantiateBcs() {
+        return bcs.struct('Reserve', {
+            id: UID.bcs,
+            lending_market_id: ID.bcs,
+            array_index: bcs.u64(),
+            coin_type: TypeName.bcs,
+            config: Cell.bcs(ReserveConfig.bcs),
+            mint_decimals: bcs.u8(),
+            price_identifier: PriceIdentifier.bcs,
+            price: Decimal.bcs,
+            smoothed_price: Decimal.bcs,
+            price_last_update_timestamp_s: bcs.u64(),
+            available_amount: bcs.u64(),
+            ctoken_supply: bcs.u64(),
+            borrowed_amount: Decimal.bcs,
+            cumulative_borrow_rate: Decimal.bcs,
+            interest_last_update_timestamp_s: bcs.u64(),
+            unclaimed_spread_fees: Decimal.bcs,
+            attributed_borrow_value: Decimal.bcs,
+            deposits_pool_reward_manager: PoolRewardManager.bcs,
+            borrows_pool_reward_manager: PoolRewardManager.bcs,
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!Reserve.cachedBcs) {
+            Reserve.cachedBcs = Reserve.instantiateBcs();
+        }
+        return Reserve.cachedBcs;
+    }
+    static fromFields(typeArg, fields) {
+        return Reserve.reified(typeArg).new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            lendingMarketId: decodeFromFields(ID.reified(), fields.lending_market_id),
+            arrayIndex: decodeFromFields('u64', fields.array_index),
+            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
+            config: decodeFromFields(Cell.reified(ReserveConfig.reified()), fields.config),
+            mintDecimals: decodeFromFields('u8', fields.mint_decimals),
+            priceIdentifier: decodeFromFields(PriceIdentifier.reified(), fields.price_identifier),
+            price: decodeFromFields(Decimal.reified(), fields.price),
+            smoothedPrice: decodeFromFields(Decimal.reified(), fields.smoothed_price),
+            priceLastUpdateTimestampS: decodeFromFields('u64', fields.price_last_update_timestamp_s),
+            availableAmount: decodeFromFields('u64', fields.available_amount),
+            ctokenSupply: decodeFromFields('u64', fields.ctoken_supply),
+            borrowedAmount: decodeFromFields(Decimal.reified(), fields.borrowed_amount),
+            cumulativeBorrowRate: decodeFromFields(Decimal.reified(), fields.cumulative_borrow_rate),
+            interestLastUpdateTimestampS: decodeFromFields('u64', fields.interest_last_update_timestamp_s),
+            unclaimedSpreadFees: decodeFromFields(Decimal.reified(), fields.unclaimed_spread_fees),
+            attributedBorrowValue: decodeFromFields(Decimal.reified(), fields.attributed_borrow_value),
+            depositsPoolRewardManager: decodeFromFields(PoolRewardManager.reified(), fields.deposits_pool_reward_manager),
+            borrowsPoolRewardManager: decodeFromFields(PoolRewardManager.reified(), fields.borrows_pool_reward_manager),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isReserve(item.type)) {
+            throw new Error('not a Reserve type');
+        }
+        assertFieldsWithTypesArgsMatch(item, [typeArg]);
+        return Reserve.reified(typeArg).new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            lendingMarketId: decodeFromFieldsWithTypes(ID.reified(), item.fields.lending_market_id),
+            arrayIndex: decodeFromFieldsWithTypes('u64', item.fields.array_index),
+            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
+            config: decodeFromFieldsWithTypes(Cell.reified(ReserveConfig.reified()), item.fields.config),
+            mintDecimals: decodeFromFieldsWithTypes('u8', item.fields.mint_decimals),
+            priceIdentifier: decodeFromFieldsWithTypes(PriceIdentifier.reified(), item.fields.price_identifier),
+            price: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.price),
+            smoothedPrice: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.smoothed_price),
+            priceLastUpdateTimestampS: decodeFromFieldsWithTypes('u64', item.fields.price_last_update_timestamp_s),
+            availableAmount: decodeFromFieldsWithTypes('u64', item.fields.available_amount),
+            ctokenSupply: decodeFromFieldsWithTypes('u64', item.fields.ctoken_supply),
+            borrowedAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrowed_amount),
+            cumulativeBorrowRate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.cumulative_borrow_rate),
+            interestLastUpdateTimestampS: decodeFromFieldsWithTypes('u64', item.fields.interest_last_update_timestamp_s),
+            unclaimedSpreadFees: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.unclaimed_spread_fees),
+            attributedBorrowValue: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.attributed_borrow_value),
+            depositsPoolRewardManager: decodeFromFieldsWithTypes(PoolRewardManager.reified(), item.fields.deposits_pool_reward_manager),
+            borrowsPoolRewardManager: decodeFromFieldsWithTypes(PoolRewardManager.reified(), item.fields.borrows_pool_reward_manager),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        return Reserve.fromFields(typeArg, Reserve.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            id: this.id,
+            lendingMarketId: this.lendingMarketId,
+            arrayIndex: this.arrayIndex.toString(),
+            coinType: this.coinType,
+            config: this.config.toJSONField(),
+            mintDecimals: this.mintDecimals,
+            priceIdentifier: this.priceIdentifier.toJSONField(),
+            price: this.price.toJSONField(),
+            smoothedPrice: this.smoothedPrice.toJSONField(),
+            priceLastUpdateTimestampS: this.priceLastUpdateTimestampS.toString(),
+            availableAmount: this.availableAmount.toString(),
+            ctokenSupply: this.ctokenSupply.toString(),
+            borrowedAmount: this.borrowedAmount.toJSONField(),
+            cumulativeBorrowRate: this.cumulativeBorrowRate.toJSONField(),
+            interestLastUpdateTimestampS: this.interestLastUpdateTimestampS.toString(),
+            unclaimedSpreadFees: this.unclaimedSpreadFees.toJSONField(),
+            attributedBorrowValue: this.attributedBorrowValue.toJSONField(),
+            depositsPoolRewardManager: this.depositsPoolRewardManager.toJSONField(),
+            borrowsPoolRewardManager: this.borrowsPoolRewardManager.toJSONField(),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(typeArg, field) {
+        return Reserve.reified(typeArg).new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            lendingMarketId: decodeFromJSONField(ID.reified(), field.lendingMarketId),
+            arrayIndex: decodeFromJSONField('u64', field.arrayIndex),
+            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
+            config: decodeFromJSONField(Cell.reified(ReserveConfig.reified()), field.config),
+            mintDecimals: decodeFromJSONField('u8', field.mintDecimals),
+            priceIdentifier: decodeFromJSONField(PriceIdentifier.reified(), field.priceIdentifier),
+            price: decodeFromJSONField(Decimal.reified(), field.price),
+            smoothedPrice: decodeFromJSONField(Decimal.reified(), field.smoothedPrice),
+            priceLastUpdateTimestampS: decodeFromJSONField('u64', field.priceLastUpdateTimestampS),
+            availableAmount: decodeFromJSONField('u64', field.availableAmount),
+            ctokenSupply: decodeFromJSONField('u64', field.ctokenSupply),
+            borrowedAmount: decodeFromJSONField(Decimal.reified(), field.borrowedAmount),
+            cumulativeBorrowRate: decodeFromJSONField(Decimal.reified(), field.cumulativeBorrowRate),
+            interestLastUpdateTimestampS: decodeFromJSONField('u64', field.interestLastUpdateTimestampS),
+            unclaimedSpreadFees: decodeFromJSONField(Decimal.reified(), field.unclaimedSpreadFees),
+            attributedBorrowValue: decodeFromJSONField(Decimal.reified(), field.attributedBorrowValue),
+            depositsPoolRewardManager: decodeFromJSONField(PoolRewardManager.reified(), field.depositsPoolRewardManager),
+            borrowsPoolRewardManager: decodeFromJSONField(PoolRewardManager.reified(), field.borrowsPoolRewardManager),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== Reserve.$typeName) {
+            throw new Error(`not a Reserve json object: expected '${Reserve.$typeName}' but got '${json.$typeName}'`);
+        }
+        assertReifiedTypeArgsMatch(composeSuiType(Reserve.$typeName, ...[extractType(typeArg)]), json.$typeArgs, [typeArg]);
+        return Reserve.fromJSONField(typeArg, json);
+    }
+    static fromCoreObject(typeArg, obj) {
+        if (!isReserve(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a Reserve object`);
+        }
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return Reserve.fromBcs(typeArg, obj.content);
+    }
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isReserve(object.type)) {
+            throw new Error(`object at id ${id} is not a Reserve object`);
+        }
+        const gotTypeArgs = parseTypeName(object.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return Reserve.fromBcs(typeArg, object.content);
+    }
+}
+/* ============================== CToken =============================== */
+export function isCToken(type) {
+    type = compressSuiType(type);
+    return type.startsWith(`${getTypeOrigin('suilend', 'reserve::CToken')}::reserve::CToken` + '<');
+}
+/**
+ * Interest bearing token on the underlying Coin<T>. The ctoken can be redeemed for
+ * the underlying token + any interest earned.
+ */
+export class CToken {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::CToken')}::reserve::CToken`;
+    }
+    static $numTypeParams = 2;
+    static $isPhantom = [true, true];
+    $typeName = CToken.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = CToken.$isPhantom;
+    dummyField;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(CToken.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.dummyField = fields.dummyField;
+    }
+    static reified(P, T) {
+        const reifiedBcs = CToken.bcs;
+        return {
+            get typeName() {
+                return CToken.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(CToken.$typeName, ...[extractType(P), extractType(T)]);
+            },
+            get typeArgs() {
+                return [extractType(P), extractType(T)];
+            },
+            isPhantom: CToken.$isPhantom,
+            reifiedTypeArgs: [P, T],
+            fromFields: (fields) => CToken.fromFields([P, T], fields),
+            fromFieldsWithTypes: (item) => CToken.fromFieldsWithTypes([P, T], item),
+            fromBcs: (data) => CToken.fromFields([P, T], reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => CToken.fromJSONField([P, T], field),
+            fromJSON: (json) => CToken.fromJSON([P, T], json),
+            fromCoreObject: (obj) => CToken.fromCoreObject([P, T], obj),
+            fetch: async (client, id) => CToken.fetch(client, [P, T], id),
+            new: (fields) => {
+                return new CToken([extractType(P), extractType(T)], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return CToken.reified;
+    }
+    static phantom(P, T) {
+        return phantom(CToken.reified(P, T));
+    }
+    static get p() {
+        return CToken.phantom;
+    }
+    static instantiateBcs() {
+        return bcs.struct('CToken', {
+            dummy_field: bcs.bool(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!CToken.cachedBcs) {
+            CToken.cachedBcs = CToken.instantiateBcs();
+        }
+        return CToken.cachedBcs;
+    }
+    static fromFields(typeArgs, fields) {
+        return CToken.reified(typeArgs[0], typeArgs[1]).new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
+        });
+    }
+    static fromFieldsWithTypes(typeArgs, item) {
+        if (!isCToken(item.type)) {
+            throw new Error('not a CToken type');
+        }
+        assertFieldsWithTypesArgsMatch(item, typeArgs);
+        return CToken.reified(typeArgs[0], typeArgs[1]).new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
+        });
+    }
+    static fromBcs(typeArgs, data) {
+        return CToken.fromFields(typeArgs, CToken.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(typeArgs, field) {
+        return CToken.reified(typeArgs[0], typeArgs[1]).new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
+        });
+    }
+    static fromJSON(typeArgs, json) {
+        if (json.$typeName !== CToken.$typeName) {
+            throw new Error(`not a CToken json object: expected '${CToken.$typeName}' but got '${json.$typeName}'`);
+        }
+        assertReifiedTypeArgsMatch(composeSuiType(CToken.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs);
+        return CToken.fromJSONField(typeArgs, json);
+    }
+    static fromCoreObject(typeArgs, obj) {
+        if (!isCToken(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a CToken object`);
+        }
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 2) {
+            throw new Error(`type argument mismatch: expected 2 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 2; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType(typeArgs[i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return CToken.fromBcs(typeArgs, obj.content);
+    }
+    static async fetch(client, typeArgs, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isCToken(object.type)) {
+            throw new Error(`object at id ${id} is not a CToken object`);
+        }
+        const gotTypeArgs = parseTypeName(object.type).typeArgs;
+        if (gotTypeArgs.length !== 2) {
+            throw new Error(`type argument mismatch: expected 2 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 2; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType(typeArgs[i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return CToken.fromBcs(typeArgs, object.content);
+    }
+}
+/* ============================== LiquidityRequest =============================== */
+export function isLiquidityRequest(type) {
+    type = compressSuiType(type);
+    return type.startsWith(`${getTypeOrigin('suilend', 'reserve::LiquidityRequest')}::reserve::LiquidityRequest` + '<');
+}
+/** A request to withdraw liquidity from the reserve. This is a hot potato object. */
+export class LiquidityRequest {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::LiquidityRequest')}::reserve::LiquidityRequest`;
+    }
+    static $numTypeParams = 2;
+    static $isPhantom = [true, true];
+    $typeName = LiquidityRequest.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = LiquidityRequest.$isPhantom;
+    amount;
+    fee;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(LiquidityRequest.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.amount = fields.amount;
+        this.fee = fields.fee;
+    }
+    static reified(P, T) {
+        const reifiedBcs = LiquidityRequest.bcs;
+        return {
+            get typeName() {
+                return LiquidityRequest.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(LiquidityRequest.$typeName, ...[extractType(P), extractType(T)]);
+            },
+            get typeArgs() {
+                return [extractType(P), extractType(T)];
+            },
+            isPhantom: LiquidityRequest.$isPhantom,
+            reifiedTypeArgs: [P, T],
+            fromFields: (fields) => LiquidityRequest.fromFields([P, T], fields),
+            fromFieldsWithTypes: (item) => LiquidityRequest.fromFieldsWithTypes([P, T], item),
+            fromBcs: (data) => LiquidityRequest.fromFields([P, T], reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => LiquidityRequest.fromJSONField([P, T], field),
+            fromJSON: (json) => LiquidityRequest.fromJSON([P, T], json),
+            fromCoreObject: (obj) => LiquidityRequest.fromCoreObject([P, T], obj),
+            fetch: async (client, id) => LiquidityRequest.fetch(client, [P, T], id),
+            new: (fields) => {
+                return new LiquidityRequest([extractType(P), extractType(T)], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return LiquidityRequest.reified;
+    }
+    static phantom(P, T) {
+        return phantom(LiquidityRequest.reified(P, T));
+    }
+    static get p() {
+        return LiquidityRequest.phantom;
+    }
+    static instantiateBcs() {
+        return bcs.struct('LiquidityRequest', {
+            amount: bcs.u64(),
+            fee: bcs.u64(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!LiquidityRequest.cachedBcs) {
+            LiquidityRequest.cachedBcs = LiquidityRequest.instantiateBcs();
+        }
+        return LiquidityRequest.cachedBcs;
+    }
+    static fromFields(typeArgs, fields) {
+        return LiquidityRequest.reified(typeArgs[0], typeArgs[1]).new({
+            amount: decodeFromFields('u64', fields.amount),
+            fee: decodeFromFields('u64', fields.fee),
+        });
+    }
+    static fromFieldsWithTypes(typeArgs, item) {
+        if (!isLiquidityRequest(item.type)) {
+            throw new Error('not a LiquidityRequest type');
+        }
+        assertFieldsWithTypesArgsMatch(item, typeArgs);
+        return LiquidityRequest.reified(typeArgs[0], typeArgs[1]).new({
+            amount: decodeFromFieldsWithTypes('u64', item.fields.amount),
+            fee: decodeFromFieldsWithTypes('u64', item.fields.fee),
+        });
+    }
+    static fromBcs(typeArgs, data) {
+        return LiquidityRequest.fromFields(typeArgs, LiquidityRequest.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            amount: this.amount.toString(),
+            fee: this.fee.toString(),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(typeArgs, field) {
+        return LiquidityRequest.reified(typeArgs[0], typeArgs[1]).new({
+            amount: decodeFromJSONField('u64', field.amount),
+            fee: decodeFromJSONField('u64', field.fee),
+        });
+    }
+    static fromJSON(typeArgs, json) {
+        if (json.$typeName !== LiquidityRequest.$typeName) {
+            throw new Error(`not a LiquidityRequest json object: expected '${LiquidityRequest.$typeName}' but got '${json.$typeName}'`);
+        }
+        assertReifiedTypeArgsMatch(composeSuiType(LiquidityRequest.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs);
+        return LiquidityRequest.fromJSONField(typeArgs, json);
+    }
+    static fromCoreObject(typeArgs, obj) {
+        if (!isLiquidityRequest(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a LiquidityRequest object`);
+        }
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 2) {
+            throw new Error(`type argument mismatch: expected 2 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 2; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType(typeArgs[i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return LiquidityRequest.fromBcs(typeArgs, obj.content);
+    }
+    static async fetch(client, typeArgs, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isLiquidityRequest(object.type)) {
+            throw new Error(`object at id ${id} is not a LiquidityRequest object`);
+        }
+        const gotTypeArgs = parseTypeName(object.type).typeArgs;
+        if (gotTypeArgs.length !== 2) {
+            throw new Error(`type argument mismatch: expected 2 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 2; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType(typeArgs[i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return LiquidityRequest.fromBcs(typeArgs, object.content);
+    }
+}
 /* ============================== BalanceKey =============================== */
 export function isBalanceKey(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::reserve::BalanceKey`;
+    return type === `${getTypeOrigin('suilend', 'reserve::BalanceKey')}::reserve::BalanceKey`;
 }
 export class BalanceKey {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::reserve::BalanceKey`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::BalanceKey')}::reserve::BalanceKey`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = BalanceKey.$typeName;
@@ -33,23 +615,29 @@ export class BalanceKey {
         this.dummyField = fields.dummyField;
     }
     static reified() {
+        const reifiedBcs = BalanceKey.bcs;
         return {
-            typeName: BalanceKey.$typeName,
-            fullTypeName: composeSuiType(BalanceKey.$typeName, ...[]),
+            get typeName() {
+                return BalanceKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(BalanceKey.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: BalanceKey.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => BalanceKey.fromFields(fields),
             fromFieldsWithTypes: (item) => BalanceKey.fromFieldsWithTypes(item),
-            fromBcs: (data) => BalanceKey.fromBcs(data),
-            bcs: BalanceKey.bcs,
+            fromBcs: (data) => BalanceKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => BalanceKey.fromJSONField(field),
             fromJSON: (json) => BalanceKey.fromJSON(json),
+            fromCoreObject: (obj) => BalanceKey.fromCoreObject(obj),
             fetch: async (client, id) => BalanceKey.fetch(client, id),
             new: (fields) => {
                 return new BalanceKey([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -61,22 +649,29 @@ export class BalanceKey {
     static get p() {
         return BalanceKey.phantom();
     }
-    static get bcs() {
-        return bcs.struct("BalanceKey", {
+    static instantiateBcs() {
+        return bcs.struct('BalanceKey', {
             dummy_field: bcs.bool(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!BalanceKey.cachedBcs) {
+            BalanceKey.cachedBcs = BalanceKey.instantiateBcs();
+        }
+        return BalanceKey.cachedBcs;
+    }
     static fromFields(fields) {
         return BalanceKey.reified().new({
-            dummyField: decodeFromFields("bool", fields.dummy_field),
+            dummyField: decodeFromFields('bool', fields.dummy_field),
         });
     }
     static fromFieldsWithTypes(item) {
         if (!isBalanceKey(item.type)) {
-            throw new Error("not a BalanceKey type");
+            throw new Error('not a BalanceKey type');
         }
         return BalanceKey.reified().new({
-            dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field),
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
         });
     }
     static fromBcs(data) {
@@ -88,232 +683,363 @@ export class BalanceKey {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return BalanceKey.reified().new({
-            dummyField: decodeFromJSONField("bool", field.dummyField),
+            dummyField: decodeFromJSONField('bool', field.dummyField),
         });
     }
     static fromJSON(json) {
         if (json.$typeName !== BalanceKey.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a BalanceKey json object: expected '${BalanceKey.$typeName}' but got '${json.$typeName}'`);
         }
         return BalanceKey.fromJSONField(json);
     }
+    static fromCoreObject(obj) {
+        if (!isBalanceKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a BalanceKey object`);
+        }
+        return BalanceKey.fromBcs(obj.content);
+    }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
         if (!isBalanceKey(object.type)) {
             throw new Error(`object at id ${id} is not a BalanceKey object`);
         }
         return BalanceKey.fromBcs(object.content);
     }
 }
-/* ============================== Balances =============================== */
-export function isBalances(type) {
+/* ============================== StakerKey =============================== */
+export function isStakerKey(type) {
     type = compressSuiType(type);
-    return type.startsWith(`${PKG_V1}::reserve::Balances` + "<");
+    return type === `${getTypeOrigin('suilend', 'reserve::StakerKey')}::reserve::StakerKey`;
 }
-export class Balances {
+export class StakerKey {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::reserve::Balances`;
-    static $numTypeParams = 2;
-    static $isPhantom = [true, true];
-    $typeName = Balances.$typeName;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::StakerKey')}::reserve::StakerKey`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = StakerKey.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = Balances.$isPhantom;
-    availableAmount;
-    ctokenSupply;
-    fees;
-    ctokenFees;
-    depositedCtokens;
+    $isPhantom = StakerKey.$isPhantom;
+    dummyField;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(Balances.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(StakerKey.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.availableAmount = fields.availableAmount;
-        this.ctokenSupply = fields.ctokenSupply;
-        this.fees = fields.fees;
-        this.ctokenFees = fields.ctokenFees;
-        this.depositedCtokens = fields.depositedCtokens;
+        this.dummyField = fields.dummyField;
     }
-    static reified(P, T) {
+    static reified() {
+        const reifiedBcs = StakerKey.bcs;
         return {
-            typeName: Balances.$typeName,
-            fullTypeName: composeSuiType(Balances.$typeName, ...[extractType(P), extractType(T)]),
-            typeArgs: [extractType(P), extractType(T)],
-            isPhantom: Balances.$isPhantom,
-            reifiedTypeArgs: [P, T],
-            fromFields: (fields) => Balances.fromFields([P, T], fields),
-            fromFieldsWithTypes: (item) => Balances.fromFieldsWithTypes([P, T], item),
-            fromBcs: (data) => Balances.fromBcs([P, T], data),
-            bcs: Balances.bcs,
-            fromJSONField: (field) => Balances.fromJSONField([P, T], field),
-            fromJSON: (json) => Balances.fromJSON([P, T], json),
-            fetch: async (client, id) => Balances.fetch(client, [P, T], id),
+            get typeName() {
+                return StakerKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(StakerKey.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: StakerKey.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => StakerKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => StakerKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => StakerKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => StakerKey.fromJSONField(field),
+            fromJSON: (json) => StakerKey.fromJSON(json),
+            fromCoreObject: (obj) => StakerKey.fromCoreObject(obj),
+            fetch: async (client, id) => StakerKey.fetch(client, id),
             new: (fields) => {
-                return new Balances([extractType(P), extractType(T)], fields);
+                return new StakerKey([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return Balances.reified;
+        return StakerKey.reified();
+    }
+    static phantom() {
+        return phantom(StakerKey.reified());
+    }
+    static get p() {
+        return StakerKey.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('StakerKey', {
+            dummy_field: bcs.bool(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!StakerKey.cachedBcs) {
+            StakerKey.cachedBcs = StakerKey.instantiateBcs();
+        }
+        return StakerKey.cachedBcs;
+    }
+    static fromFields(fields) {
+        return StakerKey.reified().new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isStakerKey(item.type)) {
+            throw new Error('not a StakerKey type');
+        }
+        return StakerKey.reified().new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
+        });
+    }
+    static fromBcs(data) {
+        return StakerKey.fromFields(StakerKey.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return StakerKey.reified().new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== StakerKey.$typeName) {
+            throw new Error(`not a StakerKey json object: expected '${StakerKey.$typeName}' but got '${json.$typeName}'`);
+        }
+        return StakerKey.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isStakerKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a StakerKey object`);
+        }
+        return StakerKey.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isStakerKey(object.type)) {
+            throw new Error(`object at id ${id} is not a StakerKey object`);
+        }
+        return StakerKey.fromBcs(object.content);
+    }
+}
+/* ============================== ReservePauseKey =============================== */
+export function isReservePauseKey(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'reserve::ReservePauseKey')}::reserve::ReservePauseKey`;
+}
+export class ReservePauseKey {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::ReservePauseKey')}::reserve::ReservePauseKey`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = ReservePauseKey.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = ReservePauseKey.$isPhantom;
+    dummyField;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(ReservePauseKey.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.dummyField = fields.dummyField;
+    }
+    static reified() {
+        const reifiedBcs = ReservePauseKey.bcs;
+        return {
+            get typeName() {
+                return ReservePauseKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ReservePauseKey.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: ReservePauseKey.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => ReservePauseKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => ReservePauseKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => ReservePauseKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => ReservePauseKey.fromJSONField(field),
+            fromJSON: (json) => ReservePauseKey.fromJSON(json),
+            fromCoreObject: (obj) => ReservePauseKey.fromCoreObject(obj),
+            fetch: async (client, id) => ReservePauseKey.fetch(client, id),
+            new: (fields) => {
+                return new ReservePauseKey([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return ReservePauseKey.reified();
     }
-    static phantom(P, T) {
-        return phantom(Balances.reified(P, T));
+    static phantom() {
+        return phantom(ReservePauseKey.reified());
     }
     static get p() {
-        return Balances.phantom;
+        return ReservePauseKey.phantom();
     }
-    static get bcs() {
-        return bcs.struct("Balances", {
-            available_amount: Balance.bcs,
-            ctoken_supply: Supply.bcs,
-            fees: Balance.bcs,
-            ctoken_fees: Balance.bcs,
-            deposited_ctokens: Balance.bcs,
+    static instantiateBcs() {
+        return bcs.struct('ReservePauseKey', {
+            dummy_field: bcs.bool(),
         });
     }
-    static fromFields(typeArgs, fields) {
-        return Balances.reified(typeArgs[0], typeArgs[1]).new({
-            availableAmount: decodeFromFields(Balance.reified(typeArgs[1]), fields.available_amount),
-            ctokenSupply: decodeFromFields(Supply.reified(reified.phantom(CToken.reified(typeArgs[0], typeArgs[1]))), fields.ctoken_supply),
-            fees: decodeFromFields(Balance.reified(typeArgs[1]), fields.fees),
-            ctokenFees: decodeFromFields(Balance.reified(reified.phantom(CToken.reified(typeArgs[0], typeArgs[1]))), fields.ctoken_fees),
-            depositedCtokens: decodeFromFields(Balance.reified(reified.phantom(CToken.reified(typeArgs[0], typeArgs[1]))), fields.deposited_ctokens),
+    static cachedBcs = null;
+    static get bcs() {
+        if (!ReservePauseKey.cachedBcs) {
+            ReservePauseKey.cachedBcs = ReservePauseKey.instantiateBcs();
+        }
+        return ReservePauseKey.cachedBcs;
+    }
+    static fromFields(fields) {
+        return ReservePauseKey.reified().new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
         });
     }
-    static fromFieldsWithTypes(typeArgs, item) {
-        if (!isBalances(item.type)) {
-            throw new Error("not a Balances type");
+    static fromFieldsWithTypes(item) {
+        if (!isReservePauseKey(item.type)) {
+            throw new Error('not a ReservePauseKey type');
         }
-        assertFieldsWithTypesArgsMatch(item, typeArgs);
-        return Balances.reified(typeArgs[0], typeArgs[1]).new({
-            availableAmount: decodeFromFieldsWithTypes(Balance.reified(typeArgs[1]), item.fields.available_amount),
-            ctokenSupply: decodeFromFieldsWithTypes(Supply.reified(reified.phantom(CToken.reified(typeArgs[0], typeArgs[1]))), item.fields.ctoken_supply),
-            fees: decodeFromFieldsWithTypes(Balance.reified(typeArgs[1]), item.fields.fees),
-            ctokenFees: decodeFromFieldsWithTypes(Balance.reified(reified.phantom(CToken.reified(typeArgs[0], typeArgs[1]))), item.fields.ctoken_fees),
-            depositedCtokens: decodeFromFieldsWithTypes(Balance.reified(reified.phantom(CToken.reified(typeArgs[0], typeArgs[1]))), item.fields.deposited_ctokens),
+        return ReservePauseKey.reified().new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
         });
     }
-    static fromBcs(typeArgs, data) {
-        return Balances.fromFields(typeArgs, Balances.bcs.parse(data));
+    static fromBcs(data) {
+        return ReservePauseKey.fromFields(ReservePauseKey.bcs.parse(data));
     }
     toJSONField() {
         return {
-            availableAmount: this.availableAmount.toJSONField(),
-            ctokenSupply: this.ctokenSupply.toJSONField(),
-            fees: this.fees.toJSONField(),
-            ctokenFees: this.ctokenFees.toJSONField(),
-            depositedCtokens: this.depositedCtokens.toJSONField(),
+            dummyField: this.dummyField,
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
-    static fromJSONField(typeArgs, field) {
-        return Balances.reified(typeArgs[0], typeArgs[1]).new({
-            availableAmount: decodeFromJSONField(Balance.reified(typeArgs[1]), field.availableAmount),
-            ctokenSupply: decodeFromJSONField(Supply.reified(reified.phantom(CToken.reified(typeArgs[0], typeArgs[1]))), field.ctokenSupply),
-            fees: decodeFromJSONField(Balance.reified(typeArgs[1]), field.fees),
-            ctokenFees: decodeFromJSONField(Balance.reified(reified.phantom(CToken.reified(typeArgs[0], typeArgs[1]))), field.ctokenFees),
-            depositedCtokens: decodeFromJSONField(Balance.reified(reified.phantom(CToken.reified(typeArgs[0], typeArgs[1]))), field.depositedCtokens),
+    static fromJSONField(field) {
+        return ReservePauseKey.reified().new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
         });
     }
-    static fromJSON(typeArgs, json) {
-        if (json.$typeName !== Balances.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+    static fromJSON(json) {
+        if (json.$typeName !== ReservePauseKey.$typeName) {
+            throw new Error(`not a ReservePauseKey json object: expected '${ReservePauseKey.$typeName}' but got '${json.$typeName}'`);
         }
-        assertReifiedTypeArgsMatch(composeSuiType(Balances.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs);
-        return Balances.fromJSONField(typeArgs, json);
+        return ReservePauseKey.fromJSONField(json);
     }
-    static async fetch(client, typeArgs, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isBalances(object.type)) {
-            throw new Error(`object at id ${id} is not a Balances object`);
+    static fromCoreObject(obj) {
+        if (!isReservePauseKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ReservePauseKey object`);
         }
-        return Balances.fromBcs(typeArgs, object.content);
+        return ReservePauseKey.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isReservePauseKey(object.type)) {
+            throw new Error(`object at id ${id} is not a ReservePauseKey object`);
+        }
+        return ReservePauseKey.fromBcs(object.content);
     }
 }
-/* ============================== CToken =============================== */
-export function isCToken(type) {
+/* ============================== PriceGuardKey =============================== */
+export function isPriceGuardKey(type) {
     type = compressSuiType(type);
-    return type.startsWith(`${PKG_V1}::reserve::CToken` + "<");
+    return type === `${getTypeOrigin('suilend', 'reserve::PriceGuardKey')}::reserve::PriceGuardKey`;
 }
-export class CToken {
+export class PriceGuardKey {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::reserve::CToken`;
-    static $numTypeParams = 2;
-    static $isPhantom = [true, true];
-    $typeName = CToken.$typeName;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::PriceGuardKey')}::reserve::PriceGuardKey`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = PriceGuardKey.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = CToken.$isPhantom;
+    $isPhantom = PriceGuardKey.$isPhantom;
     dummyField;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(CToken.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(PriceGuardKey.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.dummyField = fields.dummyField;
     }
-    static reified(P, T) {
+    static reified() {
+        const reifiedBcs = PriceGuardKey.bcs;
         return {
-            typeName: CToken.$typeName,
-            fullTypeName: composeSuiType(CToken.$typeName, ...[extractType(P), extractType(T)]),
-            typeArgs: [extractType(P), extractType(T)],
-            isPhantom: CToken.$isPhantom,
-            reifiedTypeArgs: [P, T],
-            fromFields: (fields) => CToken.fromFields([P, T], fields),
-            fromFieldsWithTypes: (item) => CToken.fromFieldsWithTypes([P, T], item),
-            fromBcs: (data) => CToken.fromBcs([P, T], data),
-            bcs: CToken.bcs,
-            fromJSONField: (field) => CToken.fromJSONField([P, T], field),
-            fromJSON: (json) => CToken.fromJSON([P, T], json),
-            fetch: async (client, id) => CToken.fetch(client, [P, T], id),
+            get typeName() {
+                return PriceGuardKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(PriceGuardKey.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: PriceGuardKey.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => PriceGuardKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => PriceGuardKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => PriceGuardKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => PriceGuardKey.fromJSONField(field),
+            fromJSON: (json) => PriceGuardKey.fromJSON(json),
+            fromCoreObject: (obj) => PriceGuardKey.fromCoreObject(obj),
+            fetch: async (client, id) => PriceGuardKey.fetch(client, id),
             new: (fields) => {
-                return new CToken([extractType(P), extractType(T)], fields);
+                return new PriceGuardKey([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return CToken.reified;
+        return PriceGuardKey.reified();
     }
-    static phantom(P, T) {
-        return phantom(CToken.reified(P, T));
+    static phantom() {
+        return phantom(PriceGuardKey.reified());
     }
     static get p() {
-        return CToken.phantom;
+        return PriceGuardKey.phantom();
     }
-    static get bcs() {
-        return bcs.struct("CToken", {
+    static instantiateBcs() {
+        return bcs.struct('PriceGuardKey', {
             dummy_field: bcs.bool(),
         });
     }
-    static fromFields(typeArgs, fields) {
-        return CToken.reified(typeArgs[0], typeArgs[1]).new({
-            dummyField: decodeFromFields("bool", fields.dummy_field),
+    static cachedBcs = null;
+    static get bcs() {
+        if (!PriceGuardKey.cachedBcs) {
+            PriceGuardKey.cachedBcs = PriceGuardKey.instantiateBcs();
+        }
+        return PriceGuardKey.cachedBcs;
+    }
+    static fromFields(fields) {
+        return PriceGuardKey.reified().new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
         });
     }
-    static fromFieldsWithTypes(typeArgs, item) {
-        if (!isCToken(item.type)) {
-            throw new Error("not a CToken type");
+    static fromFieldsWithTypes(item) {
+        if (!isPriceGuardKey(item.type)) {
+            throw new Error('not a PriceGuardKey type');
         }
-        assertFieldsWithTypesArgsMatch(item, typeArgs);
-        return CToken.reified(typeArgs[0], typeArgs[1]).new({
-            dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field),
+        return PriceGuardKey.reified().new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
         });
     }
-    static fromBcs(typeArgs, data) {
-        return CToken.fromFields(typeArgs, CToken.bcs.parse(data));
+    static fromBcs(data) {
+        return PriceGuardKey.fromFields(PriceGuardKey.bcs.parse(data));
     }
     toJSONField() {
         return {
@@ -321,714 +1047,718 @@ export class CToken {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
-    static fromJSONField(typeArgs, field) {
-        return CToken.reified(typeArgs[0], typeArgs[1]).new({
-            dummyField: decodeFromJSONField("bool", field.dummyField),
+    static fromJSONField(field) {
+        return PriceGuardKey.reified().new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
         });
     }
-    static fromJSON(typeArgs, json) {
-        if (json.$typeName !== CToken.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+    static fromJSON(json) {
+        if (json.$typeName !== PriceGuardKey.$typeName) {
+            throw new Error(`not a PriceGuardKey json object: expected '${PriceGuardKey.$typeName}' but got '${json.$typeName}'`);
         }
-        assertReifiedTypeArgsMatch(composeSuiType(CToken.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs);
-        return CToken.fromJSONField(typeArgs, json);
+        return PriceGuardKey.fromJSONField(json);
     }
-    static async fetch(client, typeArgs, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isCToken(object.type)) {
-            throw new Error(`object at id ${id} is not a CToken object`);
+    static fromCoreObject(obj) {
+        if (!isPriceGuardKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a PriceGuardKey object`);
         }
-        return CToken.fromBcs(typeArgs, object.content);
+        return PriceGuardKey.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isPriceGuardKey(object.type)) {
+            throw new Error(`object at id ${id} is not a PriceGuardKey object`);
+        }
+        return PriceGuardKey.fromBcs(object.content);
     }
 }
-/* ============================== ClaimStakingRewardsEvent =============================== */
-export function isClaimStakingRewardsEvent(type) {
+/* ============================== ConfidenceKey =============================== */
+export function isConfidenceKey(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V8}::reserve::ClaimStakingRewardsEvent`;
+    return type === `${getTypeOrigin('suilend', 'reserve::ConfidenceKey')}::reserve::ConfidenceKey`;
 }
-export class ClaimStakingRewardsEvent {
+export class ConfidenceKey {
     __StructClass = true;
-    static $typeName = `${PKG_V8}::reserve::ClaimStakingRewardsEvent`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::ConfidenceKey')}::reserve::ConfidenceKey`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = ClaimStakingRewardsEvent.$typeName;
+    $typeName = ConfidenceKey.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = ClaimStakingRewardsEvent.$isPhantom;
-    lendingMarketId;
-    coinType;
-    reserveId;
-    amount;
+    $isPhantom = ConfidenceKey.$isPhantom;
+    dummyField;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(ClaimStakingRewardsEvent.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(ConfidenceKey.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.lendingMarketId = fields.lendingMarketId;
-        this.coinType = fields.coinType;
-        this.reserveId = fields.reserveId;
-        this.amount = fields.amount;
+        this.dummyField = fields.dummyField;
     }
     static reified() {
+        const reifiedBcs = ConfidenceKey.bcs;
         return {
-            typeName: ClaimStakingRewardsEvent.$typeName,
-            fullTypeName: composeSuiType(ClaimStakingRewardsEvent.$typeName, ...[]),
+            get typeName() {
+                return ConfidenceKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ConfidenceKey.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: ClaimStakingRewardsEvent.$isPhantom,
+            isPhantom: ConfidenceKey.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => ClaimStakingRewardsEvent.fromFields(fields),
-            fromFieldsWithTypes: (item) => ClaimStakingRewardsEvent.fromFieldsWithTypes(item),
-            fromBcs: (data) => ClaimStakingRewardsEvent.fromBcs(data),
-            bcs: ClaimStakingRewardsEvent.bcs,
-            fromJSONField: (field) => ClaimStakingRewardsEvent.fromJSONField(field),
-            fromJSON: (json) => ClaimStakingRewardsEvent.fromJSON(json),
-            fetch: async (client, id) => ClaimStakingRewardsEvent.fetch(client, id),
+            fromFields: (fields) => ConfidenceKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => ConfidenceKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => ConfidenceKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => ConfidenceKey.fromJSONField(field),
+            fromJSON: (json) => ConfidenceKey.fromJSON(json),
+            fromCoreObject: (obj) => ConfidenceKey.fromCoreObject(obj),
+            fetch: async (client, id) => ConfidenceKey.fetch(client, id),
             new: (fields) => {
-                return new ClaimStakingRewardsEvent([], fields);
+                return new ConfidenceKey([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return ClaimStakingRewardsEvent.reified();
+        return ConfidenceKey.reified();
     }
     static phantom() {
-        return phantom(ClaimStakingRewardsEvent.reified());
+        return phantom(ConfidenceKey.reified());
     }
     static get p() {
-        return ClaimStakingRewardsEvent.phantom();
+        return ConfidenceKey.phantom();
     }
-    static get bcs() {
-        return bcs.struct("ClaimStakingRewardsEvent", {
-            lending_market_id: bcs
-                .bytes(32)
-                .transform({
-                input: (val) => fromHex(val),
-                output: (val) => toHex(val),
-            }),
-            coin_type: TypeName.bcs,
-            reserve_id: bcs
-                .bytes(32)
-                .transform({
-                input: (val) => fromHex(val),
-                output: (val) => toHex(val),
-            }),
-            amount: bcs.u64(),
+    static instantiateBcs() {
+        return bcs.struct('ConfidenceKey', {
+            dummy_field: bcs.bool(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!ConfidenceKey.cachedBcs) {
+            ConfidenceKey.cachedBcs = ConfidenceKey.instantiateBcs();
+        }
+        return ConfidenceKey.cachedBcs;
+    }
     static fromFields(fields) {
-        return ClaimStakingRewardsEvent.reified().new({
-            lendingMarketId: decodeFromFields("address", fields.lending_market_id),
-            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveId: decodeFromFields("address", fields.reserve_id),
-            amount: decodeFromFields("u64", fields.amount),
+        return ConfidenceKey.reified().new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isClaimStakingRewardsEvent(item.type)) {
-            throw new Error("not a ClaimStakingRewardsEvent type");
+        if (!isConfidenceKey(item.type)) {
+            throw new Error('not a ConfidenceKey type');
         }
-        return ClaimStakingRewardsEvent.reified().new({
-            lendingMarketId: decodeFromFieldsWithTypes("address", item.fields.lending_market_id),
-            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveId: decodeFromFieldsWithTypes("address", item.fields.reserve_id),
-            amount: decodeFromFieldsWithTypes("u64", item.fields.amount),
+        return ConfidenceKey.reified().new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
         });
     }
     static fromBcs(data) {
-        return ClaimStakingRewardsEvent.fromFields(ClaimStakingRewardsEvent.bcs.parse(data));
+        return ConfidenceKey.fromFields(ConfidenceKey.bcs.parse(data));
     }
     toJSONField() {
         return {
-            lendingMarketId: this.lendingMarketId,
-            coinType: this.coinType.toJSONField(),
-            reserveId: this.reserveId,
-            amount: this.amount.toString(),
+            dummyField: this.dummyField,
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return ClaimStakingRewardsEvent.reified().new({
-            lendingMarketId: decodeFromJSONField("address", field.lendingMarketId),
-            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveId: decodeFromJSONField("address", field.reserveId),
-            amount: decodeFromJSONField("u64", field.amount),
+        return ConfidenceKey.reified().new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== ClaimStakingRewardsEvent.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== ConfidenceKey.$typeName) {
+            throw new Error(`not a ConfidenceKey json object: expected '${ConfidenceKey.$typeName}' but got '${json.$typeName}'`);
         }
-        return ClaimStakingRewardsEvent.fromJSONField(json);
+        return ConfidenceKey.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isConfidenceKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ConfidenceKey object`);
+        }
+        return ConfidenceKey.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isClaimStakingRewardsEvent(object.type)) {
-            throw new Error(`object at id ${id} is not a ClaimStakingRewardsEvent object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isConfidenceKey(object.type)) {
+            throw new Error(`object at id ${id} is not a ConfidenceKey object`);
         }
-        return ClaimStakingRewardsEvent.fromBcs(object.content);
+        return ConfidenceKey.fromBcs(object.content);
     }
 }
-/* ============================== InterestUpdateEvent =============================== */
-export function isInterestUpdateEvent(type) {
+/* ============================== PriceGuard =============================== */
+export function isPriceGuard(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::reserve::InterestUpdateEvent`;
+    return type === `${getTypeOrigin('suilend', 'reserve::PriceGuard')}::reserve::PriceGuard`;
 }
-export class InterestUpdateEvent {
+/**
+ * Bounds how far `price` and `smoothed_price` may move per
+ * `min_update_interval_s`. Each anchor moves at most one band per interval and is
+ * advanced to the clamped value, so repeating a refresh inside one PTB cannot walk
+ * either price further than a single band.
+ */
+export class PriceGuard {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::reserve::InterestUpdateEvent`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::PriceGuard')}::reserve::PriceGuard`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = InterestUpdateEvent.$typeName;
+    $typeName = PriceGuard.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = InterestUpdateEvent.$isPhantom;
-    lendingMarketId;
-    coinType;
-    reserveId;
-    cumulativeBorrowRate;
-    availableAmount;
-    borrowedAmount;
-    unclaimedSpreadFees;
-    ctokenSupply;
-    borrowInterestPaid;
-    spreadFee;
-    supplyInterestEarned;
-    borrowInterestPaidUsdEstimate;
-    protocolFeeUsdEstimate;
-    supplyInterestEarnedUsdEstimate;
+    $isPhantom = PriceGuard.$isPhantom;
+    maxPriceChangeBps;
+    minUpdateIntervalS;
+    priceAnchor;
+    smoothedPriceAnchor;
+    anchorTimestampS;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(InterestUpdateEvent.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(PriceGuard.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.lendingMarketId = fields.lendingMarketId;
-        this.coinType = fields.coinType;
-        this.reserveId = fields.reserveId;
-        this.cumulativeBorrowRate = fields.cumulativeBorrowRate;
-        this.availableAmount = fields.availableAmount;
-        this.borrowedAmount = fields.borrowedAmount;
-        this.unclaimedSpreadFees = fields.unclaimedSpreadFees;
-        this.ctokenSupply = fields.ctokenSupply;
-        this.borrowInterestPaid = fields.borrowInterestPaid;
-        this.spreadFee = fields.spreadFee;
-        this.supplyInterestEarned = fields.supplyInterestEarned;
-        this.borrowInterestPaidUsdEstimate = fields.borrowInterestPaidUsdEstimate;
-        this.protocolFeeUsdEstimate = fields.protocolFeeUsdEstimate;
-        this.supplyInterestEarnedUsdEstimate =
-            fields.supplyInterestEarnedUsdEstimate;
+        this.maxPriceChangeBps = fields.maxPriceChangeBps;
+        this.minUpdateIntervalS = fields.minUpdateIntervalS;
+        this.priceAnchor = fields.priceAnchor;
+        this.smoothedPriceAnchor = fields.smoothedPriceAnchor;
+        this.anchorTimestampS = fields.anchorTimestampS;
     }
     static reified() {
+        const reifiedBcs = PriceGuard.bcs;
         return {
-            typeName: InterestUpdateEvent.$typeName,
-            fullTypeName: composeSuiType(InterestUpdateEvent.$typeName, ...[]),
+            get typeName() {
+                return PriceGuard.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(PriceGuard.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: InterestUpdateEvent.$isPhantom,
+            isPhantom: PriceGuard.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => InterestUpdateEvent.fromFields(fields),
-            fromFieldsWithTypes: (item) => InterestUpdateEvent.fromFieldsWithTypes(item),
-            fromBcs: (data) => InterestUpdateEvent.fromBcs(data),
-            bcs: InterestUpdateEvent.bcs,
-            fromJSONField: (field) => InterestUpdateEvent.fromJSONField(field),
-            fromJSON: (json) => InterestUpdateEvent.fromJSON(json),
-            fetch: async (client, id) => InterestUpdateEvent.fetch(client, id),
+            fromFields: (fields) => PriceGuard.fromFields(fields),
+            fromFieldsWithTypes: (item) => PriceGuard.fromFieldsWithTypes(item),
+            fromBcs: (data) => PriceGuard.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => PriceGuard.fromJSONField(field),
+            fromJSON: (json) => PriceGuard.fromJSON(json),
+            fromCoreObject: (obj) => PriceGuard.fromCoreObject(obj),
+            fetch: async (client, id) => PriceGuard.fetch(client, id),
             new: (fields) => {
-                return new InterestUpdateEvent([], fields);
-            },
-            kind: "StructClassReified",
-        };
-    }
-    static get r() {
-        return InterestUpdateEvent.reified();
-    }
-    static phantom() {
-        return phantom(InterestUpdateEvent.reified());
-    }
-    static get p() {
-        return InterestUpdateEvent.phantom();
-    }
-    static get bcs() {
-        return bcs.struct("InterestUpdateEvent", {
-            lending_market_id: bcs
-                .bytes(32)
-                .transform({
-                input: (val) => fromHex(val),
-                output: (val) => toHex(val),
-            }),
-            coin_type: TypeName.bcs,
-            reserve_id: bcs
-                .bytes(32)
-                .transform({
-                input: (val) => fromHex(val),
-                output: (val) => toHex(val),
-            }),
-            cumulative_borrow_rate: Decimal.bcs,
-            available_amount: bcs.u64(),
-            borrowed_amount: Decimal.bcs,
-            unclaimed_spread_fees: Decimal.bcs,
-            ctoken_supply: bcs.u64(),
-            borrow_interest_paid: Decimal.bcs,
-            spread_fee: Decimal.bcs,
-            supply_interest_earned: Decimal.bcs,
-            borrow_interest_paid_usd_estimate: Decimal.bcs,
-            protocol_fee_usd_estimate: Decimal.bcs,
-            supply_interest_earned_usd_estimate: Decimal.bcs,
+                return new PriceGuard([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return PriceGuard.reified();
+    }
+    static phantom() {
+        return phantom(PriceGuard.reified());
+    }
+    static get p() {
+        return PriceGuard.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('PriceGuard', {
+            max_price_change_bps: bcs.u64(),
+            min_update_interval_s: bcs.u64(),
+            price_anchor: Decimal.bcs,
+            smoothed_price_anchor: Decimal.bcs,
+            anchor_timestamp_s: bcs.u64(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!PriceGuard.cachedBcs) {
+            PriceGuard.cachedBcs = PriceGuard.instantiateBcs();
+        }
+        return PriceGuard.cachedBcs;
+    }
     static fromFields(fields) {
-        return InterestUpdateEvent.reified().new({
-            lendingMarketId: decodeFromFields("address", fields.lending_market_id),
-            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveId: decodeFromFields("address", fields.reserve_id),
-            cumulativeBorrowRate: decodeFromFields(Decimal.reified(), fields.cumulative_borrow_rate),
-            availableAmount: decodeFromFields("u64", fields.available_amount),
-            borrowedAmount: decodeFromFields(Decimal.reified(), fields.borrowed_amount),
-            unclaimedSpreadFees: decodeFromFields(Decimal.reified(), fields.unclaimed_spread_fees),
-            ctokenSupply: decodeFromFields("u64", fields.ctoken_supply),
-            borrowInterestPaid: decodeFromFields(Decimal.reified(), fields.borrow_interest_paid),
-            spreadFee: decodeFromFields(Decimal.reified(), fields.spread_fee),
-            supplyInterestEarned: decodeFromFields(Decimal.reified(), fields.supply_interest_earned),
-            borrowInterestPaidUsdEstimate: decodeFromFields(Decimal.reified(), fields.borrow_interest_paid_usd_estimate),
-            protocolFeeUsdEstimate: decodeFromFields(Decimal.reified(), fields.protocol_fee_usd_estimate),
-            supplyInterestEarnedUsdEstimate: decodeFromFields(Decimal.reified(), fields.supply_interest_earned_usd_estimate),
+        return PriceGuard.reified().new({
+            maxPriceChangeBps: decodeFromFields('u64', fields.max_price_change_bps),
+            minUpdateIntervalS: decodeFromFields('u64', fields.min_update_interval_s),
+            priceAnchor: decodeFromFields(Decimal.reified(), fields.price_anchor),
+            smoothedPriceAnchor: decodeFromFields(Decimal.reified(), fields.smoothed_price_anchor),
+            anchorTimestampS: decodeFromFields('u64', fields.anchor_timestamp_s),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isInterestUpdateEvent(item.type)) {
-            throw new Error("not a InterestUpdateEvent type");
+        if (!isPriceGuard(item.type)) {
+            throw new Error('not a PriceGuard type');
         }
-        return InterestUpdateEvent.reified().new({
-            lendingMarketId: decodeFromFieldsWithTypes("address", item.fields.lending_market_id),
-            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveId: decodeFromFieldsWithTypes("address", item.fields.reserve_id),
-            cumulativeBorrowRate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.cumulative_borrow_rate),
-            availableAmount: decodeFromFieldsWithTypes("u64", item.fields.available_amount),
-            borrowedAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrowed_amount),
-            unclaimedSpreadFees: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.unclaimed_spread_fees),
-            ctokenSupply: decodeFromFieldsWithTypes("u64", item.fields.ctoken_supply),
-            borrowInterestPaid: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrow_interest_paid),
-            spreadFee: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.spread_fee),
-            supplyInterestEarned: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.supply_interest_earned),
-            borrowInterestPaidUsdEstimate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrow_interest_paid_usd_estimate),
-            protocolFeeUsdEstimate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.protocol_fee_usd_estimate),
-            supplyInterestEarnedUsdEstimate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.supply_interest_earned_usd_estimate),
+        return PriceGuard.reified().new({
+            maxPriceChangeBps: decodeFromFieldsWithTypes('u64', item.fields.max_price_change_bps),
+            minUpdateIntervalS: decodeFromFieldsWithTypes('u64', item.fields.min_update_interval_s),
+            priceAnchor: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.price_anchor),
+            smoothedPriceAnchor: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.smoothed_price_anchor),
+            anchorTimestampS: decodeFromFieldsWithTypes('u64', item.fields.anchor_timestamp_s),
         });
     }
     static fromBcs(data) {
-        return InterestUpdateEvent.fromFields(InterestUpdateEvent.bcs.parse(data));
+        return PriceGuard.fromFields(PriceGuard.bcs.parse(data));
     }
     toJSONField() {
         return {
-            lendingMarketId: this.lendingMarketId,
-            coinType: this.coinType.toJSONField(),
-            reserveId: this.reserveId,
-            cumulativeBorrowRate: this.cumulativeBorrowRate.toJSONField(),
-            availableAmount: this.availableAmount.toString(),
-            borrowedAmount: this.borrowedAmount.toJSONField(),
-            unclaimedSpreadFees: this.unclaimedSpreadFees.toJSONField(),
-            ctokenSupply: this.ctokenSupply.toString(),
-            borrowInterestPaid: this.borrowInterestPaid.toJSONField(),
-            spreadFee: this.spreadFee.toJSONField(),
-            supplyInterestEarned: this.supplyInterestEarned.toJSONField(),
-            borrowInterestPaidUsdEstimate: this.borrowInterestPaidUsdEstimate.toJSONField(),
-            protocolFeeUsdEstimate: this.protocolFeeUsdEstimate.toJSONField(),
-            supplyInterestEarnedUsdEstimate: this.supplyInterestEarnedUsdEstimate.toJSONField(),
+            maxPriceChangeBps: this.maxPriceChangeBps.toString(),
+            minUpdateIntervalS: this.minUpdateIntervalS.toString(),
+            priceAnchor: this.priceAnchor.toJSONField(),
+            smoothedPriceAnchor: this.smoothedPriceAnchor.toJSONField(),
+            anchorTimestampS: this.anchorTimestampS.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return InterestUpdateEvent.reified().new({
-            lendingMarketId: decodeFromJSONField("address", field.lendingMarketId),
-            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveId: decodeFromJSONField("address", field.reserveId),
-            cumulativeBorrowRate: decodeFromJSONField(Decimal.reified(), field.cumulativeBorrowRate),
-            availableAmount: decodeFromJSONField("u64", field.availableAmount),
-            borrowedAmount: decodeFromJSONField(Decimal.reified(), field.borrowedAmount),
-            unclaimedSpreadFees: decodeFromJSONField(Decimal.reified(), field.unclaimedSpreadFees),
-            ctokenSupply: decodeFromJSONField("u64", field.ctokenSupply),
-            borrowInterestPaid: decodeFromJSONField(Decimal.reified(), field.borrowInterestPaid),
-            spreadFee: decodeFromJSONField(Decimal.reified(), field.spreadFee),
-            supplyInterestEarned: decodeFromJSONField(Decimal.reified(), field.supplyInterestEarned),
-            borrowInterestPaidUsdEstimate: decodeFromJSONField(Decimal.reified(), field.borrowInterestPaidUsdEstimate),
-            protocolFeeUsdEstimate: decodeFromJSONField(Decimal.reified(), field.protocolFeeUsdEstimate),
-            supplyInterestEarnedUsdEstimate: decodeFromJSONField(Decimal.reified(), field.supplyInterestEarnedUsdEstimate),
+        return PriceGuard.reified().new({
+            maxPriceChangeBps: decodeFromJSONField('u64', field.maxPriceChangeBps),
+            minUpdateIntervalS: decodeFromJSONField('u64', field.minUpdateIntervalS),
+            priceAnchor: decodeFromJSONField(Decimal.reified(), field.priceAnchor),
+            smoothedPriceAnchor: decodeFromJSONField(Decimal.reified(), field.smoothedPriceAnchor),
+            anchorTimestampS: decodeFromJSONField('u64', field.anchorTimestampS),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== InterestUpdateEvent.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== PriceGuard.$typeName) {
+            throw new Error(`not a PriceGuard json object: expected '${PriceGuard.$typeName}' but got '${json.$typeName}'`);
         }
-        return InterestUpdateEvent.fromJSONField(json);
+        return PriceGuard.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isPriceGuard(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a PriceGuard object`);
+        }
+        return PriceGuard.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isInterestUpdateEvent(object.type)) {
-            throw new Error(`object at id ${id} is not a InterestUpdateEvent object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isPriceGuard(object.type)) {
+            throw new Error(`object at id ${id} is not a PriceGuard object`);
         }
-        return InterestUpdateEvent.fromBcs(object.content);
+        return PriceGuard.fromBcs(object.content);
     }
 }
-/* ============================== LiquidityRequest =============================== */
-export function isLiquidityRequest(type) {
+/* ============================== Balances =============================== */
+export function isBalances(type) {
     type = compressSuiType(type);
-    return type.startsWith(`${PKG_V8}::reserve::LiquidityRequest` + "<");
+    return type.startsWith(`${getTypeOrigin('suilend', 'reserve::Balances')}::reserve::Balances` + '<');
 }
-export class LiquidityRequest {
+/** Balances are stored in a dynamic field to avoid typing the Reserve with CoinType */
+export class Balances {
     __StructClass = true;
-    static $typeName = `${PKG_V8}::reserve::LiquidityRequest`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::Balances')}::reserve::Balances`;
+    }
     static $numTypeParams = 2;
     static $isPhantom = [true, true];
-    $typeName = LiquidityRequest.$typeName;
+    $typeName = Balances.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = LiquidityRequest.$isPhantom;
-    amount;
-    fee;
+    $isPhantom = Balances.$isPhantom;
+    availableAmount;
+    ctokenSupply;
+    fees;
+    ctokenFees;
+    depositedCtokens;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(LiquidityRequest.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(Balances.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.amount = fields.amount;
-        this.fee = fields.fee;
+        this.availableAmount = fields.availableAmount;
+        this.ctokenSupply = fields.ctokenSupply;
+        this.fees = fields.fees;
+        this.ctokenFees = fields.ctokenFees;
+        this.depositedCtokens = fields.depositedCtokens;
     }
     static reified(P, T) {
+        const reifiedBcs = Balances.bcs;
         return {
-            typeName: LiquidityRequest.$typeName,
-            fullTypeName: composeSuiType(LiquidityRequest.$typeName, ...[extractType(P), extractType(T)]),
-            typeArgs: [extractType(P), extractType(T)],
-            isPhantom: LiquidityRequest.$isPhantom,
+            get typeName() {
+                return Balances.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(Balances.$typeName, ...[extractType(P), extractType(T)]);
+            },
+            get typeArgs() {
+                return [extractType(P), extractType(T)];
+            },
+            isPhantom: Balances.$isPhantom,
             reifiedTypeArgs: [P, T],
-            fromFields: (fields) => LiquidityRequest.fromFields([P, T], fields),
-            fromFieldsWithTypes: (item) => LiquidityRequest.fromFieldsWithTypes([P, T], item),
-            fromBcs: (data) => LiquidityRequest.fromBcs([P, T], data),
-            bcs: LiquidityRequest.bcs,
-            fromJSONField: (field) => LiquidityRequest.fromJSONField([P, T], field),
-            fromJSON: (json) => LiquidityRequest.fromJSON([P, T], json),
-            fetch: async (client, id) => LiquidityRequest.fetch(client, [P, T], id),
+            fromFields: (fields) => Balances.fromFields([P, T], fields),
+            fromFieldsWithTypes: (item) => Balances.fromFieldsWithTypes([P, T], item),
+            fromBcs: (data) => Balances.fromFields([P, T], reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => Balances.fromJSONField([P, T], field),
+            fromJSON: (json) => Balances.fromJSON([P, T], json),
+            fromCoreObject: (obj) => Balances.fromCoreObject([P, T], obj),
+            fetch: async (client, id) => Balances.fetch(client, [P, T], id),
             new: (fields) => {
-                return new LiquidityRequest([extractType(P), extractType(T)], fields);
+                return new Balances([extractType(P), extractType(T)], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return LiquidityRequest.reified;
+        return Balances.reified;
     }
     static phantom(P, T) {
-        return phantom(LiquidityRequest.reified(P, T));
+        return phantom(Balances.reified(P, T));
     }
     static get p() {
-        return LiquidityRequest.phantom;
+        return Balances.phantom;
     }
-    static get bcs() {
-        return bcs.struct("LiquidityRequest", {
-            amount: bcs.u64(),
-            fee: bcs.u64(),
+    static instantiateBcs() {
+        return bcs.struct('Balances', {
+            available_amount: Balance.bcs,
+            ctoken_supply: Supply.bcs,
+            fees: Balance.bcs,
+            ctoken_fees: Balance.bcs,
+            deposited_ctokens: Balance.bcs,
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!Balances.cachedBcs) {
+            Balances.cachedBcs = Balances.instantiateBcs();
+        }
+        return Balances.cachedBcs;
+    }
     static fromFields(typeArgs, fields) {
-        return LiquidityRequest.reified(typeArgs[0], typeArgs[1]).new({
-            amount: decodeFromFields("u64", fields.amount),
-            fee: decodeFromFields("u64", fields.fee),
+        return Balances.reified(typeArgs[0], typeArgs[1]).new({
+            availableAmount: decodeFromFields(Balance.reified(typeArgs[1]), fields.available_amount),
+            ctokenSupply: decodeFromFields(Supply.reified(phantom(CToken.reified(typeArgs[0], typeArgs[1]))), fields.ctoken_supply),
+            fees: decodeFromFields(Balance.reified(typeArgs[1]), fields.fees),
+            ctokenFees: decodeFromFields(Balance.reified(phantom(CToken.reified(typeArgs[0], typeArgs[1]))), fields.ctoken_fees),
+            depositedCtokens: decodeFromFields(Balance.reified(phantom(CToken.reified(typeArgs[0], typeArgs[1]))), fields.deposited_ctokens),
         });
     }
     static fromFieldsWithTypes(typeArgs, item) {
-        if (!isLiquidityRequest(item.type)) {
-            throw new Error("not a LiquidityRequest type");
+        if (!isBalances(item.type)) {
+            throw new Error('not a Balances type');
         }
         assertFieldsWithTypesArgsMatch(item, typeArgs);
-        return LiquidityRequest.reified(typeArgs[0], typeArgs[1]).new({
-            amount: decodeFromFieldsWithTypes("u64", item.fields.amount),
-            fee: decodeFromFieldsWithTypes("u64", item.fields.fee),
+        return Balances.reified(typeArgs[0], typeArgs[1]).new({
+            availableAmount: decodeFromFieldsWithTypes(Balance.reified(typeArgs[1]), item.fields.available_amount),
+            ctokenSupply: decodeFromFieldsWithTypes(Supply.reified(phantom(CToken.reified(typeArgs[0], typeArgs[1]))), item.fields.ctoken_supply),
+            fees: decodeFromFieldsWithTypes(Balance.reified(typeArgs[1]), item.fields.fees),
+            ctokenFees: decodeFromFieldsWithTypes(Balance.reified(phantom(CToken.reified(typeArgs[0], typeArgs[1]))), item.fields.ctoken_fees),
+            depositedCtokens: decodeFromFieldsWithTypes(Balance.reified(phantom(CToken.reified(typeArgs[0], typeArgs[1]))), item.fields.deposited_ctokens),
         });
     }
     static fromBcs(typeArgs, data) {
-        return LiquidityRequest.fromFields(typeArgs, LiquidityRequest.bcs.parse(data));
+        return Balances.fromFields(typeArgs, Balances.bcs.parse(data));
     }
     toJSONField() {
         return {
-            amount: this.amount.toString(),
-            fee: this.fee.toString(),
+            availableAmount: this.availableAmount.toJSONField(),
+            ctokenSupply: this.ctokenSupply.toJSONField(),
+            fees: this.fees.toJSONField(),
+            ctokenFees: this.ctokenFees.toJSONField(),
+            depositedCtokens: this.depositedCtokens.toJSONField(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(typeArgs, field) {
-        return LiquidityRequest.reified(typeArgs[0], typeArgs[1]).new({
-            amount: decodeFromJSONField("u64", field.amount),
-            fee: decodeFromJSONField("u64", field.fee),
+        return Balances.reified(typeArgs[0], typeArgs[1]).new({
+            availableAmount: decodeFromJSONField(Balance.reified(typeArgs[1]), field.availableAmount),
+            ctokenSupply: decodeFromJSONField(Supply.reified(phantom(CToken.reified(typeArgs[0], typeArgs[1]))), field.ctokenSupply),
+            fees: decodeFromJSONField(Balance.reified(typeArgs[1]), field.fees),
+            ctokenFees: decodeFromJSONField(Balance.reified(phantom(CToken.reified(typeArgs[0], typeArgs[1]))), field.ctokenFees),
+            depositedCtokens: decodeFromJSONField(Balance.reified(phantom(CToken.reified(typeArgs[0], typeArgs[1]))), field.depositedCtokens),
         });
     }
     static fromJSON(typeArgs, json) {
-        if (json.$typeName !== LiquidityRequest.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== Balances.$typeName) {
+            throw new Error(`not a Balances json object: expected '${Balances.$typeName}' but got '${json.$typeName}'`);
         }
-        assertReifiedTypeArgsMatch(composeSuiType(LiquidityRequest.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs);
-        return LiquidityRequest.fromJSONField(typeArgs, json);
+        assertReifiedTypeArgsMatch(composeSuiType(Balances.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs);
+        return Balances.fromJSONField(typeArgs, json);
+    }
+    static fromCoreObject(typeArgs, obj) {
+        if (!isBalances(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a Balances object`);
+        }
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 2) {
+            throw new Error(`type argument mismatch: expected 2 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 2; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType(typeArgs[i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return Balances.fromBcs(typeArgs, obj.content);
     }
     static async fetch(client, typeArgs, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isLiquidityRequest(object.type)) {
-            throw new Error(`object at id ${id} is not a LiquidityRequest object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isBalances(object.type)) {
+            throw new Error(`object at id ${id} is not a Balances object`);
         }
-        return LiquidityRequest.fromBcs(typeArgs, object.content);
+        const gotTypeArgs = parseTypeName(object.type).typeArgs;
+        if (gotTypeArgs.length !== 2) {
+            throw new Error(`type argument mismatch: expected 2 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 2; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType(typeArgs[i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return Balances.fromBcs(typeArgs, object.content);
     }
 }
-/* ============================== Reserve =============================== */
-export function isReserve(type) {
+/* ============================== InterestUpdateEvent =============================== */
+export function isInterestUpdateEvent(type) {
     type = compressSuiType(type);
-    return type.startsWith(`${PKG_V1}::reserve::Reserve` + "<");
+    return type
+        === `${getTypeOrigin('suilend', 'reserve::InterestUpdateEvent')}::reserve::InterestUpdateEvent`;
 }
-export class Reserve {
+export class InterestUpdateEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::reserve::Reserve`;
-    static $numTypeParams = 1;
-    static $isPhantom = [true];
-    $typeName = Reserve.$typeName;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::InterestUpdateEvent')}::reserve::InterestUpdateEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = InterestUpdateEvent.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = Reserve.$isPhantom;
-    id;
+    $isPhantom = InterestUpdateEvent.$isPhantom;
     lendingMarketId;
-    arrayIndex;
     coinType;
-    config;
-    mintDecimals;
-    priceIdentifier;
-    price;
-    smoothedPrice;
-    priceLastUpdateTimestampS;
+    reserveId;
+    cumulativeBorrowRate;
     availableAmount;
-    ctokenSupply;
     borrowedAmount;
-    cumulativeBorrowRate;
-    interestLastUpdateTimestampS;
     unclaimedSpreadFees;
-    attributedBorrowValue;
-    depositsPoolRewardManager;
-    borrowsPoolRewardManager;
+    ctokenSupply;
+    borrowInterestPaid;
+    spreadFee;
+    supplyInterestEarned;
+    borrowInterestPaidUsdEstimate;
+    protocolFeeUsdEstimate;
+    supplyInterestEarnedUsdEstimate;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(Reserve.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(InterestUpdateEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.id = fields.id;
         this.lendingMarketId = fields.lendingMarketId;
-        this.arrayIndex = fields.arrayIndex;
         this.coinType = fields.coinType;
-        this.config = fields.config;
-        this.mintDecimals = fields.mintDecimals;
-        this.priceIdentifier = fields.priceIdentifier;
-        this.price = fields.price;
-        this.smoothedPrice = fields.smoothedPrice;
-        this.priceLastUpdateTimestampS = fields.priceLastUpdateTimestampS;
+        this.reserveId = fields.reserveId;
+        this.cumulativeBorrowRate = fields.cumulativeBorrowRate;
         this.availableAmount = fields.availableAmount;
-        this.ctokenSupply = fields.ctokenSupply;
         this.borrowedAmount = fields.borrowedAmount;
-        this.cumulativeBorrowRate = fields.cumulativeBorrowRate;
-        this.interestLastUpdateTimestampS = fields.interestLastUpdateTimestampS;
         this.unclaimedSpreadFees = fields.unclaimedSpreadFees;
-        this.attributedBorrowValue = fields.attributedBorrowValue;
-        this.depositsPoolRewardManager = fields.depositsPoolRewardManager;
-        this.borrowsPoolRewardManager = fields.borrowsPoolRewardManager;
+        this.ctokenSupply = fields.ctokenSupply;
+        this.borrowInterestPaid = fields.borrowInterestPaid;
+        this.spreadFee = fields.spreadFee;
+        this.supplyInterestEarned = fields.supplyInterestEarned;
+        this.borrowInterestPaidUsdEstimate = fields.borrowInterestPaidUsdEstimate;
+        this.protocolFeeUsdEstimate = fields.protocolFeeUsdEstimate;
+        this.supplyInterestEarnedUsdEstimate = fields.supplyInterestEarnedUsdEstimate;
     }
-    static reified(P) {
+    static reified() {
+        const reifiedBcs = InterestUpdateEvent.bcs;
         return {
-            typeName: Reserve.$typeName,
-            fullTypeName: composeSuiType(Reserve.$typeName, ...[extractType(P)]),
-            typeArgs: [extractType(P)],
-            isPhantom: Reserve.$isPhantom,
-            reifiedTypeArgs: [P],
-            fromFields: (fields) => Reserve.fromFields(P, fields),
-            fromFieldsWithTypes: (item) => Reserve.fromFieldsWithTypes(P, item),
-            fromBcs: (data) => Reserve.fromBcs(P, data),
-            bcs: Reserve.bcs,
-            fromJSONField: (field) => Reserve.fromJSONField(P, field),
-            fromJSON: (json) => Reserve.fromJSON(P, json),
-            fetch: async (client, id) => Reserve.fetch(client, P, id),
+            get typeName() {
+                return InterestUpdateEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(InterestUpdateEvent.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: InterestUpdateEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => InterestUpdateEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => InterestUpdateEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => InterestUpdateEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => InterestUpdateEvent.fromJSONField(field),
+            fromJSON: (json) => InterestUpdateEvent.fromJSON(json),
+            fromCoreObject: (obj) => InterestUpdateEvent.fromCoreObject(obj),
+            fetch: async (client, id) => InterestUpdateEvent.fetch(client, id),
             new: (fields) => {
-                return new Reserve([extractType(P)], fields);
+                return new InterestUpdateEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return Reserve.reified;
+        return InterestUpdateEvent.reified();
     }
-    static phantom(P) {
-        return phantom(Reserve.reified(P));
+    static phantom() {
+        return phantom(InterestUpdateEvent.reified());
     }
     static get p() {
-        return Reserve.phantom;
+        return InterestUpdateEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("Reserve", {
-            id: UID.bcs,
-            lending_market_id: ID.bcs,
-            array_index: bcs.u64(),
+    static instantiateBcs() {
+        return bcs.struct('InterestUpdateEvent', {
+            lending_market_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
             coin_type: TypeName.bcs,
-            config: Cell.bcs(ReserveConfig.bcs),
-            mint_decimals: bcs.u8(),
-            price_identifier: PriceIdentifier.bcs,
-            price: Decimal.bcs,
-            smoothed_price: Decimal.bcs,
-            price_last_update_timestamp_s: bcs.u64(),
+            reserve_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            cumulative_borrow_rate: Decimal.bcs,
             available_amount: bcs.u64(),
-            ctoken_supply: bcs.u64(),
             borrowed_amount: Decimal.bcs,
-            cumulative_borrow_rate: Decimal.bcs,
-            interest_last_update_timestamp_s: bcs.u64(),
             unclaimed_spread_fees: Decimal.bcs,
-            attributed_borrow_value: Decimal.bcs,
-            deposits_pool_reward_manager: PoolRewardManager.bcs,
-            borrows_pool_reward_manager: PoolRewardManager.bcs,
+            ctoken_supply: bcs.u64(),
+            borrow_interest_paid: Decimal.bcs,
+            spread_fee: Decimal.bcs,
+            supply_interest_earned: Decimal.bcs,
+            borrow_interest_paid_usd_estimate: Decimal.bcs,
+            protocol_fee_usd_estimate: Decimal.bcs,
+            supply_interest_earned_usd_estimate: Decimal.bcs,
         });
     }
-    static fromFields(typeArg, fields) {
-        return Reserve.reified(typeArg).new({
-            id: decodeFromFields(UID.reified(), fields.id),
-            lendingMarketId: decodeFromFields(ID.reified(), fields.lending_market_id),
-            arrayIndex: decodeFromFields("u64", fields.array_index),
+    static cachedBcs = null;
+    static get bcs() {
+        if (!InterestUpdateEvent.cachedBcs) {
+            InterestUpdateEvent.cachedBcs = InterestUpdateEvent.instantiateBcs();
+        }
+        return InterestUpdateEvent.cachedBcs;
+    }
+    static fromFields(fields) {
+        return InterestUpdateEvent.reified().new({
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
             coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            config: decodeFromFields(Cell.reified(ReserveConfig.reified()), fields.config),
-            mintDecimals: decodeFromFields("u8", fields.mint_decimals),
-            priceIdentifier: decodeFromFields(PriceIdentifier.reified(), fields.price_identifier),
-            price: decodeFromFields(Decimal.reified(), fields.price),
-            smoothedPrice: decodeFromFields(Decimal.reified(), fields.smoothed_price),
-            priceLastUpdateTimestampS: decodeFromFields("u64", fields.price_last_update_timestamp_s),
-            availableAmount: decodeFromFields("u64", fields.available_amount),
-            ctokenSupply: decodeFromFields("u64", fields.ctoken_supply),
-            borrowedAmount: decodeFromFields(Decimal.reified(), fields.borrowed_amount),
+            reserveId: decodeFromFields('address', fields.reserve_id),
             cumulativeBorrowRate: decodeFromFields(Decimal.reified(), fields.cumulative_borrow_rate),
-            interestLastUpdateTimestampS: decodeFromFields("u64", fields.interest_last_update_timestamp_s),
+            availableAmount: decodeFromFields('u64', fields.available_amount),
+            borrowedAmount: decodeFromFields(Decimal.reified(), fields.borrowed_amount),
             unclaimedSpreadFees: decodeFromFields(Decimal.reified(), fields.unclaimed_spread_fees),
-            attributedBorrowValue: decodeFromFields(Decimal.reified(), fields.attributed_borrow_value),
-            depositsPoolRewardManager: decodeFromFields(PoolRewardManager.reified(), fields.deposits_pool_reward_manager),
-            borrowsPoolRewardManager: decodeFromFields(PoolRewardManager.reified(), fields.borrows_pool_reward_manager),
+            ctokenSupply: decodeFromFields('u64', fields.ctoken_supply),
+            borrowInterestPaid: decodeFromFields(Decimal.reified(), fields.borrow_interest_paid),
+            spreadFee: decodeFromFields(Decimal.reified(), fields.spread_fee),
+            supplyInterestEarned: decodeFromFields(Decimal.reified(), fields.supply_interest_earned),
+            borrowInterestPaidUsdEstimate: decodeFromFields(Decimal.reified(), fields.borrow_interest_paid_usd_estimate),
+            protocolFeeUsdEstimate: decodeFromFields(Decimal.reified(), fields.protocol_fee_usd_estimate),
+            supplyInterestEarnedUsdEstimate: decodeFromFields(Decimal.reified(), fields.supply_interest_earned_usd_estimate),
         });
     }
-    static fromFieldsWithTypes(typeArg, item) {
-        if (!isReserve(item.type)) {
-            throw new Error("not a Reserve type");
+    static fromFieldsWithTypes(item) {
+        if (!isInterestUpdateEvent(item.type)) {
+            throw new Error('not a InterestUpdateEvent type');
         }
-        assertFieldsWithTypesArgsMatch(item, [typeArg]);
-        return Reserve.reified(typeArg).new({
-            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
-            lendingMarketId: decodeFromFieldsWithTypes(ID.reified(), item.fields.lending_market_id),
-            arrayIndex: decodeFromFieldsWithTypes("u64", item.fields.array_index),
+        return InterestUpdateEvent.reified().new({
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
             coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            config: decodeFromFieldsWithTypes(Cell.reified(ReserveConfig.reified()), item.fields.config),
-            mintDecimals: decodeFromFieldsWithTypes("u8", item.fields.mint_decimals),
-            priceIdentifier: decodeFromFieldsWithTypes(PriceIdentifier.reified(), item.fields.price_identifier),
-            price: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.price),
-            smoothedPrice: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.smoothed_price),
-            priceLastUpdateTimestampS: decodeFromFieldsWithTypes("u64", item.fields.price_last_update_timestamp_s),
-            availableAmount: decodeFromFieldsWithTypes("u64", item.fields.available_amount),
-            ctokenSupply: decodeFromFieldsWithTypes("u64", item.fields.ctoken_supply),
-            borrowedAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrowed_amount),
+            reserveId: decodeFromFieldsWithTypes('address', item.fields.reserve_id),
             cumulativeBorrowRate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.cumulative_borrow_rate),
-            interestLastUpdateTimestampS: decodeFromFieldsWithTypes("u64", item.fields.interest_last_update_timestamp_s),
+            availableAmount: decodeFromFieldsWithTypes('u64', item.fields.available_amount),
+            borrowedAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrowed_amount),
             unclaimedSpreadFees: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.unclaimed_spread_fees),
-            attributedBorrowValue: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.attributed_borrow_value),
-            depositsPoolRewardManager: decodeFromFieldsWithTypes(PoolRewardManager.reified(), item.fields.deposits_pool_reward_manager),
-            borrowsPoolRewardManager: decodeFromFieldsWithTypes(PoolRewardManager.reified(), item.fields.borrows_pool_reward_manager),
+            ctokenSupply: decodeFromFieldsWithTypes('u64', item.fields.ctoken_supply),
+            borrowInterestPaid: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrow_interest_paid),
+            spreadFee: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.spread_fee),
+            supplyInterestEarned: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.supply_interest_earned),
+            borrowInterestPaidUsdEstimate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrow_interest_paid_usd_estimate),
+            protocolFeeUsdEstimate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.protocol_fee_usd_estimate),
+            supplyInterestEarnedUsdEstimate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.supply_interest_earned_usd_estimate),
         });
     }
-    static fromBcs(typeArg, data) {
-        return Reserve.fromFields(typeArg, Reserve.bcs.parse(data));
+    static fromBcs(data) {
+        return InterestUpdateEvent.fromFields(InterestUpdateEvent.bcs.parse(data));
     }
     toJSONField() {
         return {
-            id: this.id,
             lendingMarketId: this.lendingMarketId,
-            arrayIndex: this.arrayIndex.toString(),
-            coinType: this.coinType.toJSONField(),
-            config: this.config.toJSONField(),
-            mintDecimals: this.mintDecimals,
-            priceIdentifier: this.priceIdentifier.toJSONField(),
-            price: this.price.toJSONField(),
-            smoothedPrice: this.smoothedPrice.toJSONField(),
-            priceLastUpdateTimestampS: this.priceLastUpdateTimestampS.toString(),
+            coinType: this.coinType,
+            reserveId: this.reserveId,
+            cumulativeBorrowRate: this.cumulativeBorrowRate.toJSONField(),
             availableAmount: this.availableAmount.toString(),
-            ctokenSupply: this.ctokenSupply.toString(),
             borrowedAmount: this.borrowedAmount.toJSONField(),
-            cumulativeBorrowRate: this.cumulativeBorrowRate.toJSONField(),
-            interestLastUpdateTimestampS: this.interestLastUpdateTimestampS.toString(),
             unclaimedSpreadFees: this.unclaimedSpreadFees.toJSONField(),
-            attributedBorrowValue: this.attributedBorrowValue.toJSONField(),
-            depositsPoolRewardManager: this.depositsPoolRewardManager.toJSONField(),
-            borrowsPoolRewardManager: this.borrowsPoolRewardManager.toJSONField(),
+            ctokenSupply: this.ctokenSupply.toString(),
+            borrowInterestPaid: this.borrowInterestPaid.toJSONField(),
+            spreadFee: this.spreadFee.toJSONField(),
+            supplyInterestEarned: this.supplyInterestEarned.toJSONField(),
+            borrowInterestPaidUsdEstimate: this.borrowInterestPaidUsdEstimate.toJSONField(),
+            protocolFeeUsdEstimate: this.protocolFeeUsdEstimate.toJSONField(),
+            supplyInterestEarnedUsdEstimate: this.supplyInterestEarnedUsdEstimate.toJSONField(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
-    static fromJSONField(typeArg, field) {
-        return Reserve.reified(typeArg).new({
-            id: decodeFromJSONField(UID.reified(), field.id),
-            lendingMarketId: decodeFromJSONField(ID.reified(), field.lendingMarketId),
-            arrayIndex: decodeFromJSONField("u64", field.arrayIndex),
+    static fromJSONField(field) {
+        return InterestUpdateEvent.reified().new({
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
             coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            config: decodeFromJSONField(Cell.reified(ReserveConfig.reified()), field.config),
-            mintDecimals: decodeFromJSONField("u8", field.mintDecimals),
-            priceIdentifier: decodeFromJSONField(PriceIdentifier.reified(), field.priceIdentifier),
-            price: decodeFromJSONField(Decimal.reified(), field.price),
-            smoothedPrice: decodeFromJSONField(Decimal.reified(), field.smoothedPrice),
-            priceLastUpdateTimestampS: decodeFromJSONField("u64", field.priceLastUpdateTimestampS),
-            availableAmount: decodeFromJSONField("u64", field.availableAmount),
-            ctokenSupply: decodeFromJSONField("u64", field.ctokenSupply),
-            borrowedAmount: decodeFromJSONField(Decimal.reified(), field.borrowedAmount),
+            reserveId: decodeFromJSONField('address', field.reserveId),
             cumulativeBorrowRate: decodeFromJSONField(Decimal.reified(), field.cumulativeBorrowRate),
-            interestLastUpdateTimestampS: decodeFromJSONField("u64", field.interestLastUpdateTimestampS),
+            availableAmount: decodeFromJSONField('u64', field.availableAmount),
+            borrowedAmount: decodeFromJSONField(Decimal.reified(), field.borrowedAmount),
             unclaimedSpreadFees: decodeFromJSONField(Decimal.reified(), field.unclaimedSpreadFees),
-            attributedBorrowValue: decodeFromJSONField(Decimal.reified(), field.attributedBorrowValue),
-            depositsPoolRewardManager: decodeFromJSONField(PoolRewardManager.reified(), field.depositsPoolRewardManager),
-            borrowsPoolRewardManager: decodeFromJSONField(PoolRewardManager.reified(), field.borrowsPoolRewardManager),
+            ctokenSupply: decodeFromJSONField('u64', field.ctokenSupply),
+            borrowInterestPaid: decodeFromJSONField(Decimal.reified(), field.borrowInterestPaid),
+            spreadFee: decodeFromJSONField(Decimal.reified(), field.spreadFee),
+            supplyInterestEarned: decodeFromJSONField(Decimal.reified(), field.supplyInterestEarned),
+            borrowInterestPaidUsdEstimate: decodeFromJSONField(Decimal.reified(), field.borrowInterestPaidUsdEstimate),
+            protocolFeeUsdEstimate: decodeFromJSONField(Decimal.reified(), field.protocolFeeUsdEstimate),
+            supplyInterestEarnedUsdEstimate: decodeFromJSONField(Decimal.reified(), field.supplyInterestEarnedUsdEstimate),
         });
     }
-    static fromJSON(typeArg, json) {
-        if (json.$typeName !== Reserve.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+    static fromJSON(json) {
+        if (json.$typeName !== InterestUpdateEvent.$typeName) {
+            throw new Error(`not a InterestUpdateEvent json object: expected '${InterestUpdateEvent.$typeName}' but got '${json.$typeName}'`);
         }
-        assertReifiedTypeArgsMatch(composeSuiType(Reserve.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
-        return Reserve.fromJSONField(typeArg, json);
+        return InterestUpdateEvent.fromJSONField(json);
     }
-    static async fetch(client, typeArg, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isReserve(object.type)) {
-            throw new Error(`object at id ${id} is not a Reserve object`);
+    static fromCoreObject(obj) {
+        if (!isInterestUpdateEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a InterestUpdateEvent object`);
         }
-        return Reserve.fromBcs(typeArg, object.content);
+        return InterestUpdateEvent.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isInterestUpdateEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a InterestUpdateEvent object`);
+        }
+        return InterestUpdateEvent.fromBcs(object.content);
     }
 }
 /* ============================== ReserveAssetDataEvent =============================== */
 export function isReserveAssetDataEvent(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::reserve::ReserveAssetDataEvent`;
+    return type
+        === `${getTypeOrigin('suilend', 'reserve::ReserveAssetDataEvent')}::reserve::ReserveAssetDataEvent`;
 }
 export class ReserveAssetDataEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::reserve::ReserveAssetDataEvent`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::ReserveAssetDataEvent')}::reserve::ReserveAssetDataEvent`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = ReserveAssetDataEvent.$typeName;
@@ -1072,23 +1802,29 @@ export class ReserveAssetDataEvent {
         this.priceLastUpdateTimestampS = fields.priceLastUpdateTimestampS;
     }
     static reified() {
+        const reifiedBcs = ReserveAssetDataEvent.bcs;
         return {
-            typeName: ReserveAssetDataEvent.$typeName,
-            fullTypeName: composeSuiType(ReserveAssetDataEvent.$typeName, ...[]),
+            get typeName() {
+                return ReserveAssetDataEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ReserveAssetDataEvent.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: ReserveAssetDataEvent.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => ReserveAssetDataEvent.fromFields(fields),
             fromFieldsWithTypes: (item) => ReserveAssetDataEvent.fromFieldsWithTypes(item),
-            fromBcs: (data) => ReserveAssetDataEvent.fromBcs(data),
-            bcs: ReserveAssetDataEvent.bcs,
+            fromBcs: (data) => ReserveAssetDataEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => ReserveAssetDataEvent.fromJSONField(field),
             fromJSON: (json) => ReserveAssetDataEvent.fromJSON(json),
+            fromCoreObject: (obj) => ReserveAssetDataEvent.fromCoreObject(obj),
             fetch: async (client, id) => ReserveAssetDataEvent.fetch(client, id),
             new: (fields) => {
                 return new ReserveAssetDataEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -1100,18 +1836,14 @@ export class ReserveAssetDataEvent {
     static get p() {
         return ReserveAssetDataEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("ReserveAssetDataEvent", {
-            lending_market_id: bcs
-                .bytes(32)
-                .transform({
+    static instantiateBcs() {
+        return bcs.struct('ReserveAssetDataEvent', {
+            lending_market_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
             coin_type: TypeName.bcs,
-            reserve_id: bcs
-                .bytes(32)
-                .transform({
+            reserve_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
@@ -1130,11 +1862,18 @@ export class ReserveAssetDataEvent {
             price_last_update_timestamp_s: bcs.u64(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!ReserveAssetDataEvent.cachedBcs) {
+            ReserveAssetDataEvent.cachedBcs = ReserveAssetDataEvent.instantiateBcs();
+        }
+        return ReserveAssetDataEvent.cachedBcs;
+    }
     static fromFields(fields) {
         return ReserveAssetDataEvent.reified().new({
-            lendingMarketId: decodeFromFields("address", fields.lending_market_id),
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
             coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveId: decodeFromFields("address", fields.reserve_id),
+            reserveId: decodeFromFields('address', fields.reserve_id),
             availableAmount: decodeFromFields(Decimal.reified(), fields.available_amount),
             supplyAmount: decodeFromFields(Decimal.reified(), fields.supply_amount),
             borrowedAmount: decodeFromFields(Decimal.reified(), fields.borrowed_amount),
@@ -1143,21 +1882,21 @@ export class ReserveAssetDataEvent {
             borrowedAmountUsdEstimate: decodeFromFields(Decimal.reified(), fields.borrowed_amount_usd_estimate),
             borrowApr: decodeFromFields(Decimal.reified(), fields.borrow_apr),
             supplyApr: decodeFromFields(Decimal.reified(), fields.supply_apr),
-            ctokenSupply: decodeFromFields("u64", fields.ctoken_supply),
+            ctokenSupply: decodeFromFields('u64', fields.ctoken_supply),
             cumulativeBorrowRate: decodeFromFields(Decimal.reified(), fields.cumulative_borrow_rate),
             price: decodeFromFields(Decimal.reified(), fields.price),
             smoothedPrice: decodeFromFields(Decimal.reified(), fields.smoothed_price),
-            priceLastUpdateTimestampS: decodeFromFields("u64", fields.price_last_update_timestamp_s),
+            priceLastUpdateTimestampS: decodeFromFields('u64', fields.price_last_update_timestamp_s),
         });
     }
     static fromFieldsWithTypes(item) {
         if (!isReserveAssetDataEvent(item.type)) {
-            throw new Error("not a ReserveAssetDataEvent type");
+            throw new Error('not a ReserveAssetDataEvent type');
         }
         return ReserveAssetDataEvent.reified().new({
-            lendingMarketId: decodeFromFieldsWithTypes("address", item.fields.lending_market_id),
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
             coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveId: decodeFromFieldsWithTypes("address", item.fields.reserve_id),
+            reserveId: decodeFromFieldsWithTypes('address', item.fields.reserve_id),
             availableAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.available_amount),
             supplyAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.supply_amount),
             borrowedAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrowed_amount),
@@ -1166,11 +1905,11 @@ export class ReserveAssetDataEvent {
             borrowedAmountUsdEstimate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrowed_amount_usd_estimate),
             borrowApr: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrow_apr),
             supplyApr: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.supply_apr),
-            ctokenSupply: decodeFromFieldsWithTypes("u64", item.fields.ctoken_supply),
+            ctokenSupply: decodeFromFieldsWithTypes('u64', item.fields.ctoken_supply),
             cumulativeBorrowRate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.cumulative_borrow_rate),
             price: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.price),
             smoothedPrice: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.smoothed_price),
-            priceLastUpdateTimestampS: decodeFromFieldsWithTypes("u64", item.fields.price_last_update_timestamp_s),
+            priceLastUpdateTimestampS: decodeFromFieldsWithTypes('u64', item.fields.price_last_update_timestamp_s),
         });
     }
     static fromBcs(data) {
@@ -1179,7 +1918,7 @@ export class ReserveAssetDataEvent {
     toJSONField() {
         return {
             lendingMarketId: this.lendingMarketId,
-            coinType: this.coinType.toJSONField(),
+            coinType: this.coinType,
             reserveId: this.reserveId,
             availableAmount: this.availableAmount.toJSONField(),
             supplyAmount: this.supplyAmount.toJSONField(),
@@ -1197,17 +1936,13 @@ export class ReserveAssetDataEvent {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return ReserveAssetDataEvent.reified().new({
-            lendingMarketId: decodeFromJSONField("address", field.lendingMarketId),
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
             coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveId: decodeFromJSONField("address", field.reserveId),
+            reserveId: decodeFromJSONField('address', field.reserveId),
             availableAmount: decodeFromJSONField(Decimal.reified(), field.availableAmount),
             supplyAmount: decodeFromJSONField(Decimal.reified(), field.supplyAmount),
             borrowedAmount: decodeFromJSONField(Decimal.reified(), field.borrowedAmount),
@@ -1216,125 +1951,182 @@ export class ReserveAssetDataEvent {
             borrowedAmountUsdEstimate: decodeFromJSONField(Decimal.reified(), field.borrowedAmountUsdEstimate),
             borrowApr: decodeFromJSONField(Decimal.reified(), field.borrowApr),
             supplyApr: decodeFromJSONField(Decimal.reified(), field.supplyApr),
-            ctokenSupply: decodeFromJSONField("u64", field.ctokenSupply),
+            ctokenSupply: decodeFromJSONField('u64', field.ctokenSupply),
             cumulativeBorrowRate: decodeFromJSONField(Decimal.reified(), field.cumulativeBorrowRate),
             price: decodeFromJSONField(Decimal.reified(), field.price),
             smoothedPrice: decodeFromJSONField(Decimal.reified(), field.smoothedPrice),
-            priceLastUpdateTimestampS: decodeFromJSONField("u64", field.priceLastUpdateTimestampS),
+            priceLastUpdateTimestampS: decodeFromJSONField('u64', field.priceLastUpdateTimestampS),
         });
     }
     static fromJSON(json) {
         if (json.$typeName !== ReserveAssetDataEvent.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a ReserveAssetDataEvent json object: expected '${ReserveAssetDataEvent.$typeName}' but got '${json.$typeName}'`);
         }
         return ReserveAssetDataEvent.fromJSONField(json);
     }
+    static fromCoreObject(obj) {
+        if (!isReserveAssetDataEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ReserveAssetDataEvent object`);
+        }
+        return ReserveAssetDataEvent.fromBcs(obj.content);
+    }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
         if (!isReserveAssetDataEvent(object.type)) {
             throw new Error(`object at id ${id} is not a ReserveAssetDataEvent object`);
         }
         return ReserveAssetDataEvent.fromBcs(object.content);
     }
 }
-/* ============================== StakerKey =============================== */
-export function isStakerKey(type) {
+/* ============================== ClaimStakingRewardsEvent =============================== */
+export function isClaimStakingRewardsEvent(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V8}::reserve::StakerKey`;
+    return type
+        === `${getTypeOrigin('suilend', 'reserve::ClaimStakingRewardsEvent')}::reserve::ClaimStakingRewardsEvent`;
 }
-export class StakerKey {
+export class ClaimStakingRewardsEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V8}::reserve::StakerKey`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::ClaimStakingRewardsEvent')}::reserve::ClaimStakingRewardsEvent`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = StakerKey.$typeName;
+    $typeName = ClaimStakingRewardsEvent.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = StakerKey.$isPhantom;
-    dummyField;
+    $isPhantom = ClaimStakingRewardsEvent.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    amount;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(StakerKey.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(ClaimStakingRewardsEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.dummyField = fields.dummyField;
+        this.lendingMarketId = fields.lendingMarketId;
+        this.coinType = fields.coinType;
+        this.reserveId = fields.reserveId;
+        this.amount = fields.amount;
     }
     static reified() {
+        const reifiedBcs = ClaimStakingRewardsEvent.bcs;
         return {
-            typeName: StakerKey.$typeName,
-            fullTypeName: composeSuiType(StakerKey.$typeName, ...[]),
+            get typeName() {
+                return ClaimStakingRewardsEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ClaimStakingRewardsEvent.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: StakerKey.$isPhantom,
+            isPhantom: ClaimStakingRewardsEvent.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => StakerKey.fromFields(fields),
-            fromFieldsWithTypes: (item) => StakerKey.fromFieldsWithTypes(item),
-            fromBcs: (data) => StakerKey.fromBcs(data),
-            bcs: StakerKey.bcs,
-            fromJSONField: (field) => StakerKey.fromJSONField(field),
-            fromJSON: (json) => StakerKey.fromJSON(json),
-            fetch: async (client, id) => StakerKey.fetch(client, id),
+            fromFields: (fields) => ClaimStakingRewardsEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => ClaimStakingRewardsEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => ClaimStakingRewardsEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => ClaimStakingRewardsEvent.fromJSONField(field),
+            fromJSON: (json) => ClaimStakingRewardsEvent.fromJSON(json),
+            fromCoreObject: (obj) => ClaimStakingRewardsEvent.fromCoreObject(obj),
+            fetch: async (client, id) => ClaimStakingRewardsEvent.fetch(client, id),
             new: (fields) => {
-                return new StakerKey([], fields);
+                return new ClaimStakingRewardsEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return StakerKey.reified();
+        return ClaimStakingRewardsEvent.reified();
     }
     static phantom() {
-        return phantom(StakerKey.reified());
+        return phantom(ClaimStakingRewardsEvent.reified());
     }
     static get p() {
-        return StakerKey.phantom();
+        return ClaimStakingRewardsEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("StakerKey", {
-            dummy_field: bcs.bool(),
+    static instantiateBcs() {
+        return bcs.struct('ClaimStakingRewardsEvent', {
+            lending_market_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            coin_type: TypeName.bcs,
+            reserve_id: bcs.bytes(32).transform({
+                input: (val) => fromHex(val),
+                output: (val) => toHex(val),
+            }),
+            amount: bcs.u64(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!ClaimStakingRewardsEvent.cachedBcs) {
+            ClaimStakingRewardsEvent.cachedBcs = ClaimStakingRewardsEvent.instantiateBcs();
+        }
+        return ClaimStakingRewardsEvent.cachedBcs;
+    }
     static fromFields(fields) {
-        return StakerKey.reified().new({
-            dummyField: decodeFromFields("bool", fields.dummy_field),
+        return ClaimStakingRewardsEvent.reified().new({
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
+            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
+            reserveId: decodeFromFields('address', fields.reserve_id),
+            amount: decodeFromFields('u64', fields.amount),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isStakerKey(item.type)) {
-            throw new Error("not a StakerKey type");
+        if (!isClaimStakingRewardsEvent(item.type)) {
+            throw new Error('not a ClaimStakingRewardsEvent type');
         }
-        return StakerKey.reified().new({
-            dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field),
+        return ClaimStakingRewardsEvent.reified().new({
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
+            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
+            reserveId: decodeFromFieldsWithTypes('address', item.fields.reserve_id),
+            amount: decodeFromFieldsWithTypes('u64', item.fields.amount),
         });
     }
     static fromBcs(data) {
-        return StakerKey.fromFields(StakerKey.bcs.parse(data));
+        return ClaimStakingRewardsEvent.fromFields(ClaimStakingRewardsEvent.bcs.parse(data));
     }
     toJSONField() {
         return {
-            dummyField: this.dummyField,
+            lendingMarketId: this.lendingMarketId,
+            coinType: this.coinType,
+            reserveId: this.reserveId,
+            amount: this.amount.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return StakerKey.reified().new({
-            dummyField: decodeFromJSONField("bool", field.dummyField),
+        return ClaimStakingRewardsEvent.reified().new({
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
+            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
+            reserveId: decodeFromJSONField('address', field.reserveId),
+            amount: decodeFromJSONField('u64', field.amount),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== StakerKey.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== ClaimStakingRewardsEvent.$typeName) {
+            throw new Error(`not a ClaimStakingRewardsEvent json object: expected '${ClaimStakingRewardsEvent.$typeName}' but got '${json.$typeName}'`);
         }
-        return StakerKey.fromJSONField(json);
+        return ClaimStakingRewardsEvent.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isClaimStakingRewardsEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ClaimStakingRewardsEvent object`);
+        }
+        return ClaimStakingRewardsEvent.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isStakerKey(object.type)) {
-            throw new Error(`object at id ${id} is not a StakerKey object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isClaimStakingRewardsEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a ClaimStakingRewardsEvent object`);
         }
-        return StakerKey.fromBcs(object.content);
+        return ClaimStakingRewardsEvent.fromBcs(object.content);
     }
 }