@suilend/sdk 12.7.0 → 13.0.0-next.g122801a

package/_generated/suilend/rate-limiter/structs.js

@@ -1,25 +1,33 @@
-import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom, } from "../../_framework/reified.js";
-import { composeSuiType, compressSuiType, } from "../../_framework/util.js";
-import { Decimal } from "../decimal/structs.js";
-import { PKG_V1 } from "../index.js";
-import { bcs } from "@mysten/sui/bcs";
+import { bcs } from '@mysten/sui/bcs';
+import { getTypeOrigin } from '../../_envs/index.js';
+import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom, } from '../../_framework/reified.js';
+import { composeSuiType, compressSuiType } from '../../_framework/util.js';
+import { Decimal } from '../decimal/structs.js';
 /* ============================== RateLimiter =============================== */
 export function isRateLimiter(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::rate_limiter::RateLimiter`;
+    return type
+        === `${getTypeOrigin('suilend', 'rate_limiter::RateLimiter')}::rate_limiter::RateLimiter`;
 }
+/** A structure to manage rate limiting for outflows within a specified time window. */
 export class RateLimiter {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::rate_limiter::RateLimiter`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'rate_limiter::RateLimiter')}::rate_limiter::RateLimiter`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = RateLimiter.$typeName;
     $fullTypeName;
     $typeArgs;
     $isPhantom = RateLimiter.$isPhantom;
+    /** Configuration parameters for the rate limiter. */
     config;
+    /** The sum of all outflows from the previous window. */
     prevQty;
+    /** The timestamp (in seconds) when the current window started. */
     windowStart;
+    /** The sum of all outflows in the current window. */
     curQty;
     constructor(typeArgs, fields) {
         this.$fullTypeName = composeSuiType(RateLimiter.$typeName, ...typeArgs);
@@ -30,23 +38,29 @@ export class RateLimiter {
         this.curQty = fields.curQty;
     }
     static reified() {
+        const reifiedBcs = RateLimiter.bcs;
         return {
-            typeName: RateLimiter.$typeName,
-            fullTypeName: composeSuiType(RateLimiter.$typeName, ...[]),
+            get typeName() {
+                return RateLimiter.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(RateLimiter.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: RateLimiter.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => RateLimiter.fromFields(fields),
             fromFieldsWithTypes: (item) => RateLimiter.fromFieldsWithTypes(item),
-            fromBcs: (data) => RateLimiter.fromBcs(data),
-            bcs: RateLimiter.bcs,
+            fromBcs: (data) => RateLimiter.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => RateLimiter.fromJSONField(field),
             fromJSON: (json) => RateLimiter.fromJSON(json),
+            fromCoreObject: (obj) => RateLimiter.fromCoreObject(obj),
             fetch: async (client, id) => RateLimiter.fetch(client, id),
             new: (fields) => {
                 return new RateLimiter([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -58,30 +72,37 @@ export class RateLimiter {
     static get p() {
         return RateLimiter.phantom();
     }
-    static get bcs() {
-        return bcs.struct("RateLimiter", {
+    static instantiateBcs() {
+        return bcs.struct('RateLimiter', {
             config: RateLimiterConfig.bcs,
             prev_qty: Decimal.bcs,
             window_start: bcs.u64(),
             cur_qty: Decimal.bcs,
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!RateLimiter.cachedBcs) {
+            RateLimiter.cachedBcs = RateLimiter.instantiateBcs();
+        }
+        return RateLimiter.cachedBcs;
+    }
     static fromFields(fields) {
         return RateLimiter.reified().new({
             config: decodeFromFields(RateLimiterConfig.reified(), fields.config),
             prevQty: decodeFromFields(Decimal.reified(), fields.prev_qty),
-            windowStart: decodeFromFields("u64", fields.window_start),
+            windowStart: decodeFromFields('u64', fields.window_start),
             curQty: decodeFromFields(Decimal.reified(), fields.cur_qty),
         });
     }
     static fromFieldsWithTypes(item) {
         if (!isRateLimiter(item.type)) {
-            throw new Error("not a RateLimiter type");
+            throw new Error('not a RateLimiter type');
         }
         return RateLimiter.reified().new({
             config: decodeFromFieldsWithTypes(RateLimiterConfig.reified(), item.fields.config),
             prevQty: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.prev_qty),
-            windowStart: decodeFromFieldsWithTypes("u64", item.fields.window_start),
+            windowStart: decodeFromFieldsWithTypes('u64', item.fields.window_start),
             curQty: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.cur_qty),
         });
     }
@@ -97,28 +118,33 @@ export class RateLimiter {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return RateLimiter.reified().new({
             config: decodeFromJSONField(RateLimiterConfig.reified(), field.config),
             prevQty: decodeFromJSONField(Decimal.reified(), field.prevQty),
-            windowStart: decodeFromJSONField("u64", field.windowStart),
+            windowStart: decodeFromJSONField('u64', field.windowStart),
             curQty: decodeFromJSONField(Decimal.reified(), field.curQty),
         });
     }
     static fromJSON(json) {
         if (json.$typeName !== RateLimiter.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a RateLimiter json object: expected '${RateLimiter.$typeName}' but got '${json.$typeName}'`);
         }
         return RateLimiter.fromJSONField(json);
     }
+    static fromCoreObject(obj) {
+        if (!isRateLimiter(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a RateLimiter object`);
+        }
+        return RateLimiter.fromBcs(obj.content);
+    }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
         if (!isRateLimiter(object.type)) {
             throw new Error(`object at id ${id} is not a RateLimiter object`);
         }
@@ -128,18 +154,24 @@ export class RateLimiter {
 /* ============================== RateLimiterConfig =============================== */
 export function isRateLimiterConfig(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::rate_limiter::RateLimiterConfig`;
+    return type
+        === `${getTypeOrigin('suilend', 'rate_limiter::RateLimiterConfig')}::rate_limiter::RateLimiterConfig`;
 }
+/** Configuration for the rate limiter, defining the window duration and maximum outflow. */
 export class RateLimiterConfig {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::rate_limiter::RateLimiterConfig`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'rate_limiter::RateLimiterConfig')}::rate_limiter::RateLimiterConfig`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = RateLimiterConfig.$typeName;
     $fullTypeName;
     $typeArgs;
     $isPhantom = RateLimiterConfig.$isPhantom;
+    /** The duration of the rate limiter window in seconds. */
     windowDuration;
+    /** The maximum allowed outflow in a single window. */
     maxOutflow;
     constructor(typeArgs, fields) {
         this.$fullTypeName = composeSuiType(RateLimiterConfig.$typeName, ...typeArgs);
@@ -148,23 +180,29 @@ export class RateLimiterConfig {
         this.maxOutflow = fields.maxOutflow;
     }
     static reified() {
+        const reifiedBcs = RateLimiterConfig.bcs;
         return {
-            typeName: RateLimiterConfig.$typeName,
-            fullTypeName: composeSuiType(RateLimiterConfig.$typeName, ...[]),
+            get typeName() {
+                return RateLimiterConfig.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(RateLimiterConfig.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: RateLimiterConfig.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => RateLimiterConfig.fromFields(fields),
             fromFieldsWithTypes: (item) => RateLimiterConfig.fromFieldsWithTypes(item),
-            fromBcs: (data) => RateLimiterConfig.fromBcs(data),
-            bcs: RateLimiterConfig.bcs,
+            fromBcs: (data) => RateLimiterConfig.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => RateLimiterConfig.fromJSONField(field),
             fromJSON: (json) => RateLimiterConfig.fromJSON(json),
+            fromCoreObject: (obj) => RateLimiterConfig.fromCoreObject(obj),
             fetch: async (client, id) => RateLimiterConfig.fetch(client, id),
             new: (fields) => {
                 return new RateLimiterConfig([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -176,25 +214,32 @@ export class RateLimiterConfig {
     static get p() {
         return RateLimiterConfig.phantom();
     }
-    static get bcs() {
-        return bcs.struct("RateLimiterConfig", {
+    static instantiateBcs() {
+        return bcs.struct('RateLimiterConfig', {
             window_duration: bcs.u64(),
             max_outflow: bcs.u64(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!RateLimiterConfig.cachedBcs) {
+            RateLimiterConfig.cachedBcs = RateLimiterConfig.instantiateBcs();
+        }
+        return RateLimiterConfig.cachedBcs;
+    }
     static fromFields(fields) {
         return RateLimiterConfig.reified().new({
-            windowDuration: decodeFromFields("u64", fields.window_duration),
-            maxOutflow: decodeFromFields("u64", fields.max_outflow),
+            windowDuration: decodeFromFields('u64', fields.window_duration),
+            maxOutflow: decodeFromFields('u64', fields.max_outflow),
         });
     }
     static fromFieldsWithTypes(item) {
         if (!isRateLimiterConfig(item.type)) {
-            throw new Error("not a RateLimiterConfig type");
+            throw new Error('not a RateLimiterConfig type');
         }
         return RateLimiterConfig.reified().new({
-            windowDuration: decodeFromFieldsWithTypes("u64", item.fields.window_duration),
-            maxOutflow: decodeFromFieldsWithTypes("u64", item.fields.max_outflow),
+            windowDuration: decodeFromFieldsWithTypes('u64', item.fields.window_duration),
+            maxOutflow: decodeFromFieldsWithTypes('u64', item.fields.max_outflow),
         });
     }
     static fromBcs(data) {
@@ -207,26 +252,31 @@ export class RateLimiterConfig {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return RateLimiterConfig.reified().new({
-            windowDuration: decodeFromJSONField("u64", field.windowDuration),
-            maxOutflow: decodeFromJSONField("u64", field.maxOutflow),
+            windowDuration: decodeFromJSONField('u64', field.windowDuration),
+            maxOutflow: decodeFromJSONField('u64', field.maxOutflow),
         });
     }
     static fromJSON(json) {
         if (json.$typeName !== RateLimiterConfig.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a RateLimiterConfig json object: expected '${RateLimiterConfig.$typeName}' but got '${json.$typeName}'`);
         }
         return RateLimiterConfig.fromJSONField(json);
     }
+    static fromCoreObject(obj) {
+        if (!isRateLimiterConfig(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a RateLimiterConfig object`);
+        }
+        return RateLimiterConfig.fromBcs(obj.content);
+    }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
         if (!isRateLimiterConfig(object.type)) {
             throw new Error(`object at id ${id} is not a RateLimiterConfig object`);
         }