@suilend/sdk 12.7.0 → 13.0.0-next.g803bba0

package/_generated/suilend/obligation/structs.js

@@ -1,293 +1,294 @@
-import * as reified from "../../_framework/reified.js";
-import { TypeName } from "../../_dependencies/source/0x1/type-name/structs.js";
-import { ID, UID } from "../../_dependencies/source/0x2/object/structs.js";
-import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom, } from "../../_framework/reified.js";
-import { composeSuiType, compressSuiType, } from "../../_framework/util.js";
-import { Decimal } from "../decimal/structs.js";
-import { PKG_V1, PKG_V11 } from "../index.js";
-import { UserRewardManager } from "../liquidity-mining/structs.js";
-import { bcs } from "@mysten/sui/bcs";
-import { fromHex, toHex } from "@mysten/sui/utils";
-/* ============================== Borrow =============================== */
-export function isBorrow(type) {
+import { bcs } from '@mysten/sui/bcs';
+import { fromHex, toHex } from '@mysten/sui/utils';
+import { TypeName } from '../../_dependencies/std/type-name/structs.js';
+import { ID, UID } from '../../_dependencies/sui/object/structs.js';
+import { getTypeOrigin } from '../../_envs/index.js';
+import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom, vector, } from '../../_framework/reified.js';
+import { composeSuiType, compressSuiType, parseTypeName, } from '../../_framework/util.js';
+import { Decimal } from '../decimal/structs.js';
+import { UserRewardManager } from '../liquidity-mining/structs.js';
+/* ============================== Obligation =============================== */
+export function isObligation(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::obligation::Borrow`;
+    return type.startsWith(`${getTypeOrigin('suilend', 'obligation::Obligation')}::obligation::Obligation` + '<');
 }
-export class Borrow {
+export class Obligation {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::obligation::Borrow`;
-    static $numTypeParams = 0;
-    static $isPhantom = [];
-    $typeName = Borrow.$typeName;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'obligation::Obligation')}::obligation::Obligation`;
+    }
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = Obligation.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = Borrow.$isPhantom;
-    coinType;
-    reserveArrayIndex;
-    borrowedAmount;
-    cumulativeBorrowRate;
-    marketValue;
-    userRewardManagerIndex;
+    $isPhantom = Obligation.$isPhantom;
+    id;
+    lendingMarketId;
+    /**
+     * all deposits in the obligation. there is at most one deposit per coin type
+     * There should never be a deposit object with a zeroed amount
+     */
+    deposits;
+    /**
+     * all borrows in the obligation. there is at most one deposit per coin type
+     * There should never be a borrow object with a zeroed amount
+     */
+    borrows;
+    /** value of all deposits in USD */
+    depositedValueUsd;
+    /**
+     * sum(deposit value * open ltv) for all deposits.
+     * if weighted_borrowed_value_usd > allowed_borrow_value_usd,
+     * the obligation is not healthy
+     */
+    allowedBorrowValueUsd;
+    /**
+     * sum(deposit value * close ltv) for all deposits
+     * if weighted_borrowed_value_usd > unhealthy_borrow_value_usd,
+     * the obligation is unhealthy and can be liquidated
+     */
+    unhealthyBorrowValueUsd;
+    superUnhealthyBorrowValueUsd;
+    /** value of all borrows in USD */
+    unweightedBorrowedValueUsd;
+    /** weighted value of all borrows in USD. used when checking if an obligation is liquidatable */
+    weightedBorrowedValueUsd;
+    /**
+     * weighted value of all borrows in USD, but using the upper bound of the market value
+     * used to limit borrows and withdraws
+     */
+    weightedBorrowedValueUpperBoundUsd;
+    borrowingIsolatedAsset;
+    userRewardManagers;
+    /** unused */
+    badDebtUsd;
+    /** unused */
+    closable;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(Borrow.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(Obligation.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.coinType = fields.coinType;
-        this.reserveArrayIndex = fields.reserveArrayIndex;
-        this.borrowedAmount = fields.borrowedAmount;
-        this.cumulativeBorrowRate = fields.cumulativeBorrowRate;
-        this.marketValue = fields.marketValue;
-        this.userRewardManagerIndex = fields.userRewardManagerIndex;
+        this.id = fields.id;
+        this.lendingMarketId = fields.lendingMarketId;
+        this.deposits = fields.deposits;
+        this.borrows = fields.borrows;
+        this.depositedValueUsd = fields.depositedValueUsd;
+        this.allowedBorrowValueUsd = fields.allowedBorrowValueUsd;
+        this.unhealthyBorrowValueUsd = fields.unhealthyBorrowValueUsd;
+        this.superUnhealthyBorrowValueUsd = fields.superUnhealthyBorrowValueUsd;
+        this.unweightedBorrowedValueUsd = fields.unweightedBorrowedValueUsd;
+        this.weightedBorrowedValueUsd = fields.weightedBorrowedValueUsd;
+        this.weightedBorrowedValueUpperBoundUsd = fields.weightedBorrowedValueUpperBoundUsd;
+        this.borrowingIsolatedAsset = fields.borrowingIsolatedAsset;
+        this.userRewardManagers = fields.userRewardManagers;
+        this.badDebtUsd = fields.badDebtUsd;
+        this.closable = fields.closable;
     }
-    static reified() {
+    static reified(P) {
+        const reifiedBcs = Obligation.bcs;
         return {
-            typeName: Borrow.$typeName,
-            fullTypeName: composeSuiType(Borrow.$typeName, ...[]),
-            typeArgs: [],
-            isPhantom: Borrow.$isPhantom,
-            reifiedTypeArgs: [],
-            fromFields: (fields) => Borrow.fromFields(fields),
-            fromFieldsWithTypes: (item) => Borrow.fromFieldsWithTypes(item),
-            fromBcs: (data) => Borrow.fromBcs(data),
-            bcs: Borrow.bcs,
-            fromJSONField: (field) => Borrow.fromJSONField(field),
-            fromJSON: (json) => Borrow.fromJSON(json),
-            fetch: async (client, id) => Borrow.fetch(client, id),
+            get typeName() {
+                return Obligation.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(Obligation.$typeName, ...[extractType(P)]);
+            },
+            get typeArgs() {
+                return [extractType(P)];
+            },
+            isPhantom: Obligation.$isPhantom,
+            reifiedTypeArgs: [P],
+            fromFields: (fields) => Obligation.fromFields(P, fields),
+            fromFieldsWithTypes: (item) => Obligation.fromFieldsWithTypes(P, item),
+            fromBcs: (data) => Obligation.fromFields(P, reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => Obligation.fromJSONField(P, field),
+            fromJSON: (json) => Obligation.fromJSON(P, json),
+            fromCoreObject: (obj) => Obligation.fromCoreObject(P, obj),
+            fetch: async (client, id) => Obligation.fetch(client, P, id),
             new: (fields) => {
-                return new Borrow([], fields);
+                return new Obligation([extractType(P)], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return Borrow.reified();
+        return Obligation.reified;
     }
-    static phantom() {
-        return phantom(Borrow.reified());
+    static phantom(P) {
+        return phantom(Obligation.reified(P));
     }
     static get p() {
-        return Borrow.phantom();
+        return Obligation.phantom;
     }
-    static get bcs() {
-        return bcs.struct("Borrow", {
-            coin_type: TypeName.bcs,
-            reserve_array_index: bcs.u64(),
-            borrowed_amount: Decimal.bcs,
-            cumulative_borrow_rate: Decimal.bcs,
-            market_value: Decimal.bcs,
-            user_reward_manager_index: bcs.u64(),
+    static instantiateBcs() {
+        return bcs.struct('Obligation', {
+            id: UID.bcs,
+            lending_market_id: ID.bcs,
+            deposits: bcs.vector(Deposit.bcs),
+            borrows: bcs.vector(Borrow.bcs),
+            deposited_value_usd: Decimal.bcs,
+            allowed_borrow_value_usd: Decimal.bcs,
+            unhealthy_borrow_value_usd: Decimal.bcs,
+            super_unhealthy_borrow_value_usd: Decimal.bcs,
+            unweighted_borrowed_value_usd: Decimal.bcs,
+            weighted_borrowed_value_usd: Decimal.bcs,
+            weighted_borrowed_value_upper_bound_usd: Decimal.bcs,
+            borrowing_isolated_asset: bcs.bool(),
+            user_reward_managers: bcs.vector(UserRewardManager.bcs),
+            bad_debt_usd: Decimal.bcs,
+            closable: bcs.bool(),
         });
     }
-    static fromFields(fields) {
-        return Borrow.reified().new({
-            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveArrayIndex: decodeFromFields("u64", fields.reserve_array_index),
-            borrowedAmount: decodeFromFields(Decimal.reified(), fields.borrowed_amount),
-            cumulativeBorrowRate: decodeFromFields(Decimal.reified(), fields.cumulative_borrow_rate),
-            marketValue: decodeFromFields(Decimal.reified(), fields.market_value),
-            userRewardManagerIndex: decodeFromFields("u64", fields.user_reward_manager_index),
+    static cachedBcs = null;
+    static get bcs() {
+        if (!Obligation.cachedBcs) {
+            Obligation.cachedBcs = Obligation.instantiateBcs();
+        }
+        return Obligation.cachedBcs;
+    }
+    static fromFields(typeArg, fields) {
+        return Obligation.reified(typeArg).new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            lendingMarketId: decodeFromFields(ID.reified(), fields.lending_market_id),
+            deposits: decodeFromFields(vector(Deposit.reified()), fields.deposits),
+            borrows: decodeFromFields(vector(Borrow.reified()), fields.borrows),
+            depositedValueUsd: decodeFromFields(Decimal.reified(), fields.deposited_value_usd),
+            allowedBorrowValueUsd: decodeFromFields(Decimal.reified(), fields.allowed_borrow_value_usd),
+            unhealthyBorrowValueUsd: decodeFromFields(Decimal.reified(), fields.unhealthy_borrow_value_usd),
+            superUnhealthyBorrowValueUsd: decodeFromFields(Decimal.reified(), fields.super_unhealthy_borrow_value_usd),
+            unweightedBorrowedValueUsd: decodeFromFields(Decimal.reified(), fields.unweighted_borrowed_value_usd),
+            weightedBorrowedValueUsd: decodeFromFields(Decimal.reified(), fields.weighted_borrowed_value_usd),
+            weightedBorrowedValueUpperBoundUsd: decodeFromFields(Decimal.reified(), fields.weighted_borrowed_value_upper_bound_usd),
+            borrowingIsolatedAsset: decodeFromFields('bool', fields.borrowing_isolated_asset),
+            userRewardManagers: decodeFromFields(vector(UserRewardManager.reified()), fields.user_reward_managers),
+            badDebtUsd: decodeFromFields(Decimal.reified(), fields.bad_debt_usd),
+            closable: decodeFromFields('bool', fields.closable),
         });
     }
-    static fromFieldsWithTypes(item) {
-        if (!isBorrow(item.type)) {
-            throw new Error("not a Borrow type");
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isObligation(item.type)) {
+            throw new Error('not a Obligation type');
         }
-        return Borrow.reified().new({
-            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveArrayIndex: decodeFromFieldsWithTypes("u64", item.fields.reserve_array_index),
-            borrowedAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrowed_amount),
-            cumulativeBorrowRate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.cumulative_borrow_rate),
-            marketValue: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.market_value),
-            userRewardManagerIndex: decodeFromFieldsWithTypes("u64", item.fields.user_reward_manager_index),
+        assertFieldsWithTypesArgsMatch(item, [typeArg]);
+        return Obligation.reified(typeArg).new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            lendingMarketId: decodeFromFieldsWithTypes(ID.reified(), item.fields.lending_market_id),
+            deposits: decodeFromFieldsWithTypes(vector(Deposit.reified()), item.fields.deposits),
+            borrows: decodeFromFieldsWithTypes(vector(Borrow.reified()), item.fields.borrows),
+            depositedValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.deposited_value_usd),
+            allowedBorrowValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.allowed_borrow_value_usd),
+            unhealthyBorrowValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.unhealthy_borrow_value_usd),
+            superUnhealthyBorrowValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.super_unhealthy_borrow_value_usd),
+            unweightedBorrowedValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.unweighted_borrowed_value_usd),
+            weightedBorrowedValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.weighted_borrowed_value_usd),
+            weightedBorrowedValueUpperBoundUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.weighted_borrowed_value_upper_bound_usd),
+            borrowingIsolatedAsset: decodeFromFieldsWithTypes('bool', item.fields.borrowing_isolated_asset),
+            userRewardManagers: decodeFromFieldsWithTypes(vector(UserRewardManager.reified()), item.fields.user_reward_managers),
+            badDebtUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.bad_debt_usd),
+            closable: decodeFromFieldsWithTypes('bool', item.fields.closable),
         });
     }
-    static fromBcs(data) {
-        return Borrow.fromFields(Borrow.bcs.parse(data));
+    static fromBcs(typeArg, data) {
+        return Obligation.fromFields(typeArg, Obligation.bcs.parse(data));
     }
     toJSONField() {
         return {
-            coinType: this.coinType.toJSONField(),
-            reserveArrayIndex: this.reserveArrayIndex.toString(),
-            borrowedAmount: this.borrowedAmount.toJSONField(),
-            cumulativeBorrowRate: this.cumulativeBorrowRate.toJSONField(),
-            marketValue: this.marketValue.toJSONField(),
-            userRewardManagerIndex: this.userRewardManagerIndex.toString(),
+            id: this.id,
+            lendingMarketId: this.lendingMarketId,
+            deposits: fieldToJSON(`vector<${Deposit.$typeName}>`, this.deposits),
+            borrows: fieldToJSON(`vector<${Borrow.$typeName}>`, this.borrows),
+            depositedValueUsd: this.depositedValueUsd.toJSONField(),
+            allowedBorrowValueUsd: this.allowedBorrowValueUsd.toJSONField(),
+            unhealthyBorrowValueUsd: this.unhealthyBorrowValueUsd.toJSONField(),
+            superUnhealthyBorrowValueUsd: this.superUnhealthyBorrowValueUsd.toJSONField(),
+            unweightedBorrowedValueUsd: this.unweightedBorrowedValueUsd.toJSONField(),
+            weightedBorrowedValueUsd: this.weightedBorrowedValueUsd.toJSONField(),
+            weightedBorrowedValueUpperBoundUsd: this.weightedBorrowedValueUpperBoundUsd.toJSONField(),
+            borrowingIsolatedAsset: this.borrowingIsolatedAsset,
+            userRewardManagers: fieldToJSON(`vector<${UserRewardManager.$typeName}>`, this.userRewardManagers),
+            badDebtUsd: this.badDebtUsd.toJSONField(),
+            closable: this.closable,
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
-    static fromJSONField(field) {
-        return Borrow.reified().new({
-            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveArrayIndex: decodeFromJSONField("u64", field.reserveArrayIndex),
-            borrowedAmount: decodeFromJSONField(Decimal.reified(), field.borrowedAmount),
-            cumulativeBorrowRate: decodeFromJSONField(Decimal.reified(), field.cumulativeBorrowRate),
-            marketValue: decodeFromJSONField(Decimal.reified(), field.marketValue),
-            userRewardManagerIndex: decodeFromJSONField("u64", field.userRewardManagerIndex),
+    static fromJSONField(typeArg, field) {
+        return Obligation.reified(typeArg).new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            lendingMarketId: decodeFromJSONField(ID.reified(), field.lendingMarketId),
+            deposits: decodeFromJSONField(vector(Deposit.reified()), field.deposits),
+            borrows: decodeFromJSONField(vector(Borrow.reified()), field.borrows),
+            depositedValueUsd: decodeFromJSONField(Decimal.reified(), field.depositedValueUsd),
+            allowedBorrowValueUsd: decodeFromJSONField(Decimal.reified(), field.allowedBorrowValueUsd),
+            unhealthyBorrowValueUsd: decodeFromJSONField(Decimal.reified(), field.unhealthyBorrowValueUsd),
+            superUnhealthyBorrowValueUsd: decodeFromJSONField(Decimal.reified(), field.superUnhealthyBorrowValueUsd),
+            unweightedBorrowedValueUsd: decodeFromJSONField(Decimal.reified(), field.unweightedBorrowedValueUsd),
+            weightedBorrowedValueUsd: decodeFromJSONField(Decimal.reified(), field.weightedBorrowedValueUsd),
+            weightedBorrowedValueUpperBoundUsd: decodeFromJSONField(Decimal.reified(), field.weightedBorrowedValueUpperBoundUsd),
+            borrowingIsolatedAsset: decodeFromJSONField('bool', field.borrowingIsolatedAsset),
+            userRewardManagers: decodeFromJSONField(vector(UserRewardManager.reified()), field.userRewardManagers),
+            badDebtUsd: decodeFromJSONField(Decimal.reified(), field.badDebtUsd),
+            closable: decodeFromJSONField('bool', field.closable),
         });
     }
-    static fromJSON(json) {
-        if (json.$typeName !== Borrow.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== Obligation.$typeName) {
+            throw new Error(`not a Obligation json object: expected '${Obligation.$typeName}' but got '${json.$typeName}'`);
         }
-        return Borrow.fromJSONField(json);
+        assertReifiedTypeArgsMatch(composeSuiType(Obligation.$typeName, ...[extractType(typeArg)]), json.$typeArgs, [typeArg]);
+        return Obligation.fromJSONField(typeArg, json);
     }
-    static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isBorrow(object.type)) {
-            throw new Error(`object at id ${id} is not a Borrow object`);
+    static fromCoreObject(typeArg, obj) {
+        if (!isObligation(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a Obligation object`);
         }
-        return Borrow.fromBcs(object.content);
-    }
-}
-/* ============================== BorrowRecord =============================== */
-export function isBorrowRecord(type) {
-    type = compressSuiType(type);
-    return type === `${PKG_V1}::obligation::BorrowRecord`;
-}
-export class BorrowRecord {
-    __StructClass = true;
-    static $typeName = `${PKG_V1}::obligation::BorrowRecord`;
-    static $numTypeParams = 0;
-    static $isPhantom = [];
-    $typeName = BorrowRecord.$typeName;
-    $fullTypeName;
-    $typeArgs;
-    $isPhantom = BorrowRecord.$isPhantom;
-    coinType;
-    reserveArrayIndex;
-    borrowedAmount;
-    cumulativeBorrowRate;
-    marketValue;
-    userRewardManagerIndex;
-    constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(BorrowRecord.$typeName, ...typeArgs);
-        this.$typeArgs = typeArgs;
-        this.coinType = fields.coinType;
-        this.reserveArrayIndex = fields.reserveArrayIndex;
-        this.borrowedAmount = fields.borrowedAmount;
-        this.cumulativeBorrowRate = fields.cumulativeBorrowRate;
-        this.marketValue = fields.marketValue;
-        this.userRewardManagerIndex = fields.userRewardManagerIndex;
-    }
-    static reified() {
-        return {
-            typeName: BorrowRecord.$typeName,
-            fullTypeName: composeSuiType(BorrowRecord.$typeName, ...[]),
-            typeArgs: [],
-            isPhantom: BorrowRecord.$isPhantom,
-            reifiedTypeArgs: [],
-            fromFields: (fields) => BorrowRecord.fromFields(fields),
-            fromFieldsWithTypes: (item) => BorrowRecord.fromFieldsWithTypes(item),
-            fromBcs: (data) => BorrowRecord.fromBcs(data),
-            bcs: BorrowRecord.bcs,
-            fromJSONField: (field) => BorrowRecord.fromJSONField(field),
-            fromJSON: (json) => BorrowRecord.fromJSON(json),
-            fetch: async (client, id) => BorrowRecord.fetch(client, id),
-            new: (fields) => {
-                return new BorrowRecord([], fields);
-            },
-            kind: "StructClassReified",
-        };
-    }
-    static get r() {
-        return BorrowRecord.reified();
-    }
-    static phantom() {
-        return phantom(BorrowRecord.reified());
-    }
-    static get p() {
-        return BorrowRecord.phantom();
-    }
-    static get bcs() {
-        return bcs.struct("BorrowRecord", {
-            coin_type: TypeName.bcs,
-            reserve_array_index: bcs.u64(),
-            borrowed_amount: Decimal.bcs,
-            cumulative_borrow_rate: Decimal.bcs,
-            market_value: Decimal.bcs,
-            user_reward_manager_index: bcs.u64(),
-        });
-    }
-    static fromFields(fields) {
-        return BorrowRecord.reified().new({
-            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveArrayIndex: decodeFromFields("u64", fields.reserve_array_index),
-            borrowedAmount: decodeFromFields(Decimal.reified(), fields.borrowed_amount),
-            cumulativeBorrowRate: decodeFromFields(Decimal.reified(), fields.cumulative_borrow_rate),
-            marketValue: decodeFromFields(Decimal.reified(), fields.market_value),
-            userRewardManagerIndex: decodeFromFields("u64", fields.user_reward_manager_index),
-        });
-    }
-    static fromFieldsWithTypes(item) {
-        if (!isBorrowRecord(item.type)) {
-            throw new Error("not a BorrowRecord type");
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
         }
-        return BorrowRecord.reified().new({
-            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveArrayIndex: decodeFromFieldsWithTypes("u64", item.fields.reserve_array_index),
-            borrowedAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrowed_amount),
-            cumulativeBorrowRate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.cumulative_borrow_rate),
-            marketValue: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.market_value),
-            userRewardManagerIndex: decodeFromFieldsWithTypes("u64", item.fields.user_reward_manager_index),
-        });
-    }
-    static fromBcs(data) {
-        return BorrowRecord.fromFields(BorrowRecord.bcs.parse(data));
-    }
-    toJSONField() {
-        return {
-            coinType: this.coinType.toJSONField(),
-            reserveArrayIndex: this.reserveArrayIndex.toString(),
-            borrowedAmount: this.borrowedAmount.toJSONField(),
-            cumulativeBorrowRate: this.cumulativeBorrowRate.toJSONField(),
-            marketValue: this.marketValue.toJSONField(),
-            userRewardManagerIndex: this.userRewardManagerIndex.toString(),
-        };
-    }
-    toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        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 Obligation.fromBcs(typeArg, obj.content);
     }
-    static fromJSONField(field) {
-        return BorrowRecord.reified().new({
-            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveArrayIndex: decodeFromJSONField("u64", field.reserveArrayIndex),
-            borrowedAmount: decodeFromJSONField(Decimal.reified(), field.borrowedAmount),
-            cumulativeBorrowRate: decodeFromJSONField(Decimal.reified(), field.cumulativeBorrowRate),
-            marketValue: decodeFromJSONField(Decimal.reified(), field.marketValue),
-            userRewardManagerIndex: decodeFromJSONField("u64", field.userRewardManagerIndex),
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
         });
-    }
-    static fromJSON(json) {
-        if (json.$typeName !== BorrowRecord.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (!isObligation(object.type)) {
+            throw new Error(`object at id ${id} is not a Obligation object`);
         }
-        return BorrowRecord.fromJSONField(json);
-    }
-    static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isBorrowRecord(object.type)) {
-            throw new Error(`object at id ${id} is not a BorrowRecord 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}'`);
         }
-        return BorrowRecord.fromBcs(object.content);
+        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 Obligation.fromBcs(typeArg, object.content);
     }
 }
 /* ============================== Deposit =============================== */
 export function isDeposit(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::obligation::Deposit`;
+    return type === `${getTypeOrigin('suilend', 'obligation::Deposit')}::obligation::Deposit`;
 }
 export class Deposit {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::obligation::Deposit`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'obligation::Deposit')}::obligation::Deposit`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = Deposit.$typeName;
@@ -299,6 +300,7 @@ export class Deposit {
     depositedCtokenAmount;
     marketValue;
     userRewardManagerIndex;
+    /** unused */
     attributedBorrowValue;
     constructor(typeArgs, fields) {
         this.$fullTypeName = composeSuiType(Deposit.$typeName, ...typeArgs);
@@ -311,23 +313,29 @@ export class Deposit {
         this.attributedBorrowValue = fields.attributedBorrowValue;
     }
     static reified() {
+        const reifiedBcs = Deposit.bcs;
         return {
-            typeName: Deposit.$typeName,
-            fullTypeName: composeSuiType(Deposit.$typeName, ...[]),
+            get typeName() {
+                return Deposit.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(Deposit.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: Deposit.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => Deposit.fromFields(fields),
             fromFieldsWithTypes: (item) => Deposit.fromFieldsWithTypes(item),
-            fromBcs: (data) => Deposit.fromBcs(data),
-            bcs: Deposit.bcs,
+            fromBcs: (data) => Deposit.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => Deposit.fromJSONField(field),
             fromJSON: (json) => Deposit.fromJSON(json),
+            fromCoreObject: (obj) => Deposit.fromCoreObject(obj),
             fetch: async (client, id) => Deposit.fetch(client, id),
             new: (fields) => {
                 return new Deposit([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -339,8 +347,8 @@ export class Deposit {
     static get p() {
         return Deposit.phantom();
     }
-    static get bcs() {
-        return bcs.struct("Deposit", {
+    static instantiateBcs() {
+        return bcs.struct('Deposit', {
             coin_type: TypeName.bcs,
             reserve_array_index: bcs.u64(),
             deposited_ctoken_amount: bcs.u64(),
@@ -349,26 +357,33 @@ export class Deposit {
             attributed_borrow_value: Decimal.bcs,
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!Deposit.cachedBcs) {
+            Deposit.cachedBcs = Deposit.instantiateBcs();
+        }
+        return Deposit.cachedBcs;
+    }
     static fromFields(fields) {
         return Deposit.reified().new({
             coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveArrayIndex: decodeFromFields("u64", fields.reserve_array_index),
-            depositedCtokenAmount: decodeFromFields("u64", fields.deposited_ctoken_amount),
+            reserveArrayIndex: decodeFromFields('u64', fields.reserve_array_index),
+            depositedCtokenAmount: decodeFromFields('u64', fields.deposited_ctoken_amount),
             marketValue: decodeFromFields(Decimal.reified(), fields.market_value),
-            userRewardManagerIndex: decodeFromFields("u64", fields.user_reward_manager_index),
+            userRewardManagerIndex: decodeFromFields('u64', fields.user_reward_manager_index),
             attributedBorrowValue: decodeFromFields(Decimal.reified(), fields.attributed_borrow_value),
         });
     }
     static fromFieldsWithTypes(item) {
         if (!isDeposit(item.type)) {
-            throw new Error("not a Deposit type");
+            throw new Error('not a Deposit type');
         }
         return Deposit.reified().new({
             coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveArrayIndex: decodeFromFieldsWithTypes("u64", item.fields.reserve_array_index),
-            depositedCtokenAmount: decodeFromFieldsWithTypes("u64", item.fields.deposited_ctoken_amount),
+            reserveArrayIndex: decodeFromFieldsWithTypes('u64', item.fields.reserve_array_index),
+            depositedCtokenAmount: decodeFromFieldsWithTypes('u64', item.fields.deposited_ctoken_amount),
             marketValue: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.market_value),
-            userRewardManagerIndex: decodeFromFieldsWithTypes("u64", item.fields.user_reward_manager_index),
+            userRewardManagerIndex: decodeFromFieldsWithTypes('u64', item.fields.user_reward_manager_index),
             attributedBorrowValue: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.attributed_borrow_value),
         });
     }
@@ -377,7 +392,7 @@ export class Deposit {
     }
     toJSONField() {
         return {
-            coinType: this.coinType.toJSONField(),
+            coinType: this.coinType,
             reserveArrayIndex: this.reserveArrayIndex.toString(),
             depositedCtokenAmount: this.depositedCtokenAmount.toString(),
             marketValue: this.marketValue.toJSONField(),
@@ -386,180 +401,208 @@ export class Deposit {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return Deposit.reified().new({
             coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveArrayIndex: decodeFromJSONField("u64", field.reserveArrayIndex),
-            depositedCtokenAmount: decodeFromJSONField("u64", field.depositedCtokenAmount),
+            reserveArrayIndex: decodeFromJSONField('u64', field.reserveArrayIndex),
+            depositedCtokenAmount: decodeFromJSONField('u64', field.depositedCtokenAmount),
             marketValue: decodeFromJSONField(Decimal.reified(), field.marketValue),
-            userRewardManagerIndex: decodeFromJSONField("u64", field.userRewardManagerIndex),
+            userRewardManagerIndex: decodeFromJSONField('u64', field.userRewardManagerIndex),
             attributedBorrowValue: decodeFromJSONField(Decimal.reified(), field.attributedBorrowValue),
         });
     }
     static fromJSON(json) {
         if (json.$typeName !== Deposit.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a Deposit json object: expected '${Deposit.$typeName}' but got '${json.$typeName}'`);
         }
         return Deposit.fromJSONField(json);
     }
+    static fromCoreObject(obj) {
+        if (!isDeposit(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a Deposit object`);
+        }
+        return Deposit.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 (!isDeposit(object.type)) {
             throw new Error(`object at id ${id} is not a Deposit object`);
         }
         return Deposit.fromBcs(object.content);
     }
 }
-/* ============================== DepositRecord =============================== */
-export function isDepositRecord(type) {
+/* ============================== Borrow =============================== */
+export function isBorrow(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::obligation::DepositRecord`;
+    return type === `${getTypeOrigin('suilend', 'obligation::Borrow')}::obligation::Borrow`;
 }
-export class DepositRecord {
+export class Borrow {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::obligation::DepositRecord`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'obligation::Borrow')}::obligation::Borrow`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = DepositRecord.$typeName;
+    $typeName = Borrow.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = DepositRecord.$isPhantom;
+    $isPhantom = Borrow.$isPhantom;
     coinType;
     reserveArrayIndex;
-    depositedCtokenAmount;
+    borrowedAmount;
+    cumulativeBorrowRate;
     marketValue;
     userRewardManagerIndex;
-    attributedBorrowValue;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(DepositRecord.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(Borrow.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.coinType = fields.coinType;
         this.reserveArrayIndex = fields.reserveArrayIndex;
-        this.depositedCtokenAmount = fields.depositedCtokenAmount;
+        this.borrowedAmount = fields.borrowedAmount;
+        this.cumulativeBorrowRate = fields.cumulativeBorrowRate;
         this.marketValue = fields.marketValue;
         this.userRewardManagerIndex = fields.userRewardManagerIndex;
-        this.attributedBorrowValue = fields.attributedBorrowValue;
     }
     static reified() {
+        const reifiedBcs = Borrow.bcs;
         return {
-            typeName: DepositRecord.$typeName,
-            fullTypeName: composeSuiType(DepositRecord.$typeName, ...[]),
+            get typeName() {
+                return Borrow.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(Borrow.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: DepositRecord.$isPhantom,
+            isPhantom: Borrow.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => DepositRecord.fromFields(fields),
-            fromFieldsWithTypes: (item) => DepositRecord.fromFieldsWithTypes(item),
-            fromBcs: (data) => DepositRecord.fromBcs(data),
-            bcs: DepositRecord.bcs,
-            fromJSONField: (field) => DepositRecord.fromJSONField(field),
-            fromJSON: (json) => DepositRecord.fromJSON(json),
-            fetch: async (client, id) => DepositRecord.fetch(client, id),
+            fromFields: (fields) => Borrow.fromFields(fields),
+            fromFieldsWithTypes: (item) => Borrow.fromFieldsWithTypes(item),
+            fromBcs: (data) => Borrow.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => Borrow.fromJSONField(field),
+            fromJSON: (json) => Borrow.fromJSON(json),
+            fromCoreObject: (obj) => Borrow.fromCoreObject(obj),
+            fetch: async (client, id) => Borrow.fetch(client, id),
             new: (fields) => {
-                return new DepositRecord([], fields);
+                return new Borrow([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return DepositRecord.reified();
+        return Borrow.reified();
     }
     static phantom() {
-        return phantom(DepositRecord.reified());
+        return phantom(Borrow.reified());
     }
     static get p() {
-        return DepositRecord.phantom();
+        return Borrow.phantom();
     }
-    static get bcs() {
-        return bcs.struct("DepositRecord", {
+    static instantiateBcs() {
+        return bcs.struct('Borrow', {
             coin_type: TypeName.bcs,
             reserve_array_index: bcs.u64(),
-            deposited_ctoken_amount: bcs.u64(),
+            borrowed_amount: Decimal.bcs,
+            cumulative_borrow_rate: Decimal.bcs,
             market_value: Decimal.bcs,
             user_reward_manager_index: bcs.u64(),
-            attributed_borrow_value: Decimal.bcs,
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!Borrow.cachedBcs) {
+            Borrow.cachedBcs = Borrow.instantiateBcs();
+        }
+        return Borrow.cachedBcs;
+    }
     static fromFields(fields) {
-        return DepositRecord.reified().new({
+        return Borrow.reified().new({
             coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            reserveArrayIndex: decodeFromFields("u64", fields.reserve_array_index),
-            depositedCtokenAmount: decodeFromFields("u64", fields.deposited_ctoken_amount),
+            reserveArrayIndex: decodeFromFields('u64', fields.reserve_array_index),
+            borrowedAmount: decodeFromFields(Decimal.reified(), fields.borrowed_amount),
+            cumulativeBorrowRate: decodeFromFields(Decimal.reified(), fields.cumulative_borrow_rate),
             marketValue: decodeFromFields(Decimal.reified(), fields.market_value),
-            userRewardManagerIndex: decodeFromFields("u64", fields.user_reward_manager_index),
-            attributedBorrowValue: decodeFromFields(Decimal.reified(), fields.attributed_borrow_value),
+            userRewardManagerIndex: decodeFromFields('u64', fields.user_reward_manager_index),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isDepositRecord(item.type)) {
-            throw new Error("not a DepositRecord type");
+        if (!isBorrow(item.type)) {
+            throw new Error('not a Borrow type');
         }
-        return DepositRecord.reified().new({
+        return Borrow.reified().new({
             coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            reserveArrayIndex: decodeFromFieldsWithTypes("u64", item.fields.reserve_array_index),
-            depositedCtokenAmount: decodeFromFieldsWithTypes("u64", item.fields.deposited_ctoken_amount),
+            reserveArrayIndex: decodeFromFieldsWithTypes('u64', item.fields.reserve_array_index),
+            borrowedAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrowed_amount),
+            cumulativeBorrowRate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.cumulative_borrow_rate),
             marketValue: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.market_value),
-            userRewardManagerIndex: decodeFromFieldsWithTypes("u64", item.fields.user_reward_manager_index),
-            attributedBorrowValue: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.attributed_borrow_value),
+            userRewardManagerIndex: decodeFromFieldsWithTypes('u64', item.fields.user_reward_manager_index),
         });
     }
     static fromBcs(data) {
-        return DepositRecord.fromFields(DepositRecord.bcs.parse(data));
+        return Borrow.fromFields(Borrow.bcs.parse(data));
     }
     toJSONField() {
         return {
-            coinType: this.coinType.toJSONField(),
+            coinType: this.coinType,
             reserveArrayIndex: this.reserveArrayIndex.toString(),
-            depositedCtokenAmount: this.depositedCtokenAmount.toString(),
+            borrowedAmount: this.borrowedAmount.toJSONField(),
+            cumulativeBorrowRate: this.cumulativeBorrowRate.toJSONField(),
             marketValue: this.marketValue.toJSONField(),
             userRewardManagerIndex: this.userRewardManagerIndex.toString(),
-            attributedBorrowValue: this.attributedBorrowValue.toJSONField(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return DepositRecord.reified().new({
+        return Borrow.reified().new({
             coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            reserveArrayIndex: decodeFromJSONField("u64", field.reserveArrayIndex),
-            depositedCtokenAmount: decodeFromJSONField("u64", field.depositedCtokenAmount),
+            reserveArrayIndex: decodeFromJSONField('u64', field.reserveArrayIndex),
+            borrowedAmount: decodeFromJSONField(Decimal.reified(), field.borrowedAmount),
+            cumulativeBorrowRate: decodeFromJSONField(Decimal.reified(), field.cumulativeBorrowRate),
             marketValue: decodeFromJSONField(Decimal.reified(), field.marketValue),
-            userRewardManagerIndex: decodeFromJSONField("u64", field.userRewardManagerIndex),
-            attributedBorrowValue: decodeFromJSONField(Decimal.reified(), field.attributedBorrowValue),
+            userRewardManagerIndex: decodeFromJSONField('u64', field.userRewardManagerIndex),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== DepositRecord.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== Borrow.$typeName) {
+            throw new Error(`not a Borrow json object: expected '${Borrow.$typeName}' but got '${json.$typeName}'`);
         }
-        return DepositRecord.fromJSONField(json);
+        return Borrow.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isBorrow(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a Borrow object`);
+        }
+        return Borrow.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isDepositRecord(object.type)) {
-            throw new Error(`object at id ${id} is not a DepositRecord object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isBorrow(object.type)) {
+            throw new Error(`object at id ${id} is not a Borrow object`);
         }
-        return DepositRecord.fromBcs(object.content);
+        return Borrow.fromBcs(object.content);
     }
 }
 /* ============================== ExistStaleOracles =============================== */
 export function isExistStaleOracles(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V11}::obligation::ExistStaleOracles`;
+    return type
+        === `${getTypeOrigin('suilend', 'obligation::ExistStaleOracles')}::obligation::ExistStaleOracles`;
 }
 export class ExistStaleOracles {
     __StructClass = true;
-    static $typeName = `${PKG_V11}::obligation::ExistStaleOracles`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'obligation::ExistStaleOracles')}::obligation::ExistStaleOracles`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = ExistStaleOracles.$typeName;
@@ -573,23 +616,29 @@ export class ExistStaleOracles {
         this.dummyField = fields.dummyField;
     }
     static reified() {
+        const reifiedBcs = ExistStaleOracles.bcs;
         return {
-            typeName: ExistStaleOracles.$typeName,
-            fullTypeName: composeSuiType(ExistStaleOracles.$typeName, ...[]),
+            get typeName() {
+                return ExistStaleOracles.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ExistStaleOracles.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: ExistStaleOracles.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => ExistStaleOracles.fromFields(fields),
             fromFieldsWithTypes: (item) => ExistStaleOracles.fromFieldsWithTypes(item),
-            fromBcs: (data) => ExistStaleOracles.fromBcs(data),
-            bcs: ExistStaleOracles.bcs,
+            fromBcs: (data) => ExistStaleOracles.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => ExistStaleOracles.fromJSONField(field),
             fromJSON: (json) => ExistStaleOracles.fromJSON(json),
+            fromCoreObject: (obj) => ExistStaleOracles.fromCoreObject(obj),
             fetch: async (client, id) => ExistStaleOracles.fetch(client, id),
             new: (fields) => {
                 return new ExistStaleOracles([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -601,22 +650,29 @@ export class ExistStaleOracles {
     static get p() {
         return ExistStaleOracles.phantom();
     }
-    static get bcs() {
-        return bcs.struct("ExistStaleOracles", {
+    static instantiateBcs() {
+        return bcs.struct('ExistStaleOracles', {
             dummy_field: bcs.bool(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!ExistStaleOracles.cachedBcs) {
+            ExistStaleOracles.cachedBcs = ExistStaleOracles.instantiateBcs();
+        }
+        return ExistStaleOracles.cachedBcs;
+    }
     static fromFields(fields) {
         return ExistStaleOracles.reified().new({
-            dummyField: decodeFromFields("bool", fields.dummy_field),
+            dummyField: decodeFromFields('bool', fields.dummy_field),
         });
     }
     static fromFieldsWithTypes(item) {
         if (!isExistStaleOracles(item.type)) {
-            throw new Error("not a ExistStaleOracles type");
+            throw new Error('not a ExistStaleOracles type');
         }
         return ExistStaleOracles.reified().new({
-            dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field),
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
         });
     }
     static fromBcs(data) {
@@ -628,241 +684,47 @@ export class ExistStaleOracles {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return ExistStaleOracles.reified().new({
-            dummyField: decodeFromJSONField("bool", field.dummyField),
+            dummyField: decodeFromJSONField('bool', field.dummyField),
         });
     }
     static fromJSON(json) {
         if (json.$typeName !== ExistStaleOracles.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a ExistStaleOracles json object: expected '${ExistStaleOracles.$typeName}' but got '${json.$typeName}'`);
         }
         return ExistStaleOracles.fromJSONField(json);
     }
-    static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isExistStaleOracles(object.type)) {
-            throw new Error(`object at id ${id} is not a ExistStaleOracles object`);
-        }
-        return ExistStaleOracles.fromBcs(object.content);
-    }
-}
-/* ============================== Obligation =============================== */
-export function isObligation(type) {
-    type = compressSuiType(type);
-    return type.startsWith(`${PKG_V1}::obligation::Obligation` + "<");
-}
-export class Obligation {
-    __StructClass = true;
-    static $typeName = `${PKG_V1}::obligation::Obligation`;
-    static $numTypeParams = 1;
-    static $isPhantom = [true];
-    $typeName = Obligation.$typeName;
-    $fullTypeName;
-    $typeArgs;
-    $isPhantom = Obligation.$isPhantom;
-    id;
-    lendingMarketId;
-    deposits;
-    borrows;
-    depositedValueUsd;
-    allowedBorrowValueUsd;
-    unhealthyBorrowValueUsd;
-    superUnhealthyBorrowValueUsd;
-    unweightedBorrowedValueUsd;
-    weightedBorrowedValueUsd;
-    weightedBorrowedValueUpperBoundUsd;
-    borrowingIsolatedAsset;
-    userRewardManagers;
-    badDebtUsd;
-    closable;
-    constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(Obligation.$typeName, ...typeArgs);
-        this.$typeArgs = typeArgs;
-        this.id = fields.id;
-        this.lendingMarketId = fields.lendingMarketId;
-        this.deposits = fields.deposits;
-        this.borrows = fields.borrows;
-        this.depositedValueUsd = fields.depositedValueUsd;
-        this.allowedBorrowValueUsd = fields.allowedBorrowValueUsd;
-        this.unhealthyBorrowValueUsd = fields.unhealthyBorrowValueUsd;
-        this.superUnhealthyBorrowValueUsd = fields.superUnhealthyBorrowValueUsd;
-        this.unweightedBorrowedValueUsd = fields.unweightedBorrowedValueUsd;
-        this.weightedBorrowedValueUsd = fields.weightedBorrowedValueUsd;
-        this.weightedBorrowedValueUpperBoundUsd =
-            fields.weightedBorrowedValueUpperBoundUsd;
-        this.borrowingIsolatedAsset = fields.borrowingIsolatedAsset;
-        this.userRewardManagers = fields.userRewardManagers;
-        this.badDebtUsd = fields.badDebtUsd;
-        this.closable = fields.closable;
-    }
-    static reified(P) {
-        return {
-            typeName: Obligation.$typeName,
-            fullTypeName: composeSuiType(Obligation.$typeName, ...[extractType(P)]),
-            typeArgs: [extractType(P)],
-            isPhantom: Obligation.$isPhantom,
-            reifiedTypeArgs: [P],
-            fromFields: (fields) => Obligation.fromFields(P, fields),
-            fromFieldsWithTypes: (item) => Obligation.fromFieldsWithTypes(P, item),
-            fromBcs: (data) => Obligation.fromBcs(P, data),
-            bcs: Obligation.bcs,
-            fromJSONField: (field) => Obligation.fromJSONField(P, field),
-            fromJSON: (json) => Obligation.fromJSON(P, json),
-            fetch: async (client, id) => Obligation.fetch(client, P, id),
-            new: (fields) => {
-                return new Obligation([extractType(P)], fields);
-            },
-            kind: "StructClassReified",
-        };
-    }
-    static get r() {
-        return Obligation.reified;
-    }
-    static phantom(P) {
-        return phantom(Obligation.reified(P));
-    }
-    static get p() {
-        return Obligation.phantom;
-    }
-    static get bcs() {
-        return bcs.struct("Obligation", {
-            id: UID.bcs,
-            lending_market_id: ID.bcs,
-            deposits: bcs.vector(Deposit.bcs),
-            borrows: bcs.vector(Borrow.bcs),
-            deposited_value_usd: Decimal.bcs,
-            allowed_borrow_value_usd: Decimal.bcs,
-            unhealthy_borrow_value_usd: Decimal.bcs,
-            super_unhealthy_borrow_value_usd: Decimal.bcs,
-            unweighted_borrowed_value_usd: Decimal.bcs,
-            weighted_borrowed_value_usd: Decimal.bcs,
-            weighted_borrowed_value_upper_bound_usd: Decimal.bcs,
-            borrowing_isolated_asset: bcs.bool(),
-            user_reward_managers: bcs.vector(UserRewardManager.bcs),
-            bad_debt_usd: Decimal.bcs,
-            closable: bcs.bool(),
-        });
-    }
-    static fromFields(typeArg, fields) {
-        return Obligation.reified(typeArg).new({
-            id: decodeFromFields(UID.reified(), fields.id),
-            lendingMarketId: decodeFromFields(ID.reified(), fields.lending_market_id),
-            deposits: decodeFromFields(reified.vector(Deposit.reified()), fields.deposits),
-            borrows: decodeFromFields(reified.vector(Borrow.reified()), fields.borrows),
-            depositedValueUsd: decodeFromFields(Decimal.reified(), fields.deposited_value_usd),
-            allowedBorrowValueUsd: decodeFromFields(Decimal.reified(), fields.allowed_borrow_value_usd),
-            unhealthyBorrowValueUsd: decodeFromFields(Decimal.reified(), fields.unhealthy_borrow_value_usd),
-            superUnhealthyBorrowValueUsd: decodeFromFields(Decimal.reified(), fields.super_unhealthy_borrow_value_usd),
-            unweightedBorrowedValueUsd: decodeFromFields(Decimal.reified(), fields.unweighted_borrowed_value_usd),
-            weightedBorrowedValueUsd: decodeFromFields(Decimal.reified(), fields.weighted_borrowed_value_usd),
-            weightedBorrowedValueUpperBoundUsd: decodeFromFields(Decimal.reified(), fields.weighted_borrowed_value_upper_bound_usd),
-            borrowingIsolatedAsset: decodeFromFields("bool", fields.borrowing_isolated_asset),
-            userRewardManagers: decodeFromFields(reified.vector(UserRewardManager.reified()), fields.user_reward_managers),
-            badDebtUsd: decodeFromFields(Decimal.reified(), fields.bad_debt_usd),
-            closable: decodeFromFields("bool", fields.closable),
-        });
-    }
-    static fromFieldsWithTypes(typeArg, item) {
-        if (!isObligation(item.type)) {
-            throw new Error("not a Obligation type");
-        }
-        assertFieldsWithTypesArgsMatch(item, [typeArg]);
-        return Obligation.reified(typeArg).new({
-            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
-            lendingMarketId: decodeFromFieldsWithTypes(ID.reified(), item.fields.lending_market_id),
-            deposits: decodeFromFieldsWithTypes(reified.vector(Deposit.reified()), item.fields.deposits),
-            borrows: decodeFromFieldsWithTypes(reified.vector(Borrow.reified()), item.fields.borrows),
-            depositedValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.deposited_value_usd),
-            allowedBorrowValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.allowed_borrow_value_usd),
-            unhealthyBorrowValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.unhealthy_borrow_value_usd),
-            superUnhealthyBorrowValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.super_unhealthy_borrow_value_usd),
-            unweightedBorrowedValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.unweighted_borrowed_value_usd),
-            weightedBorrowedValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.weighted_borrowed_value_usd),
-            weightedBorrowedValueUpperBoundUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.weighted_borrowed_value_upper_bound_usd),
-            borrowingIsolatedAsset: decodeFromFieldsWithTypes("bool", item.fields.borrowing_isolated_asset),
-            userRewardManagers: decodeFromFieldsWithTypes(reified.vector(UserRewardManager.reified()), item.fields.user_reward_managers),
-            badDebtUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.bad_debt_usd),
-            closable: decodeFromFieldsWithTypes("bool", item.fields.closable),
-        });
-    }
-    static fromBcs(typeArg, data) {
-        return Obligation.fromFields(typeArg, Obligation.bcs.parse(data));
-    }
-    toJSONField() {
-        return {
-            id: this.id,
-            lendingMarketId: this.lendingMarketId,
-            deposits: fieldToJSON(`vector<${Deposit.$typeName}>`, this.deposits),
-            borrows: fieldToJSON(`vector<${Borrow.$typeName}>`, this.borrows),
-            depositedValueUsd: this.depositedValueUsd.toJSONField(),
-            allowedBorrowValueUsd: this.allowedBorrowValueUsd.toJSONField(),
-            unhealthyBorrowValueUsd: this.unhealthyBorrowValueUsd.toJSONField(),
-            superUnhealthyBorrowValueUsd: this.superUnhealthyBorrowValueUsd.toJSONField(),
-            unweightedBorrowedValueUsd: this.unweightedBorrowedValueUsd.toJSONField(),
-            weightedBorrowedValueUsd: this.weightedBorrowedValueUsd.toJSONField(),
-            weightedBorrowedValueUpperBoundUsd: this.weightedBorrowedValueUpperBoundUsd.toJSONField(),
-            borrowingIsolatedAsset: this.borrowingIsolatedAsset,
-            userRewardManagers: fieldToJSON(`vector<${UserRewardManager.$typeName}>`, this.userRewardManagers),
-            badDebtUsd: this.badDebtUsd.toJSONField(),
-            closable: this.closable,
-        };
-    }
-    toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
-    }
-    static fromJSONField(typeArg, field) {
-        return Obligation.reified(typeArg).new({
-            id: decodeFromJSONField(UID.reified(), field.id),
-            lendingMarketId: decodeFromJSONField(ID.reified(), field.lendingMarketId),
-            deposits: decodeFromJSONField(reified.vector(Deposit.reified()), field.deposits),
-            borrows: decodeFromJSONField(reified.vector(Borrow.reified()), field.borrows),
-            depositedValueUsd: decodeFromJSONField(Decimal.reified(), field.depositedValueUsd),
-            allowedBorrowValueUsd: decodeFromJSONField(Decimal.reified(), field.allowedBorrowValueUsd),
-            unhealthyBorrowValueUsd: decodeFromJSONField(Decimal.reified(), field.unhealthyBorrowValueUsd),
-            superUnhealthyBorrowValueUsd: decodeFromJSONField(Decimal.reified(), field.superUnhealthyBorrowValueUsd),
-            unweightedBorrowedValueUsd: decodeFromJSONField(Decimal.reified(), field.unweightedBorrowedValueUsd),
-            weightedBorrowedValueUsd: decodeFromJSONField(Decimal.reified(), field.weightedBorrowedValueUsd),
-            weightedBorrowedValueUpperBoundUsd: decodeFromJSONField(Decimal.reified(), field.weightedBorrowedValueUpperBoundUsd),
-            borrowingIsolatedAsset: decodeFromJSONField("bool", field.borrowingIsolatedAsset),
-            userRewardManagers: decodeFromJSONField(reified.vector(UserRewardManager.reified()), field.userRewardManagers),
-            badDebtUsd: decodeFromJSONField(Decimal.reified(), field.badDebtUsd),
-            closable: decodeFromJSONField("bool", field.closable),
-        });
-    }
-    static fromJSON(typeArg, json) {
-        if (json.$typeName !== Obligation.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+    static fromCoreObject(obj) {
+        if (!isExistStaleOracles(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ExistStaleOracles object`);
         }
-        assertReifiedTypeArgsMatch(composeSuiType(Obligation.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
-        return Obligation.fromJSONField(typeArg, json);
+        return ExistStaleOracles.fromBcs(obj.content);
     }
-    static async fetch(client, typeArg, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isObligation(object.type)) {
-            throw new Error(`object at id ${id} is not a Obligation object`);
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isExistStaleOracles(object.type)) {
+            throw new Error(`object at id ${id} is not a ExistStaleOracles object`);
         }
-        return Obligation.fromBcs(typeArg, object.content);
+        return ExistStaleOracles.fromBcs(object.content);
     }
 }
 /* ============================== ObligationDataEvent =============================== */
 export function isObligationDataEvent(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::obligation::ObligationDataEvent`;
+    return type
+        === `${getTypeOrigin('suilend', 'obligation::ObligationDataEvent')}::obligation::ObligationDataEvent`;
 }
 export class ObligationDataEvent {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::obligation::ObligationDataEvent`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'obligation::ObligationDataEvent')}::obligation::ObligationDataEvent`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = ObligationDataEvent.$typeName;
@@ -896,30 +758,35 @@ export class ObligationDataEvent {
         this.superUnhealthyBorrowValueUsd = fields.superUnhealthyBorrowValueUsd;
         this.unweightedBorrowedValueUsd = fields.unweightedBorrowedValueUsd;
         this.weightedBorrowedValueUsd = fields.weightedBorrowedValueUsd;
-        this.weightedBorrowedValueUpperBoundUsd =
-            fields.weightedBorrowedValueUpperBoundUsd;
+        this.weightedBorrowedValueUpperBoundUsd = fields.weightedBorrowedValueUpperBoundUsd;
         this.borrowingIsolatedAsset = fields.borrowingIsolatedAsset;
         this.badDebtUsd = fields.badDebtUsd;
         this.closable = fields.closable;
     }
     static reified() {
+        const reifiedBcs = ObligationDataEvent.bcs;
         return {
-            typeName: ObligationDataEvent.$typeName,
-            fullTypeName: composeSuiType(ObligationDataEvent.$typeName, ...[]),
+            get typeName() {
+                return ObligationDataEvent.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ObligationDataEvent.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: ObligationDataEvent.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => ObligationDataEvent.fromFields(fields),
             fromFieldsWithTypes: (item) => ObligationDataEvent.fromFieldsWithTypes(item),
-            fromBcs: (data) => ObligationDataEvent.fromBcs(data),
-            bcs: ObligationDataEvent.bcs,
+            fromBcs: (data) => ObligationDataEvent.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => ObligationDataEvent.fromJSONField(field),
             fromJSON: (json) => ObligationDataEvent.fromJSON(json),
+            fromCoreObject: (obj) => ObligationDataEvent.fromCoreObject(obj),
             fetch: async (client, id) => ObligationDataEvent.fetch(client, id),
             new: (fields) => {
                 return new ObligationDataEvent([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -931,17 +798,13 @@ export class ObligationDataEvent {
     static get p() {
         return ObligationDataEvent.phantom();
     }
-    static get bcs() {
-        return bcs.struct("ObligationDataEvent", {
-            lending_market_id: bcs
-                .bytes(32)
-                .transform({
+    static instantiateBcs() {
+        return bcs.struct('ObligationDataEvent', {
+            lending_market_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
-            obligation_id: bcs
-                .bytes(32)
-                .transform({
+            obligation_id: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
@@ -959,12 +822,19 @@ export class ObligationDataEvent {
             closable: bcs.bool(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!ObligationDataEvent.cachedBcs) {
+            ObligationDataEvent.cachedBcs = ObligationDataEvent.instantiateBcs();
+        }
+        return ObligationDataEvent.cachedBcs;
+    }
     static fromFields(fields) {
         return ObligationDataEvent.reified().new({
-            lendingMarketId: decodeFromFields("address", fields.lending_market_id),
-            obligationId: decodeFromFields("address", fields.obligation_id),
-            deposits: decodeFromFields(reified.vector(DepositRecord.reified()), fields.deposits),
-            borrows: decodeFromFields(reified.vector(BorrowRecord.reified()), fields.borrows),
+            lendingMarketId: decodeFromFields('address', fields.lending_market_id),
+            obligationId: decodeFromFields('address', fields.obligation_id),
+            deposits: decodeFromFields(vector(DepositRecord.reified()), fields.deposits),
+            borrows: decodeFromFields(vector(BorrowRecord.reified()), fields.borrows),
             depositedValueUsd: decodeFromFields(Decimal.reified(), fields.deposited_value_usd),
             allowedBorrowValueUsd: decodeFromFields(Decimal.reified(), fields.allowed_borrow_value_usd),
             unhealthyBorrowValueUsd: decodeFromFields(Decimal.reified(), fields.unhealthy_borrow_value_usd),
@@ -972,20 +842,20 @@ export class ObligationDataEvent {
             unweightedBorrowedValueUsd: decodeFromFields(Decimal.reified(), fields.unweighted_borrowed_value_usd),
             weightedBorrowedValueUsd: decodeFromFields(Decimal.reified(), fields.weighted_borrowed_value_usd),
             weightedBorrowedValueUpperBoundUsd: decodeFromFields(Decimal.reified(), fields.weighted_borrowed_value_upper_bound_usd),
-            borrowingIsolatedAsset: decodeFromFields("bool", fields.borrowing_isolated_asset),
+            borrowingIsolatedAsset: decodeFromFields('bool', fields.borrowing_isolated_asset),
             badDebtUsd: decodeFromFields(Decimal.reified(), fields.bad_debt_usd),
-            closable: decodeFromFields("bool", fields.closable),
+            closable: decodeFromFields('bool', fields.closable),
         });
     }
     static fromFieldsWithTypes(item) {
         if (!isObligationDataEvent(item.type)) {
-            throw new Error("not a ObligationDataEvent type");
+            throw new Error('not a ObligationDataEvent type');
         }
         return ObligationDataEvent.reified().new({
-            lendingMarketId: decodeFromFieldsWithTypes("address", item.fields.lending_market_id),
-            obligationId: decodeFromFieldsWithTypes("address", item.fields.obligation_id),
-            deposits: decodeFromFieldsWithTypes(reified.vector(DepositRecord.reified()), item.fields.deposits),
-            borrows: decodeFromFieldsWithTypes(reified.vector(BorrowRecord.reified()), item.fields.borrows),
+            lendingMarketId: decodeFromFieldsWithTypes('address', item.fields.lending_market_id),
+            obligationId: decodeFromFieldsWithTypes('address', item.fields.obligation_id),
+            deposits: decodeFromFieldsWithTypes(vector(DepositRecord.reified()), item.fields.deposits),
+            borrows: decodeFromFieldsWithTypes(vector(BorrowRecord.reified()), item.fields.borrows),
             depositedValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.deposited_value_usd),
             allowedBorrowValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.allowed_borrow_value_usd),
             unhealthyBorrowValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.unhealthy_borrow_value_usd),
@@ -993,9 +863,9 @@ export class ObligationDataEvent {
             unweightedBorrowedValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.unweighted_borrowed_value_usd),
             weightedBorrowedValueUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.weighted_borrowed_value_usd),
             weightedBorrowedValueUpperBoundUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.weighted_borrowed_value_upper_bound_usd),
-            borrowingIsolatedAsset: decodeFromFieldsWithTypes("bool", item.fields.borrowing_isolated_asset),
+            borrowingIsolatedAsset: decodeFromFieldsWithTypes('bool', item.fields.borrowing_isolated_asset),
             badDebtUsd: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.bad_debt_usd),
-            closable: decodeFromFieldsWithTypes("bool", item.fields.closable),
+            closable: decodeFromFieldsWithTypes('bool', item.fields.closable),
         });
     }
     static fromBcs(data) {
@@ -1020,18 +890,14 @@ export class ObligationDataEvent {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return ObligationDataEvent.reified().new({
-            lendingMarketId: decodeFromJSONField("address", field.lendingMarketId),
-            obligationId: decodeFromJSONField("address", field.obligationId),
-            deposits: decodeFromJSONField(reified.vector(DepositRecord.reified()), field.deposits),
-            borrows: decodeFromJSONField(reified.vector(BorrowRecord.reified()), field.borrows),
+            lendingMarketId: decodeFromJSONField('address', field.lendingMarketId),
+            obligationId: decodeFromJSONField('address', field.obligationId),
+            deposits: decodeFromJSONField(vector(DepositRecord.reified()), field.deposits),
+            borrows: decodeFromJSONField(vector(BorrowRecord.reified()), field.borrows),
             depositedValueUsd: decodeFromJSONField(Decimal.reified(), field.depositedValueUsd),
             allowedBorrowValueUsd: decodeFromJSONField(Decimal.reified(), field.allowedBorrowValueUsd),
             unhealthyBorrowValueUsd: decodeFromJSONField(Decimal.reified(), field.unhealthyBorrowValueUsd),
@@ -1039,22 +905,346 @@ export class ObligationDataEvent {
             unweightedBorrowedValueUsd: decodeFromJSONField(Decimal.reified(), field.unweightedBorrowedValueUsd),
             weightedBorrowedValueUsd: decodeFromJSONField(Decimal.reified(), field.weightedBorrowedValueUsd),
             weightedBorrowedValueUpperBoundUsd: decodeFromJSONField(Decimal.reified(), field.weightedBorrowedValueUpperBoundUsd),
-            borrowingIsolatedAsset: decodeFromJSONField("bool", field.borrowingIsolatedAsset),
+            borrowingIsolatedAsset: decodeFromJSONField('bool', field.borrowingIsolatedAsset),
             badDebtUsd: decodeFromJSONField(Decimal.reified(), field.badDebtUsd),
-            closable: decodeFromJSONField("bool", field.closable),
+            closable: decodeFromJSONField('bool', field.closable),
         });
     }
     static fromJSON(json) {
         if (json.$typeName !== ObligationDataEvent.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a ObligationDataEvent json object: expected '${ObligationDataEvent.$typeName}' but got '${json.$typeName}'`);
         }
         return ObligationDataEvent.fromJSONField(json);
     }
+    static fromCoreObject(obj) {
+        if (!isObligationDataEvent(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ObligationDataEvent object`);
+        }
+        return ObligationDataEvent.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 (!isObligationDataEvent(object.type)) {
             throw new Error(`object at id ${id} is not a ObligationDataEvent object`);
         }
         return ObligationDataEvent.fromBcs(object.content);
     }
 }
+/* ============================== DepositRecord =============================== */
+export function isDepositRecord(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'obligation::DepositRecord')}::obligation::DepositRecord`;
+}
+export class DepositRecord {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'obligation::DepositRecord')}::obligation::DepositRecord`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = DepositRecord.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = DepositRecord.$isPhantom;
+    coinType;
+    reserveArrayIndex;
+    depositedCtokenAmount;
+    marketValue;
+    userRewardManagerIndex;
+    /** unused */
+    attributedBorrowValue;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(DepositRecord.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.coinType = fields.coinType;
+        this.reserveArrayIndex = fields.reserveArrayIndex;
+        this.depositedCtokenAmount = fields.depositedCtokenAmount;
+        this.marketValue = fields.marketValue;
+        this.userRewardManagerIndex = fields.userRewardManagerIndex;
+        this.attributedBorrowValue = fields.attributedBorrowValue;
+    }
+    static reified() {
+        const reifiedBcs = DepositRecord.bcs;
+        return {
+            get typeName() {
+                return DepositRecord.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(DepositRecord.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: DepositRecord.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => DepositRecord.fromFields(fields),
+            fromFieldsWithTypes: (item) => DepositRecord.fromFieldsWithTypes(item),
+            fromBcs: (data) => DepositRecord.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => DepositRecord.fromJSONField(field),
+            fromJSON: (json) => DepositRecord.fromJSON(json),
+            fromCoreObject: (obj) => DepositRecord.fromCoreObject(obj),
+            fetch: async (client, id) => DepositRecord.fetch(client, id),
+            new: (fields) => {
+                return new DepositRecord([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return DepositRecord.reified();
+    }
+    static phantom() {
+        return phantom(DepositRecord.reified());
+    }
+    static get p() {
+        return DepositRecord.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('DepositRecord', {
+            coin_type: TypeName.bcs,
+            reserve_array_index: bcs.u64(),
+            deposited_ctoken_amount: bcs.u64(),
+            market_value: Decimal.bcs,
+            user_reward_manager_index: bcs.u64(),
+            attributed_borrow_value: Decimal.bcs,
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!DepositRecord.cachedBcs) {
+            DepositRecord.cachedBcs = DepositRecord.instantiateBcs();
+        }
+        return DepositRecord.cachedBcs;
+    }
+    static fromFields(fields) {
+        return DepositRecord.reified().new({
+            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
+            reserveArrayIndex: decodeFromFields('u64', fields.reserve_array_index),
+            depositedCtokenAmount: decodeFromFields('u64', fields.deposited_ctoken_amount),
+            marketValue: decodeFromFields(Decimal.reified(), fields.market_value),
+            userRewardManagerIndex: decodeFromFields('u64', fields.user_reward_manager_index),
+            attributedBorrowValue: decodeFromFields(Decimal.reified(), fields.attributed_borrow_value),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isDepositRecord(item.type)) {
+            throw new Error('not a DepositRecord type');
+        }
+        return DepositRecord.reified().new({
+            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
+            reserveArrayIndex: decodeFromFieldsWithTypes('u64', item.fields.reserve_array_index),
+            depositedCtokenAmount: decodeFromFieldsWithTypes('u64', item.fields.deposited_ctoken_amount),
+            marketValue: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.market_value),
+            userRewardManagerIndex: decodeFromFieldsWithTypes('u64', item.fields.user_reward_manager_index),
+            attributedBorrowValue: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.attributed_borrow_value),
+        });
+    }
+    static fromBcs(data) {
+        return DepositRecord.fromFields(DepositRecord.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            coinType: this.coinType,
+            reserveArrayIndex: this.reserveArrayIndex.toString(),
+            depositedCtokenAmount: this.depositedCtokenAmount.toString(),
+            marketValue: this.marketValue.toJSONField(),
+            userRewardManagerIndex: this.userRewardManagerIndex.toString(),
+            attributedBorrowValue: this.attributedBorrowValue.toJSONField(),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return DepositRecord.reified().new({
+            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
+            reserveArrayIndex: decodeFromJSONField('u64', field.reserveArrayIndex),
+            depositedCtokenAmount: decodeFromJSONField('u64', field.depositedCtokenAmount),
+            marketValue: decodeFromJSONField(Decimal.reified(), field.marketValue),
+            userRewardManagerIndex: decodeFromJSONField('u64', field.userRewardManagerIndex),
+            attributedBorrowValue: decodeFromJSONField(Decimal.reified(), field.attributedBorrowValue),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== DepositRecord.$typeName) {
+            throw new Error(`not a DepositRecord json object: expected '${DepositRecord.$typeName}' but got '${json.$typeName}'`);
+        }
+        return DepositRecord.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isDepositRecord(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a DepositRecord object`);
+        }
+        return DepositRecord.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isDepositRecord(object.type)) {
+            throw new Error(`object at id ${id} is not a DepositRecord object`);
+        }
+        return DepositRecord.fromBcs(object.content);
+    }
+}
+/* ============================== BorrowRecord =============================== */
+export function isBorrowRecord(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'obligation::BorrowRecord')}::obligation::BorrowRecord`;
+}
+export class BorrowRecord {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'obligation::BorrowRecord')}::obligation::BorrowRecord`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = BorrowRecord.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = BorrowRecord.$isPhantom;
+    coinType;
+    reserveArrayIndex;
+    borrowedAmount;
+    cumulativeBorrowRate;
+    marketValue;
+    userRewardManagerIndex;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(BorrowRecord.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.coinType = fields.coinType;
+        this.reserveArrayIndex = fields.reserveArrayIndex;
+        this.borrowedAmount = fields.borrowedAmount;
+        this.cumulativeBorrowRate = fields.cumulativeBorrowRate;
+        this.marketValue = fields.marketValue;
+        this.userRewardManagerIndex = fields.userRewardManagerIndex;
+    }
+    static reified() {
+        const reifiedBcs = BorrowRecord.bcs;
+        return {
+            get typeName() {
+                return BorrowRecord.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(BorrowRecord.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: BorrowRecord.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => BorrowRecord.fromFields(fields),
+            fromFieldsWithTypes: (item) => BorrowRecord.fromFieldsWithTypes(item),
+            fromBcs: (data) => BorrowRecord.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => BorrowRecord.fromJSONField(field),
+            fromJSON: (json) => BorrowRecord.fromJSON(json),
+            fromCoreObject: (obj) => BorrowRecord.fromCoreObject(obj),
+            fetch: async (client, id) => BorrowRecord.fetch(client, id),
+            new: (fields) => {
+                return new BorrowRecord([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return BorrowRecord.reified();
+    }
+    static phantom() {
+        return phantom(BorrowRecord.reified());
+    }
+    static get p() {
+        return BorrowRecord.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('BorrowRecord', {
+            coin_type: TypeName.bcs,
+            reserve_array_index: bcs.u64(),
+            borrowed_amount: Decimal.bcs,
+            cumulative_borrow_rate: Decimal.bcs,
+            market_value: Decimal.bcs,
+            user_reward_manager_index: bcs.u64(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!BorrowRecord.cachedBcs) {
+            BorrowRecord.cachedBcs = BorrowRecord.instantiateBcs();
+        }
+        return BorrowRecord.cachedBcs;
+    }
+    static fromFields(fields) {
+        return BorrowRecord.reified().new({
+            coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
+            reserveArrayIndex: decodeFromFields('u64', fields.reserve_array_index),
+            borrowedAmount: decodeFromFields(Decimal.reified(), fields.borrowed_amount),
+            cumulativeBorrowRate: decodeFromFields(Decimal.reified(), fields.cumulative_borrow_rate),
+            marketValue: decodeFromFields(Decimal.reified(), fields.market_value),
+            userRewardManagerIndex: decodeFromFields('u64', fields.user_reward_manager_index),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isBorrowRecord(item.type)) {
+            throw new Error('not a BorrowRecord type');
+        }
+        return BorrowRecord.reified().new({
+            coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
+            reserveArrayIndex: decodeFromFieldsWithTypes('u64', item.fields.reserve_array_index),
+            borrowedAmount: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.borrowed_amount),
+            cumulativeBorrowRate: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.cumulative_borrow_rate),
+            marketValue: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.market_value),
+            userRewardManagerIndex: decodeFromFieldsWithTypes('u64', item.fields.user_reward_manager_index),
+        });
+    }
+    static fromBcs(data) {
+        return BorrowRecord.fromFields(BorrowRecord.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            coinType: this.coinType,
+            reserveArrayIndex: this.reserveArrayIndex.toString(),
+            borrowedAmount: this.borrowedAmount.toJSONField(),
+            cumulativeBorrowRate: this.cumulativeBorrowRate.toJSONField(),
+            marketValue: this.marketValue.toJSONField(),
+            userRewardManagerIndex: this.userRewardManagerIndex.toString(),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return BorrowRecord.reified().new({
+            coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
+            reserveArrayIndex: decodeFromJSONField('u64', field.reserveArrayIndex),
+            borrowedAmount: decodeFromJSONField(Decimal.reified(), field.borrowedAmount),
+            cumulativeBorrowRate: decodeFromJSONField(Decimal.reified(), field.cumulativeBorrowRate),
+            marketValue: decodeFromJSONField(Decimal.reified(), field.marketValue),
+            userRewardManagerIndex: decodeFromJSONField('u64', field.userRewardManagerIndex),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== BorrowRecord.$typeName) {
+            throw new Error(`not a BorrowRecord json object: expected '${BorrowRecord.$typeName}' but got '${json.$typeName}'`);
+        }
+        return BorrowRecord.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isBorrowRecord(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a BorrowRecord object`);
+        }
+        return BorrowRecord.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isBorrowRecord(object.type)) {
+            throw new Error(`object at id ${id} is not a BorrowRecord object`);
+        }
+        return BorrowRecord.fromBcs(object.content);
+    }
+}