@suilend/sdk 3.0.8 → 4.0.0

package/_generated/suilend/reserve/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 { Balance, Supply, } from "../../_dependencies/source/0x2/balance/structs.js";
@@ -27,10 +18,16 @@ export function isBalanceKey(type) {
     return type === `${PKG_V1}::reserve::BalanceKey`;
 }
 export class BalanceKey {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::reserve::BalanceKey`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = BalanceKey.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = BalanceKey.$isPhantom;
+    dummyField;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = BalanceKey.$typeName;
-        this.$isPhantom = BalanceKey.$isPhantom;
         this.$fullTypeName = composeSuiType(BalanceKey.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.dummyField = fields.dummyField;
@@ -48,7 +45,7 @@ export class BalanceKey {
             bcs: BalanceKey.bcs,
             fromJSONField: (field) => BalanceKey.fromJSONField(field),
             fromJSON: (json) => BalanceKey.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return BalanceKey.fetch(client, id); }),
+            fetch: async (client, id) => BalanceKey.fetch(client, id),
             new: (fields) => {
                 return new BalanceKey([], fields);
             },
@@ -91,7 +88,11 @@ export class BalanceKey {
         };
     }
     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 BalanceKey.reified().new({
@@ -104,29 +105,34 @@ export class BalanceKey {
         }
         return BalanceKey.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 (!isBalanceKey(object.type)) {
-                throw new Error(`object at id ${id} is not a BalanceKey object`);
-            }
-            return BalanceKey.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isBalanceKey(object.type)) {
+            throw new Error(`object at id ${id} is not a BalanceKey object`);
+        }
+        return BalanceKey.fromBcs(object.content);
     }
 }
-BalanceKey.$typeName = `${PKG_V1}::reserve::BalanceKey`;
-BalanceKey.$numTypeParams = 0;
-BalanceKey.$isPhantom = [];
 /* ============================== Balances =============================== */
 export function isBalances(type) {
     type = compressSuiType(type);
     return type.startsWith(`${PKG_V1}::reserve::Balances` + "<");
 }
 export class Balances {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::reserve::Balances`;
+    static $numTypeParams = 2;
+    static $isPhantom = [true, true];
+    $typeName = Balances.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = Balances.$isPhantom;
+    availableAmount;
+    ctokenSupply;
+    fees;
+    ctokenFees;
+    depositedCtokens;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = Balances.$typeName;
-        this.$isPhantom = Balances.$isPhantom;
         this.$fullTypeName = composeSuiType(Balances.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.availableAmount = fields.availableAmount;
@@ -148,7 +154,7 @@ export class Balances {
             bcs: Balances.bcs,
             fromJSONField: (field) => Balances.fromJSONField([P, T], field),
             fromJSON: (json) => Balances.fromJSON([P, T], json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return Balances.fetch(client, [P, T], id); }),
+            fetch: async (client, id) => Balances.fetch(client, [P, T], id),
             new: (fields) => {
                 return new Balances([extractType(P), extractType(T)], fields);
             },
@@ -208,7 +214,11 @@ export class Balances {
         };
     }
     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 Balances.reified(typeArgs[0], typeArgs[1]).new({
@@ -226,29 +236,30 @@ export class Balances {
         assertReifiedTypeArgsMatch(composeSuiType(Balances.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs);
         return Balances.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 (!isBalances(object.type)) {
-                throw new Error(`object at id ${id} is not a Balances object`);
-            }
-            return Balances.fromBcs(typeArgs, object.content);
-        });
+    static async fetch(client, typeArgs, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isBalances(object.type)) {
+            throw new Error(`object at id ${id} is not a Balances object`);
+        }
+        return Balances.fromBcs(typeArgs, object.content);
     }
 }
-Balances.$typeName = `${PKG_V1}::reserve::Balances`;
-Balances.$numTypeParams = 2;
-Balances.$isPhantom = [true, true];
 /* ============================== CToken =============================== */
 export function isCToken(type) {
     type = compressSuiType(type);
     return type.startsWith(`${PKG_V1}::reserve::CToken` + "<");
 }
 export class CToken {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::reserve::CToken`;
+    static $numTypeParams = 2;
+    static $isPhantom = [true, true];
+    $typeName = CToken.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = CToken.$isPhantom;
+    dummyField;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = CToken.$typeName;
-        this.$isPhantom = CToken.$isPhantom;
         this.$fullTypeName = composeSuiType(CToken.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.dummyField = fields.dummyField;
@@ -266,7 +277,7 @@ export class CToken {
             bcs: CToken.bcs,
             fromJSONField: (field) => CToken.fromJSONField([P, T], field),
             fromJSON: (json) => CToken.fromJSON([P, T], json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return CToken.fetch(client, [P, T], id); }),
+            fetch: async (client, id) => CToken.fetch(client, [P, T], id),
             new: (fields) => {
                 return new CToken([extractType(P), extractType(T)], fields);
             },
@@ -310,7 +321,11 @@ export class CToken {
         };
     }
     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 CToken.reified(typeArgs[0], typeArgs[1]).new({
@@ -324,29 +339,33 @@ export class CToken {
         assertReifiedTypeArgsMatch(composeSuiType(CToken.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs);
         return CToken.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 (!isCToken(object.type)) {
-                throw new Error(`object at id ${id} is not a CToken object`);
-            }
-            return CToken.fromBcs(typeArgs, object.content);
-        });
+    static async fetch(client, typeArgs, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isCToken(object.type)) {
+            throw new Error(`object at id ${id} is not a CToken object`);
+        }
+        return CToken.fromBcs(typeArgs, object.content);
     }
 }
-CToken.$typeName = `${PKG_V1}::reserve::CToken`;
-CToken.$numTypeParams = 2;
-CToken.$isPhantom = [true, true];
 /* ============================== ClaimStakingRewardsEvent =============================== */
 export function isClaimStakingRewardsEvent(type) {
     type = compressSuiType(type);
     return type === `${PKG_V8}::reserve::ClaimStakingRewardsEvent`;
 }
 export class ClaimStakingRewardsEvent {
+    __StructClass = true;
+    static $typeName = `${PKG_V8}::reserve::ClaimStakingRewardsEvent`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = ClaimStakingRewardsEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = ClaimStakingRewardsEvent.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    amount;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = ClaimStakingRewardsEvent.$typeName;
-        this.$isPhantom = ClaimStakingRewardsEvent.$isPhantom;
         this.$fullTypeName = composeSuiType(ClaimStakingRewardsEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
@@ -367,7 +386,7 @@ export class ClaimStakingRewardsEvent {
             bcs: ClaimStakingRewardsEvent.bcs,
             fromJSONField: (field) => ClaimStakingRewardsEvent.fromJSONField(field),
             fromJSON: (json) => ClaimStakingRewardsEvent.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return ClaimStakingRewardsEvent.fetch(client, id); }),
+            fetch: async (client, id) => ClaimStakingRewardsEvent.fetch(client, id),
             new: (fields) => {
                 return new ClaimStakingRewardsEvent([], fields);
             },
@@ -432,7 +451,11 @@ export class ClaimStakingRewardsEvent {
         };
     }
     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 ClaimStakingRewardsEvent.reified().new({
@@ -448,29 +471,43 @@ export class ClaimStakingRewardsEvent {
         }
         return ClaimStakingRewardsEvent.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 (!isClaimStakingRewardsEvent(object.type)) {
-                throw new Error(`object at id ${id} is not a ClaimStakingRewardsEvent object`);
-            }
-            return ClaimStakingRewardsEvent.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isClaimStakingRewardsEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a ClaimStakingRewardsEvent object`);
+        }
+        return ClaimStakingRewardsEvent.fromBcs(object.content);
     }
 }
-ClaimStakingRewardsEvent.$typeName = `${PKG_V8}::reserve::ClaimStakingRewardsEvent`;
-ClaimStakingRewardsEvent.$numTypeParams = 0;
-ClaimStakingRewardsEvent.$isPhantom = [];
 /* ============================== InterestUpdateEvent =============================== */
 export function isInterestUpdateEvent(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::reserve::InterestUpdateEvent`;
 }
 export class InterestUpdateEvent {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::reserve::InterestUpdateEvent`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = InterestUpdateEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = InterestUpdateEvent.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    cumulativeBorrowRate;
+    availableAmount;
+    borrowedAmount;
+    unclaimedSpreadFees;
+    ctokenSupply;
+    borrowInterestPaid;
+    spreadFee;
+    supplyInterestEarned;
+    borrowInterestPaidUsdEstimate;
+    protocolFeeUsdEstimate;
+    supplyInterestEarnedUsdEstimate;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = InterestUpdateEvent.$typeName;
-        this.$isPhantom = InterestUpdateEvent.$isPhantom;
         this.$fullTypeName = composeSuiType(InterestUpdateEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
@@ -502,7 +539,7 @@ export class InterestUpdateEvent {
             bcs: InterestUpdateEvent.bcs,
             fromJSONField: (field) => InterestUpdateEvent.fromJSONField(field),
             fromJSON: (json) => InterestUpdateEvent.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return InterestUpdateEvent.fetch(client, id); }),
+            fetch: async (client, id) => InterestUpdateEvent.fetch(client, id),
             new: (fields) => {
                 return new InterestUpdateEvent([], fields);
             },
@@ -607,7 +644,11 @@ export class InterestUpdateEvent {
         };
     }
     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 InterestUpdateEvent.reified().new({
@@ -633,29 +674,31 @@ export class InterestUpdateEvent {
         }
         return InterestUpdateEvent.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 (!isInterestUpdateEvent(object.type)) {
-                throw new Error(`object at id ${id} is not a InterestUpdateEvent object`);
-            }
-            return InterestUpdateEvent.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isInterestUpdateEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a InterestUpdateEvent object`);
+        }
+        return InterestUpdateEvent.fromBcs(object.content);
     }
 }
-InterestUpdateEvent.$typeName = `${PKG_V1}::reserve::InterestUpdateEvent`;
-InterestUpdateEvent.$numTypeParams = 0;
-InterestUpdateEvent.$isPhantom = [];
 /* ============================== LiquidityRequest =============================== */
 export function isLiquidityRequest(type) {
     type = compressSuiType(type);
     return type.startsWith(`${PKG_V8}::reserve::LiquidityRequest` + "<");
 }
 export class LiquidityRequest {
+    __StructClass = true;
+    static $typeName = `${PKG_V8}::reserve::LiquidityRequest`;
+    static $numTypeParams = 2;
+    static $isPhantom = [true, true];
+    $typeName = LiquidityRequest.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = LiquidityRequest.$isPhantom;
+    amount;
+    fee;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = LiquidityRequest.$typeName;
-        this.$isPhantom = LiquidityRequest.$isPhantom;
         this.$fullTypeName = composeSuiType(LiquidityRequest.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.amount = fields.amount;
@@ -674,7 +717,7 @@ export class LiquidityRequest {
             bcs: LiquidityRequest.bcs,
             fromJSONField: (field) => LiquidityRequest.fromJSONField([P, T], field),
             fromJSON: (json) => LiquidityRequest.fromJSON([P, T], json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return LiquidityRequest.fetch(client, [P, T], id); }),
+            fetch: async (client, id) => LiquidityRequest.fetch(client, [P, T], id),
             new: (fields) => {
                 return new LiquidityRequest([extractType(P), extractType(T)], fields);
             },
@@ -722,7 +765,11 @@ export class LiquidityRequest {
         };
     }
     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 LiquidityRequest.reified(typeArgs[0], typeArgs[1]).new({
@@ -737,29 +784,48 @@ export class LiquidityRequest {
         assertReifiedTypeArgsMatch(composeSuiType(LiquidityRequest.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs);
         return LiquidityRequest.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 (!isLiquidityRequest(object.type)) {
-                throw new Error(`object at id ${id} is not a LiquidityRequest object`);
-            }
-            return LiquidityRequest.fromBcs(typeArgs, object.content);
-        });
+    static async fetch(client, typeArgs, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isLiquidityRequest(object.type)) {
+            throw new Error(`object at id ${id} is not a LiquidityRequest object`);
+        }
+        return LiquidityRequest.fromBcs(typeArgs, object.content);
     }
 }
-LiquidityRequest.$typeName = `${PKG_V8}::reserve::LiquidityRequest`;
-LiquidityRequest.$numTypeParams = 2;
-LiquidityRequest.$isPhantom = [true, true];
 /* ============================== Reserve =============================== */
 export function isReserve(type) {
     type = compressSuiType(type);
     return type.startsWith(`${PKG_V1}::reserve::Reserve` + "<");
 }
 export class Reserve {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::reserve::Reserve`;
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = Reserve.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = Reserve.$isPhantom;
+    id;
+    lendingMarketId;
+    arrayIndex;
+    coinType;
+    config;
+    mintDecimals;
+    priceIdentifier;
+    price;
+    smoothedPrice;
+    priceLastUpdateTimestampS;
+    availableAmount;
+    ctokenSupply;
+    borrowedAmount;
+    cumulativeBorrowRate;
+    interestLastUpdateTimestampS;
+    unclaimedSpreadFees;
+    attributedBorrowValue;
+    depositsPoolRewardManager;
+    borrowsPoolRewardManager;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = Reserve.$typeName;
-        this.$isPhantom = Reserve.$isPhantom;
         this.$fullTypeName = composeSuiType(Reserve.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.id = fields.id;
@@ -795,7 +861,7 @@ export class Reserve {
             bcs: Reserve.bcs,
             fromJSONField: (field) => Reserve.fromJSONField(P, field),
             fromJSON: (json) => Reserve.fromJSON(P, json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return Reserve.fetch(client, P, id); }),
+            fetch: async (client, id) => Reserve.fetch(client, P, id),
             new: (fields) => {
                 return new Reserve([extractType(P)], fields);
             },
@@ -911,7 +977,11 @@ export class Reserve {
         };
     }
     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 Reserve.reified(typeArg).new({
@@ -943,29 +1013,45 @@ export class Reserve {
         assertReifiedTypeArgsMatch(composeSuiType(Reserve.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
         return Reserve.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 (!isReserve(object.type)) {
-                throw new Error(`object at id ${id} is not a Reserve object`);
-            }
-            return Reserve.fromBcs(typeArg, object.content);
-        });
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isReserve(object.type)) {
+            throw new Error(`object at id ${id} is not a Reserve object`);
+        }
+        return Reserve.fromBcs(typeArg, object.content);
     }
 }
-Reserve.$typeName = `${PKG_V1}::reserve::Reserve`;
-Reserve.$numTypeParams = 1;
-Reserve.$isPhantom = [true];
 /* ============================== ReserveAssetDataEvent =============================== */
 export function isReserveAssetDataEvent(type) {
     type = compressSuiType(type);
     return type === `${PKG_V1}::reserve::ReserveAssetDataEvent`;
 }
 export class ReserveAssetDataEvent {
+    __StructClass = true;
+    static $typeName = `${PKG_V1}::reserve::ReserveAssetDataEvent`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = ReserveAssetDataEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = ReserveAssetDataEvent.$isPhantom;
+    lendingMarketId;
+    coinType;
+    reserveId;
+    availableAmount;
+    supplyAmount;
+    borrowedAmount;
+    availableAmountUsdEstimate;
+    supplyAmountUsdEstimate;
+    borrowedAmountUsdEstimate;
+    borrowApr;
+    supplyApr;
+    ctokenSupply;
+    cumulativeBorrowRate;
+    price;
+    smoothedPrice;
+    priceLastUpdateTimestampS;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = ReserveAssetDataEvent.$typeName;
-        this.$isPhantom = ReserveAssetDataEvent.$isPhantom;
         this.$fullTypeName = composeSuiType(ReserveAssetDataEvent.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.lendingMarketId = fields.lendingMarketId;
@@ -998,7 +1084,7 @@ export class ReserveAssetDataEvent {
             bcs: ReserveAssetDataEvent.bcs,
             fromJSONField: (field) => ReserveAssetDataEvent.fromJSONField(field),
             fromJSON: (json) => ReserveAssetDataEvent.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return ReserveAssetDataEvent.fetch(client, id); }),
+            fetch: async (client, id) => ReserveAssetDataEvent.fetch(client, id),
             new: (fields) => {
                 return new ReserveAssetDataEvent([], fields);
             },
@@ -1111,7 +1197,11 @@ export class ReserveAssetDataEvent {
         };
     }
     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 ReserveAssetDataEvent.reified().new({
@@ -1139,29 +1229,30 @@ export class ReserveAssetDataEvent {
         }
         return ReserveAssetDataEvent.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 (!isReserveAssetDataEvent(object.type)) {
-                throw new Error(`object at id ${id} is not a ReserveAssetDataEvent object`);
-            }
-            return ReserveAssetDataEvent.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isReserveAssetDataEvent(object.type)) {
+            throw new Error(`object at id ${id} is not a ReserveAssetDataEvent object`);
+        }
+        return ReserveAssetDataEvent.fromBcs(object.content);
     }
 }
-ReserveAssetDataEvent.$typeName = `${PKG_V1}::reserve::ReserveAssetDataEvent`;
-ReserveAssetDataEvent.$numTypeParams = 0;
-ReserveAssetDataEvent.$isPhantom = [];
 /* ============================== StakerKey =============================== */
 export function isStakerKey(type) {
     type = compressSuiType(type);
     return type === `${PKG_V8}::reserve::StakerKey`;
 }
 export class StakerKey {
+    __StructClass = true;
+    static $typeName = `${PKG_V8}::reserve::StakerKey`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = StakerKey.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = StakerKey.$isPhantom;
+    dummyField;
     constructor(typeArgs, fields) {
-        this.__StructClass = true;
-        this.$typeName = StakerKey.$typeName;
-        this.$isPhantom = StakerKey.$isPhantom;
         this.$fullTypeName = composeSuiType(StakerKey.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.dummyField = fields.dummyField;
@@ -1179,7 +1270,7 @@ export class StakerKey {
             bcs: StakerKey.bcs,
             fromJSONField: (field) => StakerKey.fromJSONField(field),
             fromJSON: (json) => StakerKey.fromJSON(json),
-            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return StakerKey.fetch(client, id); }),
+            fetch: async (client, id) => StakerKey.fetch(client, id),
             new: (fields) => {
                 return new StakerKey([], fields);
             },
@@ -1222,7 +1313,11 @@ export class StakerKey {
         };
     }
     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 StakerKey.reified().new({
@@ -1235,16 +1330,11 @@ export class StakerKey {
         }
         return StakerKey.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 (!isStakerKey(object.type)) {
-                throw new Error(`object at id ${id} is not a StakerKey object`);
-            }
-            return StakerKey.fromBcs(object.content);
-        });
+    static async fetch(client, id) {
+        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        if (!isStakerKey(object.type)) {
+            throw new Error(`object at id ${id} is not a StakerKey object`);
+        }
+        return StakerKey.fromBcs(object.content);
     }
 }
-StakerKey.$typeName = `${PKG_V8}::reserve::StakerKey`;
-StakerKey.$numTypeParams = 0;
-StakerKey.$isPhantom = [];