@suilend/sdk 3.0.7 → 4.0.0

package/_generated/suilend/lending-market/structs.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import * as reified from "../../_framework/reified.js";
 import { TypeName } from "../../_dependencies/source/0x1/type-name/structs.js";
 import { ObjectTable } from "../../_dependencies/source/0x2/object-table/structs.js";
@@ -26,10 +17,20 @@ export function isMintEvent(type) {
     return type === `${PKG_V1}::lending_market::MintEvent`;
 }
 export class MintEvent {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::MintEvent`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = MintEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = MintEvent.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    liquidityAmount;
+    ctokenAmount;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = MintEvent.$typeName;
-        this.$isPhantom = MintEvent.$isPhantom;
         this.$fullTypeName = composeSuiType(MintEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
@@ -51,7 +52,7 @@ export class MintEvent {
             bcs: MintEvent.bcs,
             fromJSONField: (field) => MintEvent.fromJSONField(field),
             fromJSON: (json) => MintEvent.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return MintEvent.fetch(client, id); }),
+            fetch: async (client, id) => MintEvent.fetch(client, id),
             new: (fields) => {
                 return new MintEvent([], fields);
             },
@@ -120,7 +121,11 @@ export class MintEvent {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return MintEvent.reified().new({
@@ -137,29 +142,34 @@ export class MintEvent {
         }
         return MintEvent.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isMintEvent(object.type)) {
-                throw new Error(`object at id ${id} is not a MintEvent object`);
-            }
-            return MintEvent.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isMintEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a MintEvent object`);
+        }
+        return MintEvent.fromBcs(object.content);
     }
 }
-MintEvent.$typeName = `${PKG_V1}::lending_market::MintEvent`;
-MintEvent.$numTypeParams = 0;
-MintEvent.$isPhantom = [];
 /* ============================== RedeemEvent =============================== */
 export function isRedeemEvent(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::lending_market::RedeemEvent`;
 }
 export class RedeemEvent {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::RedeemEvent`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = RedeemEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = RedeemEvent.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    ctokenAmount;
+    liquidityAmount;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = RedeemEvent.$typeName;
-        this.$isPhantom = RedeemEvent.$isPhantom;
         this.$fullTypeName = composeSuiType(RedeemEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
@@ -181,7 +191,7 @@ export class RedeemEvent {
             bcs: RedeemEvent.bcs,
             fromJSONField: (field) => RedeemEvent.fromJSONField(field),
             fromJSON: (json) => RedeemEvent.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return RedeemEvent.fetch(client, id); }),
+            fetch: async (client, id) => RedeemEvent.fetch(client, id),
             new: (fields) => {
                 return new RedeemEvent([], fields);
             },
@@ -250,7 +260,11 @@ export class RedeemEvent {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return RedeemEvent.reified().new({
@@ -267,29 +281,35 @@ export class RedeemEvent {
         }
         return RedeemEvent.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isRedeemEvent(object.type)) {
-                throw new Error(`object at id ${id} is not a RedeemEvent object`);
-            }
-            return RedeemEvent.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isRedeemEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a RedeemEvent object`);
+        }
+        return RedeemEvent.fromBcs(object.content);
     }
 }
-RedeemEvent.$typeName = `${PKG_V1}::lending_market::RedeemEvent`;
-RedeemEvent.$numTypeParams = 0;
-RedeemEvent.$isPhantom = [];
 /* ============================== BorrowEvent =============================== */
 export function isBorrowEvent(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::lending_market::BorrowEvent`;
 }
 export class BorrowEvent {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::BorrowEvent`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = BorrowEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = BorrowEvent.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    obligationId;
+    liquidityAmount;
+    originationFeeAmount;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = BorrowEvent.$typeName;
-        this.$isPhantom = BorrowEvent.$isPhantom;
         this.$fullTypeName = composeSuiType(BorrowEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
@@ -312,7 +332,7 @@ export class BorrowEvent {
             bcs: BorrowEvent.bcs,
             fromJSONField: (field) => BorrowEvent.fromJSONField(field),
             fromJSON: (json) => BorrowEvent.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return BorrowEvent.fetch(client, id); }),
+            fetch: async (client, id) => BorrowEvent.fetch(client, id),
             new: (fields) => {
                 return new BorrowEvent([], fields);
             },
@@ -390,7 +410,11 @@ export class BorrowEvent {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return BorrowEvent.reified().new({
@@ -408,29 +432,36 @@ export class BorrowEvent {
         }
         return BorrowEvent.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isBorrowEvent(object.type)) {
-                throw new Error(`object at id ${id} is not a BorrowEvent object`);
-            }
-            return BorrowEvent.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isBorrowEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a BorrowEvent object`);
+        }
+        return BorrowEvent.fromBcs(object.content);
     }
 }
-BorrowEvent.$typeName = `${PKG_V1}::lending_market::BorrowEvent`;
-BorrowEvent.$numTypeParams = 0;
-BorrowEvent.$isPhantom = [];
 /* ============================== ClaimRewardEvent =============================== */
 export function isClaimRewardEvent(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::lending_market::ClaimRewardEvent`;
 }
 export class ClaimRewardEvent {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::ClaimRewardEvent`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = ClaimRewardEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = ClaimRewardEvent.$isPhantom;
+    lendingMarketId;
+    reserveId;
+    obligationId;
+    isDepositReward;
+    poolRewardId;
+    coinType;
+    liquidityAmount;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = ClaimRewardEvent.$typeName;
-        this.$isPhantom = ClaimRewardEvent.$isPhantom;
         this.$fullTypeName = composeSuiType(ClaimRewardEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
@@ -454,7 +485,7 @@ export class ClaimRewardEvent {
             bcs: ClaimRewardEvent.bcs,
             fromJSONField: (field) => ClaimRewardEvent.fromJSONField(field),
             fromJSON: (json) => ClaimRewardEvent.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return ClaimRewardEvent.fetch(client, id); }),
+            fetch: async (client, id) => ClaimRewardEvent.fetch(client, id),
             new: (fields) => {
                 return new ClaimRewardEvent([], fields);
             },
@@ -541,7 +572,11 @@ export class ClaimRewardEvent {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return ClaimRewardEvent.reified().new({
@@ -560,29 +595,34 @@ export class ClaimRewardEvent {
         }
         return ClaimRewardEvent.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isClaimRewardEvent(object.type)) {
-                throw new Error(`object at id ${id} is not a ClaimRewardEvent object`);
-            }
-            return ClaimRewardEvent.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isClaimRewardEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a ClaimRewardEvent object`);
+        }
+        return ClaimRewardEvent.fromBcs(object.content);
     }
 }
-ClaimRewardEvent.$typeName = `${PKG_V1}::lending_market::ClaimRewardEvent`;
-ClaimRewardEvent.$numTypeParams = 0;
-ClaimRewardEvent.$isPhantom = [];
 /* ============================== DepositEvent =============================== */
 export function isDepositEvent(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::lending_market::DepositEvent`;
 }
 export class DepositEvent {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::DepositEvent`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = DepositEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = DepositEvent.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    obligationId;
+    ctokenAmount;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = DepositEvent.$typeName;
-        this.$isPhantom = DepositEvent.$isPhantom;
         this.$fullTypeName = composeSuiType(DepositEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
@@ -604,7 +644,7 @@ export class DepositEvent {
             bcs: DepositEvent.bcs,
             fromJSONField: (field) => DepositEvent.fromJSONField(field),
             fromJSON: (json) => DepositEvent.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return DepositEvent.fetch(client, id); }),
+            fetch: async (client, id) => DepositEvent.fetch(client, id),
             new: (fields) => {
                 return new DepositEvent([], fields);
             },
@@ -678,7 +718,11 @@ export class DepositEvent {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return DepositEvent.reified().new({
@@ -695,29 +739,32 @@ export class DepositEvent {
         }
         return DepositEvent.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isDepositEvent(object.type)) {
-                throw new Error(`object at id ${id} is not a DepositEvent object`);
-            }
-            return DepositEvent.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isDepositEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a DepositEvent object`);
+        }
+        return DepositEvent.fromBcs(object.content);
     }
 }
-DepositEvent.$typeName = `${PKG_V1}::lending_market::DepositEvent`;
-DepositEvent.$numTypeParams = 0;
-DepositEvent.$isPhantom = [];
 /* ============================== FeeReceivers =============================== */
 export function isFeeReceivers(type) {
     type = compressSuiType(type);
     return type === `${PKG_V10}::lending_market::FeeReceivers`;
 }
 export class FeeReceivers {
+    __StructClass = true;
+    static $typeName = `${PKG_V10}::lending_market::FeeReceivers`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = FeeReceivers.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = FeeReceivers.$isPhantom;
+    receivers;
+    weights;
+    totalWeight;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = FeeReceivers.$typeName;
-        this.$isPhantom = FeeReceivers.$isPhantom;
         this.$fullTypeName = composeSuiType(FeeReceivers.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.receivers = fields.receivers;
@@ -737,7 +784,7 @@ export class FeeReceivers {
             bcs: FeeReceivers.bcs,
             fromJSONField: (field) => FeeReceivers.fromJSONField(field),
             fromJSON: (json) => FeeReceivers.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return FeeReceivers.fetch(client, id); }),
+            fetch: async (client, id) => FeeReceivers.fetch(client, id),
             new: (fields) => {
                 return new FeeReceivers([], fields);
             },
@@ -793,7 +840,11 @@ export class FeeReceivers {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return FeeReceivers.reified().new({
@@ -808,29 +859,30 @@ export class FeeReceivers {
         }
         return FeeReceivers.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isFeeReceivers(object.type)) {
-                throw new Error(`object at id ${id} is not a FeeReceivers object`);
-            }
-            return FeeReceivers.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isFeeReceivers(object.type)) {
+            throw new Error(`object at id ${id} is not a FeeReceivers object`);
+        }
+        return FeeReceivers.fromBcs(object.content);
     }
 }
-FeeReceivers.$typeName = `${PKG_V10}::lending_market::FeeReceivers`;
-FeeReceivers.$numTypeParams = 0;
-FeeReceivers.$isPhantom = [];
 /* ============================== FeeReceiversKey =============================== */
 export function isFeeReceiversKey(type) {
     type = compressSuiType(type);
     return type === `${PKG_V10}::lending_market::FeeReceiversKey`;
 }
 export class FeeReceiversKey {
+    __StructClass = true;
+    static $typeName = `${PKG_V10}::lending_market::FeeReceiversKey`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = FeeReceiversKey.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = FeeReceiversKey.$isPhantom;
+    dummyField;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = FeeReceiversKey.$typeName;
-        this.$isPhantom = FeeReceiversKey.$isPhantom;
         this.$fullTypeName = composeSuiType(FeeReceiversKey.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.dummyField = fields.dummyField;
@@ -848,7 +900,7 @@ export class FeeReceiversKey {
             bcs: FeeReceiversKey.bcs,
             fromJSONField: (field) => FeeReceiversKey.fromJSONField(field),
             fromJSON: (json) => FeeReceiversKey.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return FeeReceiversKey.fetch(client, id); }),
+            fetch: async (client, id) => FeeReceiversKey.fetch(client, id),
             new: (fields) => {
                 return new FeeReceiversKey([], fields);
             },
@@ -891,7 +943,11 @@ export class FeeReceiversKey {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return FeeReceiversKey.reified().new({
@@ -904,29 +960,34 @@ export class FeeReceiversKey {
         }
         return FeeReceiversKey.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isFeeReceiversKey(object.type)) {
-                throw new Error(`object at id ${id} is not a FeeReceiversKey object`);
-            }
-            return FeeReceiversKey.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isFeeReceiversKey(object.type)) {
+            throw new Error(`object at id ${id} is not a FeeReceiversKey object`);
+        }
+        return FeeReceiversKey.fromBcs(object.content);
     }
 }
-FeeReceiversKey.$typeName = `${PKG_V10}::lending_market::FeeReceiversKey`;
-FeeReceiversKey.$numTypeParams = 0;
-FeeReceiversKey.$isPhantom = [];
 /* ============================== ForgiveEvent =============================== */
 export function isForgiveEvent(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::lending_market::ForgiveEvent`;
 }
 export class ForgiveEvent {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::ForgiveEvent`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = ForgiveEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = ForgiveEvent.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    obligationId;
+    liquidityAmount;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = ForgiveEvent.$typeName;
-        this.$isPhantom = ForgiveEvent.$isPhantom;
         this.$fullTypeName = composeSuiType(ForgiveEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
@@ -948,7 +1009,7 @@ export class ForgiveEvent {
             bcs: ForgiveEvent.bcs,
             fromJSONField: (field) => ForgiveEvent.fromJSONField(field),
             fromJSON: (json) => ForgiveEvent.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return ForgiveEvent.fetch(client, id); }),
+            fetch: async (client, id) => ForgiveEvent.fetch(client, id),
             new: (fields) => {
                 return new ForgiveEvent([], fields);
             },
@@ -1022,7 +1083,11 @@ export class ForgiveEvent {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return ForgiveEvent.reified().new({
@@ -1039,29 +1104,30 @@ export class ForgiveEvent {
         }
         return ForgiveEvent.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isForgiveEvent(object.type)) {
-                throw new Error(`object at id ${id} is not a ForgiveEvent object`);
-            }
-            return ForgiveEvent.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isForgiveEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a ForgiveEvent object`);
+        }
+        return ForgiveEvent.fromBcs(object.content);
     }
 }
-ForgiveEvent.$typeName = `${PKG_V1}::lending_market::ForgiveEvent`;
-ForgiveEvent.$numTypeParams = 0;
-ForgiveEvent.$isPhantom = [];
 /* ============================== LENDING_MARKET =============================== */
 export function isLENDING_MARKET(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::lending_market::LENDING_MARKET`;
 }
 export class LENDING_MARKET {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::LENDING_MARKET`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = LENDING_MARKET.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = LENDING_MARKET.$isPhantom;
+    dummyField;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = LENDING_MARKET.$typeName;
-        this.$isPhantom = LENDING_MARKET.$isPhantom;
         this.$fullTypeName = composeSuiType(LENDING_MARKET.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.dummyField = fields.dummyField;
@@ -1079,7 +1145,7 @@ export class LENDING_MARKET {
             bcs: LENDING_MARKET.bcs,
             fromJSONField: (field) => LENDING_MARKET.fromJSONField(field),
             fromJSON: (json) => LENDING_MARKET.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return LENDING_MARKET.fetch(client, id); }),
+            fetch: async (client, id) => LENDING_MARKET.fetch(client, id),
             new: (fields) => {
                 return new LENDING_MARKET([], fields);
             },
@@ -1122,7 +1188,11 @@ export class LENDING_MARKET {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return LENDING_MARKET.reified().new({
@@ -1135,29 +1205,37 @@ export class LENDING_MARKET {
         }
         return LENDING_MARKET.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isLENDING_MARKET(object.type)) {
-                throw new Error(`object at id ${id} is not a LENDING_MARKET object`);
-            }
-            return LENDING_MARKET.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isLENDING_MARKET(object.type)) {
+            throw new Error(`object at id ${id} is not a LENDING_MARKET object`);
+        }
+        return LENDING_MARKET.fromBcs(object.content);
     }
 }
-LENDING_MARKET.$typeName = `${PKG_V1}::lending_market::LENDING_MARKET`;
-LENDING_MARKET.$numTypeParams = 0;
-LENDING_MARKET.$isPhantom = [];
 /* ============================== LendingMarket =============================== */
 export function isLendingMarket(type) {
     type = compressSuiType(type);
     return type.startsWith(`${PKG_V1}::lending_market::LendingMarket` + "<");
 }
 export class LendingMarket {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::LendingMarket`;
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = LendingMarket.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = LendingMarket.$isPhantom;
+    id;
+    version;
+    reserves;
+    obligations;
+    rateLimiter;
+    feeReceiver;
+    badDebtUsd;
+    badDebtLimitUsd;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = LendingMarket.$typeName;
-        this.$isPhantom = LendingMarket.$isPhantom;
         this.$fullTypeName = composeSuiType(LendingMarket.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.id = fields.id;
@@ -1182,7 +1260,7 @@ export class LendingMarket {
             bcs: LendingMarket.bcs,
             fromJSONField: (field) => LendingMarket.fromJSONField(P, field),
             fromJSON: (json) => LendingMarket.fromJSON(P, json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return LendingMarket.fetch(client, P, id); }),
+            fetch: async (client, id) => LendingMarket.fetch(client, P, id),
             new: (fields) => {
                 return new LendingMarket([extractType(P)], fields);
             },
@@ -1259,7 +1337,11 @@ export class LendingMarket {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(typeArg, field) {
         return LendingMarket.reified(typeArg).new({
@@ -1280,29 +1362,31 @@ export class LendingMarket {
         assertReifiedTypeArgsMatch(composeSuiType(LendingMarket.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
         return LendingMarket.fromJSONField(typeArg, json);
     }
-    static fetch(client, typeArg, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isLendingMarket(object.type)) {
-                throw new Error(`object at id ${id} is not a LendingMarket object`);
-            }
-            return LendingMarket.fromBcs(typeArg, object.content);
-        });
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isLendingMarket(object.type)) {
+            throw new Error(`object at id ${id} is not a LendingMarket object`);
+        }
+        return LendingMarket.fromBcs(typeArg, object.content);
     }
 }
-LendingMarket.$typeName = `${PKG_V1}::lending_market::LendingMarket`;
-LendingMarket.$numTypeParams = 1;
-LendingMarket.$isPhantom = [true];
 /* ============================== LendingMarketOwnerCap =============================== */
 export function isLendingMarketOwnerCap(type) {
     type = compressSuiType(type);
     return type.startsWith(`${PKG_V1}::lending_market::LendingMarketOwnerCap` + "<");
 }
 export class LendingMarketOwnerCap {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::LendingMarketOwnerCap`;
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = LendingMarketOwnerCap.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = LendingMarketOwnerCap.$isPhantom;
+    id;
+    lendingMarketId;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = LendingMarketOwnerCap.$typeName;
-        this.$isPhantom = LendingMarketOwnerCap.$isPhantom;
         this.$fullTypeName = composeSuiType(LendingMarketOwnerCap.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.id = fields.id;
@@ -1321,7 +1405,7 @@ export class LendingMarketOwnerCap {
             bcs: LendingMarketOwnerCap.bcs,
             fromJSONField: (field) => LendingMarketOwnerCap.fromJSONField(P, field),
             fromJSON: (json) => LendingMarketOwnerCap.fromJSON(P, json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return LendingMarketOwnerCap.fetch(client, P, id); }),
+            fetch: async (client, id) => LendingMarketOwnerCap.fetch(client, P, id),
             new: (fields) => {
                 return new LendingMarketOwnerCap([extractType(P)], fields);
             },
@@ -1369,7 +1453,11 @@ export class LendingMarketOwnerCap {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(typeArg, field) {
         return LendingMarketOwnerCap.reified(typeArg).new({
@@ -1384,29 +1472,39 @@ export class LendingMarketOwnerCap {
         assertReifiedTypeArgsMatch(composeSuiType(LendingMarketOwnerCap.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
         return LendingMarketOwnerCap.fromJSONField(typeArg, json);
     }
-    static fetch(client, typeArg, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isLendingMarketOwnerCap(object.type)) {
-                throw new Error(`object at id ${id} is not a LendingMarketOwnerCap object`);
-            }
-            return LendingMarketOwnerCap.fromBcs(typeArg, object.content);
-        });
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isLendingMarketOwnerCap(object.type)) {
+            throw new Error(`object at id ${id} is not a LendingMarketOwnerCap object`);
+        }
+        return LendingMarketOwnerCap.fromBcs(typeArg, object.content);
     }
 }
-LendingMarketOwnerCap.$typeName = `${PKG_V1}::lending_market::LendingMarketOwnerCap`;
-LendingMarketOwnerCap.$numTypeParams = 1;
-LendingMarketOwnerCap.$isPhantom = [true];
 /* ============================== LiquidateEvent =============================== */
 export function isLiquidateEvent(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::lending_market::LiquidateEvent`;
 }
 export class LiquidateEvent {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::LiquidateEvent`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = LiquidateEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = LiquidateEvent.$isPhantom;
+    lendingMarketId;
+    repayReserveId;
+    withdrawReserveId;
+    obligationId;
+    repayCoinType;
+    withdrawCoinType;
+    repayAmount;
+    withdrawAmount;
+    protocolFeeAmount;
+    liquidatorBonusAmount;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = LiquidateEvent.$typeName;
-        this.$isPhantom = LiquidateEvent.$isPhantom;
         this.$fullTypeName = composeSuiType(LiquidateEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
@@ -1433,7 +1531,7 @@ export class LiquidateEvent {
             bcs: LiquidateEvent.bcs,
             fromJSONField: (field) => LiquidateEvent.fromJSONField(field),
             fromJSON: (json) => LiquidateEvent.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return LiquidateEvent.fetch(client, id); }),
+            fetch: async (client, id) => LiquidateEvent.fetch(client, id),
             new: (fields) => {
                 return new LiquidateEvent([], fields);
             },
@@ -1532,7 +1630,11 @@ export class LiquidateEvent {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return LiquidateEvent.reified().new({
@@ -1554,29 +1656,31 @@ export class LiquidateEvent {
         }
         return LiquidateEvent.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isLiquidateEvent(object.type)) {
-                throw new Error(`object at id ${id} is not a LiquidateEvent object`);
-            }
-            return LiquidateEvent.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isLiquidateEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a LiquidateEvent object`);
+        }
+        return LiquidateEvent.fromBcs(object.content);
     }
 }
-LiquidateEvent.$typeName = `${PKG_V1}::lending_market::LiquidateEvent`;
-LiquidateEvent.$numTypeParams = 0;
-LiquidateEvent.$isPhantom = [];
 /* ============================== ObligationOwnerCap =============================== */
 export function isObligationOwnerCap(type) {
     type = compressSuiType(type);
     return type.startsWith(`${PKG_V1}::lending_market::ObligationOwnerCap` + "<");
 }
 export class ObligationOwnerCap {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::ObligationOwnerCap`;
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = ObligationOwnerCap.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = ObligationOwnerCap.$isPhantom;
+    id;
+    obligationId;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = ObligationOwnerCap.$typeName;
-        this.$isPhantom = ObligationOwnerCap.$isPhantom;
         this.$fullTypeName = composeSuiType(ObligationOwnerCap.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.id = fields.id;
@@ -1595,7 +1699,7 @@ export class ObligationOwnerCap {
             bcs: ObligationOwnerCap.bcs,
             fromJSONField: (field) => ObligationOwnerCap.fromJSONField(P, field),
             fromJSON: (json) => ObligationOwnerCap.fromJSON(P, json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return ObligationOwnerCap.fetch(client, P, id); }),
+            fetch: async (client, id) => ObligationOwnerCap.fetch(client, P, id),
             new: (fields) => {
                 return new ObligationOwnerCap([extractType(P)], fields);
             },
@@ -1643,7 +1747,11 @@ export class ObligationOwnerCap {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(typeArg, field) {
         return ObligationOwnerCap.reified(typeArg).new({
@@ -1658,29 +1766,30 @@ export class ObligationOwnerCap {
         assertReifiedTypeArgsMatch(composeSuiType(ObligationOwnerCap.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
         return ObligationOwnerCap.fromJSONField(typeArg, json);
     }
-    static fetch(client, typeArg, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isObligationOwnerCap(object.type)) {
-                throw new Error(`object at id ${id} is not a ObligationOwnerCap object`);
-            }
-            return ObligationOwnerCap.fromBcs(typeArg, object.content);
-        });
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isObligationOwnerCap(object.type)) {
+            throw new Error(`object at id ${id} is not a ObligationOwnerCap object`);
+        }
+        return ObligationOwnerCap.fromBcs(typeArg, object.content);
     }
 }
-ObligationOwnerCap.$typeName = `${PKG_V1}::lending_market::ObligationOwnerCap`;
-ObligationOwnerCap.$numTypeParams = 1;
-ObligationOwnerCap.$isPhantom = [true];
 /* ============================== RateLimiterExemption =============================== */
 export function isRateLimiterExemption(type) {
     type = compressSuiType(type);
     return type.startsWith(`${PKG_V1}::lending_market::RateLimiterExemption` + "<");
 }
 export class RateLimiterExemption {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::RateLimiterExemption`;
+    static $numTypeParams = 2;
+    static $isPhantom = [true, true];
+    $typeName = RateLimiterExemption.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = RateLimiterExemption.$isPhantom;
+    amount;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = RateLimiterExemption.$typeName;
-        this.$isPhantom = RateLimiterExemption.$isPhantom;
         this.$fullTypeName = composeSuiType(RateLimiterExemption.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.amount = fields.amount;
@@ -1698,7 +1807,7 @@ export class RateLimiterExemption {
             bcs: RateLimiterExemption.bcs,
             fromJSONField: (field) => RateLimiterExemption.fromJSONField([P, T], field),
             fromJSON: (json) => RateLimiterExemption.fromJSON([P, T], json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return RateLimiterExemption.fetch(client, [P, T], id); }),
+            fetch: async (client, id) => RateLimiterExemption.fetch(client, [P, T], id),
             new: (fields) => {
                 return new RateLimiterExemption([extractType(P), extractType(T)], fields);
             },
@@ -1742,7 +1851,11 @@ export class RateLimiterExemption {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(typeArgs, field) {
         return RateLimiterExemption.reified(typeArgs[0], typeArgs[1]).new({
@@ -1756,29 +1869,34 @@ export class RateLimiterExemption {
         assertReifiedTypeArgsMatch(composeSuiType(RateLimiterExemption.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs);
         return RateLimiterExemption.fromJSONField(typeArgs, json);
     }
-    static fetch(client, typeArgs, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isRateLimiterExemption(object.type)) {
-                throw new Error(`object at id ${id} is not a RateLimiterExemption object`);
-            }
-            return RateLimiterExemption.fromBcs(typeArgs, object.content);
-        });
+    static async fetch(client, typeArgs, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isRateLimiterExemption(object.type)) {
+            throw new Error(`object at id ${id} is not a RateLimiterExemption object`);
+        }
+        return RateLimiterExemption.fromBcs(typeArgs, object.content);
     }
 }
-RateLimiterExemption.$typeName = `${PKG_V1}::lending_market::RateLimiterExemption`;
-RateLimiterExemption.$numTypeParams = 2;
-RateLimiterExemption.$isPhantom = [true, true];
 /* ============================== RepayEvent =============================== */
 export function isRepayEvent(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::lending_market::RepayEvent`;
 }
 export class RepayEvent {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::RepayEvent`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = RepayEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = RepayEvent.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    obligationId;
+    liquidityAmount;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = RepayEvent.$typeName;
-        this.$isPhantom = RepayEvent.$isPhantom;
         this.$fullTypeName = composeSuiType(RepayEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
@@ -1800,7 +1918,7 @@ export class RepayEvent {
             bcs: RepayEvent.bcs,
             fromJSONField: (field) => RepayEvent.fromJSONField(field),
             fromJSON: (json) => RepayEvent.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return RepayEvent.fetch(client, id); }),
+            fetch: async (client, id) => RepayEvent.fetch(client, id),
             new: (fields) => {
                 return new RepayEvent([], fields);
             },
@@ -1874,7 +1992,11 @@ export class RepayEvent {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return RepayEvent.reified().new({
@@ -1891,29 +2013,34 @@ export class RepayEvent {
         }
         return RepayEvent.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isRepayEvent(object.type)) {
-                throw new Error(`object at id ${id} is not a RepayEvent object`);
-            }
-            return RepayEvent.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isRepayEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a RepayEvent object`);
+        }
+        return RepayEvent.fromBcs(object.content);
     }
 }
-RepayEvent.$typeName = `${PKG_V1}::lending_market::RepayEvent`;
-RepayEvent.$numTypeParams = 0;
-RepayEvent.$isPhantom = [];
 /* ============================== WithdrawEvent =============================== */
 export function isWithdrawEvent(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::lending_market::WithdrawEvent`;
 }
 export class WithdrawEvent {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::lending_market::WithdrawEvent`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = WithdrawEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = WithdrawEvent.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    obligationId;
+    ctokenAmount;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = WithdrawEvent.$typeName;
-        this.$isPhantom = WithdrawEvent.$isPhantom;
         this.$fullTypeName = composeSuiType(WithdrawEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
@@ -1935,7 +2062,7 @@ export class WithdrawEvent {
             bcs: WithdrawEvent.bcs,
             fromJSONField: (field) => WithdrawEvent.fromJSONField(field),
             fromJSON: (json) => WithdrawEvent.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return WithdrawEvent.fetch(client, id); }),
+            fetch: async (client, id) => WithdrawEvent.fetch(client, id),
             new: (fields) => {
                 return new WithdrawEvent([], fields);
             },
@@ -2009,7 +2136,11 @@ export class WithdrawEvent {
         };
     }
     toJSON() {
-        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
     }
     static fromJSONField(field) {
         return WithdrawEvent.reified().new({
@@ -2026,16 +2157,11 @@ export class WithdrawEvent {
         }
         return WithdrawEvent.fromJSONField(json);
     }
-    static fetch(client, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { object } = yield client.getObject({ objectId: id, include: { content: true } });
-            if (!isWithdrawEvent(object.type)) {
-                throw new Error(`object at id ${id} is not a WithdrawEvent object`);
-            }
-            return WithdrawEvent.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isWithdrawEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a WithdrawEvent object`);
+        }
+        return WithdrawEvent.fromBcs(object.content);
     }
 }
-WithdrawEvent.$typeName = `${PKG_V1}::lending_market::WithdrawEvent`;
-WithdrawEvent.$numTypeParams = 0;
-WithdrawEvent.$isPhantom = [];