@suilend/sdk 15.0.0 → 16.0.0

package/_generated/suilend/reserve/structs.js

@@ -834,6 +834,128 @@ export class StakerKey {
         return StakerKey.fromBcs(object.content);
     }
 }
+/* ============================== StakerValidatorKey =============================== */
+export function isStakerValidatorKey(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'reserve::StakerValidatorKey')}::reserve::StakerValidatorKey`;
+}
+export class StakerValidatorKey {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::StakerValidatorKey')}::reserve::StakerValidatorKey`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = StakerValidatorKey.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = StakerValidatorKey.$isPhantom;
+    dummyField;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(StakerValidatorKey.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.dummyField = fields.dummyField;
+    }
+    static reified() {
+        const reifiedBcs = StakerValidatorKey.bcs;
+        return {
+            get typeName() {
+                return StakerValidatorKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(StakerValidatorKey.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: StakerValidatorKey.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => StakerValidatorKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => StakerValidatorKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => StakerValidatorKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => StakerValidatorKey.fromJSONField(field),
+            fromJSON: (json) => StakerValidatorKey.fromJSON(json),
+            fromCoreObject: (obj) => StakerValidatorKey.fromCoreObject(obj),
+            fetch: async (client, id) => StakerValidatorKey.fetch(client, id),
+            new: (fields) => {
+                return new StakerValidatorKey([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return StakerValidatorKey.reified();
+    }
+    static phantom() {
+        return phantom(StakerValidatorKey.reified());
+    }
+    static get p() {
+        return StakerValidatorKey.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('StakerValidatorKey', {
+            dummy_field: bcs.bool(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!StakerValidatorKey.cachedBcs) {
+            StakerValidatorKey.cachedBcs = StakerValidatorKey.instantiateBcs();
+        }
+        return StakerValidatorKey.cachedBcs;
+    }
+    static fromFields(fields) {
+        return StakerValidatorKey.reified().new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isStakerValidatorKey(item.type)) {
+            throw new Error('not a StakerValidatorKey type');
+        }
+        return StakerValidatorKey.reified().new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
+        });
+    }
+    static fromBcs(data) {
+        return StakerValidatorKey.fromFields(StakerValidatorKey.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return StakerValidatorKey.reified().new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== StakerValidatorKey.$typeName) {
+            throw new Error(`not a StakerValidatorKey json object: expected '${StakerValidatorKey.$typeName}' but got '${json.$typeName}'`);
+        }
+        return StakerValidatorKey.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isStakerValidatorKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a StakerValidatorKey object`);
+        }
+        return StakerValidatorKey.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isStakerValidatorKey(object.type)) {
+            throw new Error(`object at id ${id} is not a StakerValidatorKey object`);
+        }
+        return StakerValidatorKey.fromBcs(object.content);
+    }
+}
 /* ============================== ReservePauseKey =============================== */
 export function isReservePauseKey(type) {
     type = compressSuiType(type);
@@ -956,6 +1078,128 @@ export class ReservePauseKey {
         return ReservePauseKey.fromBcs(object.content);
     }
 }
+/* ============================== RateLimiterExemptKey =============================== */
+export function isRateLimiterExemptKey(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'reserve::RateLimiterExemptKey')}::reserve::RateLimiterExemptKey`;
+}
+export class RateLimiterExemptKey {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::RateLimiterExemptKey')}::reserve::RateLimiterExemptKey`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = RateLimiterExemptKey.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = RateLimiterExemptKey.$isPhantom;
+    dummyField;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(RateLimiterExemptKey.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.dummyField = fields.dummyField;
+    }
+    static reified() {
+        const reifiedBcs = RateLimiterExemptKey.bcs;
+        return {
+            get typeName() {
+                return RateLimiterExemptKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(RateLimiterExemptKey.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: RateLimiterExemptKey.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => RateLimiterExemptKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => RateLimiterExemptKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => RateLimiterExemptKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => RateLimiterExemptKey.fromJSONField(field),
+            fromJSON: (json) => RateLimiterExemptKey.fromJSON(json),
+            fromCoreObject: (obj) => RateLimiterExemptKey.fromCoreObject(obj),
+            fetch: async (client, id) => RateLimiterExemptKey.fetch(client, id),
+            new: (fields) => {
+                return new RateLimiterExemptKey([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return RateLimiterExemptKey.reified();
+    }
+    static phantom() {
+        return phantom(RateLimiterExemptKey.reified());
+    }
+    static get p() {
+        return RateLimiterExemptKey.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('RateLimiterExemptKey', {
+            dummy_field: bcs.bool(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!RateLimiterExemptKey.cachedBcs) {
+            RateLimiterExemptKey.cachedBcs = RateLimiterExemptKey.instantiateBcs();
+        }
+        return RateLimiterExemptKey.cachedBcs;
+    }
+    static fromFields(fields) {
+        return RateLimiterExemptKey.reified().new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isRateLimiterExemptKey(item.type)) {
+            throw new Error('not a RateLimiterExemptKey type');
+        }
+        return RateLimiterExemptKey.reified().new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
+        });
+    }
+    static fromBcs(data) {
+        return RateLimiterExemptKey.fromFields(RateLimiterExemptKey.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return RateLimiterExemptKey.reified().new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== RateLimiterExemptKey.$typeName) {
+            throw new Error(`not a RateLimiterExemptKey json object: expected '${RateLimiterExemptKey.$typeName}' but got '${json.$typeName}'`);
+        }
+        return RateLimiterExemptKey.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isRateLimiterExemptKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a RateLimiterExemptKey object`);
+        }
+        return RateLimiterExemptKey.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isRateLimiterExemptKey(object.type)) {
+            throw new Error(`object at id ${id} is not a RateLimiterExemptKey object`);
+        }
+        return RateLimiterExemptKey.fromBcs(object.content);
+    }
+}
 /* ============================== PriceGuardKey =============================== */
 export function isPriceGuardKey(type) {
     type = compressSuiType(type);
@@ -1198,16 +1442,138 @@ export class ConfidenceKey {
         return ConfidenceKey.fromBcs(object.content);
     }
 }
+/* ============================== RawPriceKey =============================== */
+export function isRawPriceKey(type) {
+    type = compressSuiType(type);
+    return type === `${getTypeOrigin('suilend', 'reserve::RawPriceKey')}::reserve::RawPriceKey`;
+}
+export class RawPriceKey {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::RawPriceKey')}::reserve::RawPriceKey`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = RawPriceKey.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = RawPriceKey.$isPhantom;
+    dummyField;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(RawPriceKey.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.dummyField = fields.dummyField;
+    }
+    static reified() {
+        const reifiedBcs = RawPriceKey.bcs;
+        return {
+            get typeName() {
+                return RawPriceKey.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(RawPriceKey.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: RawPriceKey.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => RawPriceKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => RawPriceKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => RawPriceKey.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => RawPriceKey.fromJSONField(field),
+            fromJSON: (json) => RawPriceKey.fromJSON(json),
+            fromCoreObject: (obj) => RawPriceKey.fromCoreObject(obj),
+            fetch: async (client, id) => RawPriceKey.fetch(client, id),
+            new: (fields) => {
+                return new RawPriceKey([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return RawPriceKey.reified();
+    }
+    static phantom() {
+        return phantom(RawPriceKey.reified());
+    }
+    static get p() {
+        return RawPriceKey.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('RawPriceKey', {
+            dummy_field: bcs.bool(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!RawPriceKey.cachedBcs) {
+            RawPriceKey.cachedBcs = RawPriceKey.instantiateBcs();
+        }
+        return RawPriceKey.cachedBcs;
+    }
+    static fromFields(fields) {
+        return RawPriceKey.reified().new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isRawPriceKey(item.type)) {
+            throw new Error('not a RawPriceKey type');
+        }
+        return RawPriceKey.reified().new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
+        });
+    }
+    static fromBcs(data) {
+        return RawPriceKey.fromFields(RawPriceKey.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return RawPriceKey.reified().new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== RawPriceKey.$typeName) {
+            throw new Error(`not a RawPriceKey json object: expected '${RawPriceKey.$typeName}' but got '${json.$typeName}'`);
+        }
+        return RawPriceKey.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isRawPriceKey(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a RawPriceKey object`);
+        }
+        return RawPriceKey.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isRawPriceKey(object.type)) {
+            throw new Error(`object at id ${id} is not a RawPriceKey object`);
+        }
+        return RawPriceKey.fromBcs(object.content);
+    }
+}
 /* ============================== PriceGuard =============================== */
 export function isPriceGuard(type) {
     type = compressSuiType(type);
     return type === `${getTypeOrigin('suilend', 'reserve::PriceGuard')}::reserve::PriceGuard`;
 }
 /**
- * Bounds how far `price` and `smoothed_price` may move per
- * `min_update_interval_s`. Each anchor moves at most one band per interval and is
- * advanced to the clamped value, so repeating a refresh inside one PTB cannot walk
- * either price further than a single band.
+ * Bounds how far `price` and `smoothed_price` move per `min_update_interval_s`. An elapsed
+ * interval opens each anchor on the price stored then, and every refresh until the next
+ * one clamps against it. One PTB stays within one band of the anchor, and two refreshes
+ * either side of a boundary within three bands, the walk
+ * `assert_band_below_liquidation_buffer` bounds.
  */
 export class PriceGuard {
     __StructClass = true;
@@ -1353,6 +1719,138 @@ export class PriceGuard {
         return PriceGuard.fromBcs(object.content);
     }
 }
+/* ============================== RawPrice =============================== */
+export function isRawPrice(type) {
+    type = compressSuiType(type);
+    return type === `${getTypeOrigin('suilend', 'reserve::RawPrice')}::reserve::RawPrice`;
+}
+/**
+ * While a clamp lags the market, the stored price overvalues falling collateral and
+ * undervalues rising debt, so the borrow and withdraw bounds also range over these.
+ */
+export class RawPrice {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::RawPrice')}::reserve::RawPrice`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = RawPrice.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = RawPrice.$isPhantom;
+    price;
+    smoothedPrice;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(RawPrice.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.price = fields.price;
+        this.smoothedPrice = fields.smoothedPrice;
+    }
+    static reified() {
+        const reifiedBcs = RawPrice.bcs;
+        return {
+            get typeName() {
+                return RawPrice.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(RawPrice.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: RawPrice.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => RawPrice.fromFields(fields),
+            fromFieldsWithTypes: (item) => RawPrice.fromFieldsWithTypes(item),
+            fromBcs: (data) => RawPrice.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => RawPrice.fromJSONField(field),
+            fromJSON: (json) => RawPrice.fromJSON(json),
+            fromCoreObject: (obj) => RawPrice.fromCoreObject(obj),
+            fetch: async (client, id) => RawPrice.fetch(client, id),
+            new: (fields) => {
+                return new RawPrice([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return RawPrice.reified();
+    }
+    static phantom() {
+        return phantom(RawPrice.reified());
+    }
+    static get p() {
+        return RawPrice.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('RawPrice', {
+            price: Decimal.bcs,
+            smoothed_price: Decimal.bcs,
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!RawPrice.cachedBcs) {
+            RawPrice.cachedBcs = RawPrice.instantiateBcs();
+        }
+        return RawPrice.cachedBcs;
+    }
+    static fromFields(fields) {
+        return RawPrice.reified().new({
+            price: decodeFromFields(Decimal.reified(), fields.price),
+            smoothedPrice: decodeFromFields(Decimal.reified(), fields.smoothed_price),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isRawPrice(item.type)) {
+            throw new Error('not a RawPrice type');
+        }
+        return RawPrice.reified().new({
+            price: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.price),
+            smoothedPrice: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.smoothed_price),
+        });
+    }
+    static fromBcs(data) {
+        return RawPrice.fromFields(RawPrice.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            price: this.price.toJSONField(),
+            smoothedPrice: this.smoothedPrice.toJSONField(),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return RawPrice.reified().new({
+            price: decodeFromJSONField(Decimal.reified(), field.price),
+            smoothedPrice: decodeFromJSONField(Decimal.reified(), field.smoothedPrice),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== RawPrice.$typeName) {
+            throw new Error(`not a RawPrice json object: expected '${RawPrice.$typeName}' but got '${json.$typeName}'`);
+        }
+        return RawPrice.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isRawPrice(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a RawPrice object`);
+        }
+        return RawPrice.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isRawPrice(object.type)) {
+            throw new Error(`object at id ${id} is not a RawPrice object`);
+        }
+        return RawPrice.fromBcs(object.content);
+    }
+}
 /* ============================== Balances =============================== */
 export function isBalances(type) {
     type = compressSuiType(type);
@@ -1986,6 +2484,127 @@ export class ReserveAssetDataEvent {
         return ReserveAssetDataEvent.fromBcs(object.content);
     }
 }
+/* ============================== ReserveWitness =============================== */
+export function isReserveWitness(type) {
+    type = compressSuiType(type);
+    return type === `${getTypeOrigin('suilend', 'reserve::ReserveWitness')}::reserve::ReserveWitness`;
+}
+export class ReserveWitness {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'reserve::ReserveWitness')}::reserve::ReserveWitness`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = ReserveWitness.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = ReserveWitness.$isPhantom;
+    dummyField;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(ReserveWitness.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.dummyField = fields.dummyField;
+    }
+    static reified() {
+        const reifiedBcs = ReserveWitness.bcs;
+        return {
+            get typeName() {
+                return ReserveWitness.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ReserveWitness.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: ReserveWitness.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => ReserveWitness.fromFields(fields),
+            fromFieldsWithTypes: (item) => ReserveWitness.fromFieldsWithTypes(item),
+            fromBcs: (data) => ReserveWitness.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => ReserveWitness.fromJSONField(field),
+            fromJSON: (json) => ReserveWitness.fromJSON(json),
+            fromCoreObject: (obj) => ReserveWitness.fromCoreObject(obj),
+            fetch: async (client, id) => ReserveWitness.fetch(client, id),
+            new: (fields) => {
+                return new ReserveWitness([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return ReserveWitness.reified();
+    }
+    static phantom() {
+        return phantom(ReserveWitness.reified());
+    }
+    static get p() {
+        return ReserveWitness.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('ReserveWitness', {
+            dummy_field: bcs.bool(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!ReserveWitness.cachedBcs) {
+            ReserveWitness.cachedBcs = ReserveWitness.instantiateBcs();
+        }
+        return ReserveWitness.cachedBcs;
+    }
+    static fromFields(fields) {
+        return ReserveWitness.reified().new({
+            dummyField: decodeFromFields('bool', fields.dummy_field),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isReserveWitness(item.type)) {
+            throw new Error('not a ReserveWitness type');
+        }
+        return ReserveWitness.reified().new({
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
+        });
+    }
+    static fromBcs(data) {
+        return ReserveWitness.fromFields(ReserveWitness.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return ReserveWitness.reified().new({
+            dummyField: decodeFromJSONField('bool', field.dummyField),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== ReserveWitness.$typeName) {
+            throw new Error(`not a ReserveWitness json object: expected '${ReserveWitness.$typeName}' but got '${json.$typeName}'`);
+        }
+        return ReserveWitness.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isReserveWitness(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ReserveWitness object`);
+        }
+        return ReserveWitness.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isReserveWitness(object.type)) {
+            throw new Error(`object at id ${id} is not a ReserveWitness object`);
+        }
+        return ReserveWitness.fromBcs(object.content);
+    }
+}
 /* ============================== ClaimStakingRewardsEvent =============================== */
 export function isClaimStakingRewardsEvent(type) {
     type = compressSuiType(type);