@suilend/sdk 12.7.0 → 13.0.0-next.g803bba0

package/_generated/suilend/rate-limiter/functions.d.ts

@@ -1,32 +1,151 @@
-import { Transaction, TransactionArgument, TransactionObjectInput } from "@mysten/sui/transactions";
+import { Transaction, TransactionArgument, TransactionObjectInput, TransactionResult } from '@mysten/sui/transactions';
+import type { EnvConfig } from '../../_envs';
+export interface NewConfigArgs {
+    windowDuration: bigint | TransactionArgument;
+    maxOutflow: bigint | TransactionArgument;
+}
+/**
+ * Creates a new rate limiter configuration.
+ *
+ * # Arguments
+ *
+ * * `window_duration` - The duration of the rate limiter window in seconds.
+ * * `max_outflow` - The maximum allowed outflow in a single window.
+ *
+ * # Returns
+ *
+ * * `RateLimiterConfig` - A new configuration instance for the rate limiter.
+ *
+ * # Panics
+ *
+ * * If `window_duration` is zero (`EInvalidConfig`).
+ */
+export declare function newConfig(tx: Transaction, args: NewConfigArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
 export interface NewArgs {
     config: TransactionObjectInput;
     curTime: bigint | TransactionArgument;
 }
-export declare function new_(tx: Transaction, args: NewArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface CurrentOutflowArgs {
+/**
+ * Creates a new rate limiter with the specified configuration and current time.
+ *
+ * Initializes the rate limiter with zero previous and current quantities, setting the
+ * window start to the provided time.
+ *
+ * # Arguments
+ *
+ * * `config` - The `RateLimiterConfig` defining the window duration and max outflow.
+ * * `cur_time` - The current timestamp in seconds.
+ *
+ * # Returns
+ *
+ * * `RateLimiter` - A new rate limiter instance.
+ */
+export declare function new_(tx: Transaction, args: NewArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface UpdateInternalArgs {
     rateLimiter: TransactionObjectInput;
     curTime: bigint | TransactionArgument;
 }
-export declare function currentOutflow(tx: Transaction, args: CurrentOutflowArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface NewConfigArgs {
-    windowDuration: bigint | TransactionArgument;
-    maxOutflow: bigint | TransactionArgument;
+/**
+ * Updates the rate limiter's state based on the current time.
+ *
+ * This internal function shifts the window forward if the current time exceeds the
+ * current window's end. It moves the current quantity to the previous quantity and
+ * resets the current quantity if within the next window, or clears both if the time
+ * is beyond two windows.
+ *
+ * # Arguments
+ *
+ * * `rate_limiter` - A mutable reference to the `RateLimiter` to update.
+ * * `cur_time` - The current timestamp in seconds.
+ *
+ * # Panics
+ *
+ * * If `cur_time` is less than the rate limiter's `window_start` (`EInvalidTime`).
+ */
+export declare function updateInternal(tx: Transaction, args: UpdateInternalArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
+export interface CurrentOutflowArgs {
+    rateLimiter: TransactionObjectInput;
+    curTime: bigint | TransactionArgument;
 }
-export declare function newConfig(tx: Transaction, args: NewConfigArgs): import("@mysten/sui/transactions").TransactionResult;
+/**
+ * Calculates the current outflow for the rate limiter.
+ *
+ * This function assumes an even distribution of the previous window's outflow and
+ * combines it with the current window's outflow, weighted by the time remaining in
+ * the previous window. Must be called after `update_internal`.
+ *
+ * # Arguments
+ *
+ * * `rate_limiter` - A reference to the `RateLimiter` to query.
+ * * `cur_time` - The current timestamp in seconds.
+ *
+ * # Returns
+ *
+ * * `Decimal` - The calculated current outflow, combining weighted previous and current quantities.
+ *
+ * # Panics
+ *
+ * * If the `window_duration` is zero, as this would lead to division by zero.
+ */
+export declare function currentOutflow(tx: Transaction, args: CurrentOutflowArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
 export interface ProcessQtyArgs {
     rateLimiter: TransactionObjectInput;
     curTime: bigint | TransactionArgument;
     qty: TransactionObjectInput;
 }
-export declare function processQty(tx: Transaction, args: ProcessQtyArgs): import("@mysten/sui/transactions").TransactionResult;
+/**
+ * Processes a new outflow quantity, updating the rate limiter and checking the limit.
+ *
+ * Updates the rate limiter's state and adds the specified quantity to the current
+ * window's outflow. It ensures the total outflow does not exceed the configured maximum.
+ *
+ * # Arguments
+ *
+ * * `rate_limiter` - A mutable reference to the `RateLimiter` to update.
+ * * `cur_time` - The current timestamp in seconds.
+ * * `qty` - The outflow quantity to process, as a `Decimal`.
+ *
+ * # Panics
+ *
+ * * If `cur_time` is less than the rate limiter's `window_start` (`EInvalidTime`).
+ * * If the total outflow exceeds the configured `max_outflow` (`ERateLimitExceeded`).
+ * * If the `window_duration` is zero, as this would lead to division by zero in `current_outflow`.
+ */
+export declare function processQty(tx: Transaction, args: ProcessQtyArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;
 export interface RemainingOutflowArgs {
     rateLimiter: TransactionObjectInput;
     curTime: bigint | TransactionArgument;
 }
-export declare function remainingOutflow(tx: Transaction, args: RemainingOutflowArgs): import("@mysten/sui/transactions").TransactionResult;
-export interface UpdateInternalArgs {
-    rateLimiter: TransactionObjectInput;
-    curTime: bigint | TransactionArgument;
-}
-export declare function updateInternal(tx: Transaction, args: UpdateInternalArgs): import("@mysten/sui/transactions").TransactionResult;
+/**
+ * Calculates the remaining outflow capacity in the current window.
+ *
+ * Updates the rate limiter's state and returns the difference between the maximum
+ * allowed outflow and the current outflow, ensuring non-negative results.
+ *
+ * # Arguments
+ *
+ * * `rate_limiter` - A mutable reference to the `RateLimiter` to query.
+ * * `cur_time` - The current timestamp in seconds.
+ *
+ * # Returns
+ *
+ * * `Decimal` - The remaining outflow capacity in the current window.
+ *
+ * # Panics
+ *
+ * * If `cur_time` is less than the rate limiter's `window_start` (`EInvalidTime`).
+ * * If the `window_duration` is zero, as this would lead to division by zero in `current_outflow`.
+ */
+export declare function remainingOutflow(tx: Transaction, args: RemainingOutflowArgs, options?: {
+    env?: EnvConfig;
+}): TransactionResult;

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

@@ -1,45 +1,163 @@
-import { PUBLISHED_AT } from "../index.js";
-import { obj, pure } from "../../_framework/util.js";
-export function new_(tx, args) {
+import { getPublishedAt } from '../../_envs/index.js';
+import { obj, pure } from '../../_framework/util.js';
+/**
+ * Creates a new rate limiter configuration.
+ *
+ * # Arguments
+ *
+ * * `window_duration` - The duration of the rate limiter window in seconds.
+ * * `max_outflow` - The maximum allowed outflow in a single window.
+ *
+ * # Returns
+ *
+ * * `RateLimiterConfig` - A new configuration instance for the rate limiter.
+ *
+ * # Panics
+ *
+ * * If `window_duration` is zero (`EInvalidConfig`).
+ */
+export function newConfig(tx, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::rate_limiter::new`,
-        arguments: [obj(tx, args.config), pure(tx, args.curTime, `u64`)],
+        target: `${getPublishedAt('suilend', options?.env)}::rate_limiter::new_config`,
+        arguments: [
+            pure(tx, args.windowDuration, `u64`),
+            pure(tx, args.maxOutflow, `u64`),
+        ],
     });
 }
-export function currentOutflow(tx, args) {
+/**
+ * Creates a new rate limiter with the specified configuration and current time.
+ *
+ * Initializes the rate limiter with zero previous and current quantities, setting the
+ * window start to the provided time.
+ *
+ * # Arguments
+ *
+ * * `config` - The `RateLimiterConfig` defining the window duration and max outflow.
+ * * `cur_time` - The current timestamp in seconds.
+ *
+ * # Returns
+ *
+ * * `RateLimiter` - A new rate limiter instance.
+ */
+export function new_(tx, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::rate_limiter::current_outflow`,
-        arguments: [obj(tx, args.rateLimiter), pure(tx, args.curTime, `u64`)],
+        target: `${getPublishedAt('suilend', options?.env)}::rate_limiter::new`,
+        arguments: [
+            obj(tx, args.config),
+            pure(tx, args.curTime, `u64`),
+        ],
     });
 }
-export function newConfig(tx, args) {
+/**
+ * Updates the rate limiter's state based on the current time.
+ *
+ * This internal function shifts the window forward if the current time exceeds the
+ * current window's end. It moves the current quantity to the previous quantity and
+ * resets the current quantity if within the next window, or clears both if the time
+ * is beyond two windows.
+ *
+ * # Arguments
+ *
+ * * `rate_limiter` - A mutable reference to the `RateLimiter` to update.
+ * * `cur_time` - The current timestamp in seconds.
+ *
+ * # Panics
+ *
+ * * If `cur_time` is less than the rate limiter's `window_start` (`EInvalidTime`).
+ */
+export function updateInternal(tx, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::rate_limiter::new_config`,
+        target: `${getPublishedAt('suilend', options?.env)}::rate_limiter::update_internal`,
         arguments: [
-            pure(tx, args.windowDuration, `u64`),
-            pure(tx, args.maxOutflow, `u64`),
+            obj(tx, args.rateLimiter),
+            pure(tx, args.curTime, `u64`),
         ],
     });
 }
-export function processQty(tx, args) {
+/**
+ * Calculates the current outflow for the rate limiter.
+ *
+ * This function assumes an even distribution of the previous window's outflow and
+ * combines it with the current window's outflow, weighted by the time remaining in
+ * the previous window. Must be called after `update_internal`.
+ *
+ * # Arguments
+ *
+ * * `rate_limiter` - A reference to the `RateLimiter` to query.
+ * * `cur_time` - The current timestamp in seconds.
+ *
+ * # Returns
+ *
+ * * `Decimal` - The calculated current outflow, combining weighted previous and current quantities.
+ *
+ * # Panics
+ *
+ * * If the `window_duration` is zero, as this would lead to division by zero.
+ */
+export function currentOutflow(tx, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::rate_limiter::process_qty`,
+        target: `${getPublishedAt('suilend', options?.env)}::rate_limiter::current_outflow`,
         arguments: [
             obj(tx, args.rateLimiter),
             pure(tx, args.curTime, `u64`),
-            obj(tx, args.qty),
         ],
     });
 }
-export function remainingOutflow(tx, args) {
+/**
+ * Processes a new outflow quantity, updating the rate limiter and checking the limit.
+ *
+ * Updates the rate limiter's state and adds the specified quantity to the current
+ * window's outflow. It ensures the total outflow does not exceed the configured maximum.
+ *
+ * # Arguments
+ *
+ * * `rate_limiter` - A mutable reference to the `RateLimiter` to update.
+ * * `cur_time` - The current timestamp in seconds.
+ * * `qty` - The outflow quantity to process, as a `Decimal`.
+ *
+ * # Panics
+ *
+ * * If `cur_time` is less than the rate limiter's `window_start` (`EInvalidTime`).
+ * * If the total outflow exceeds the configured `max_outflow` (`ERateLimitExceeded`).
+ * * If the `window_duration` is zero, as this would lead to division by zero in `current_outflow`.
+ */
+export function processQty(tx, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::rate_limiter::remaining_outflow`,
-        arguments: [obj(tx, args.rateLimiter), pure(tx, args.curTime, `u64`)],
+        target: `${getPublishedAt('suilend', options?.env)}::rate_limiter::process_qty`,
+        arguments: [
+            obj(tx, args.rateLimiter),
+            pure(tx, args.curTime, `u64`),
+            obj(tx, args.qty),
+        ],
     });
 }
-export function updateInternal(tx, args) {
+/**
+ * Calculates the remaining outflow capacity in the current window.
+ *
+ * Updates the rate limiter's state and returns the difference between the maximum
+ * allowed outflow and the current outflow, ensuring non-negative results.
+ *
+ * # Arguments
+ *
+ * * `rate_limiter` - A mutable reference to the `RateLimiter` to query.
+ * * `cur_time` - The current timestamp in seconds.
+ *
+ * # Returns
+ *
+ * * `Decimal` - The remaining outflow capacity in the current window.
+ *
+ * # Panics
+ *
+ * * If `cur_time` is less than the rate limiter's `window_start` (`EInvalidTime`).
+ * * If the `window_duration` is zero, as this would lead to division by zero in `current_outflow`.
+ */
+export function remainingOutflow(tx, args, options) {
     return tx.moveCall({
-        target: `${PUBLISHED_AT}::rate_limiter::update_internal`,
-        arguments: [obj(tx, args.rateLimiter), pure(tx, args.curTime, `u64`)],
+        target: `${getPublishedAt('suilend', options?.env)}::rate_limiter::remaining_outflow`,
+        arguments: [
+            obj(tx, args.rateLimiter),
+            pure(tx, args.curTime, `u64`),
+        ],
     });
 }

package/_generated/suilend/rate-limiter/structs.d.ts

@@ -1,122 +1,114 @@
-import { PhantomReified, Reified, StructClass, ToField, ToTypeStr } from "../../_framework/reified";
-import { FieldsWithTypes } from "../../_framework/util";
-import { Decimal } from "../decimal/structs";
-import { PKG_V1 } from "../index";
-import { SuiGrpcClient } from "@mysten/sui/grpc";
+import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
+import { PhantomReified, Reified, StructClass, ToField, ToJSON, ToTypeStr } from '../../_framework/reified';
+import { FieldsWithTypes } from '../../_framework/util';
+import { Decimal } from '../decimal/structs';
 export declare function isRateLimiter(type: string): boolean;
 export interface RateLimiterFields {
+    /** Configuration parameters for the rate limiter. */
     config: ToField<RateLimiterConfig>;
+    /** The sum of all outflows from the previous window. */
     prevQty: ToField<Decimal>;
-    windowStart: ToField<"u64">;
+    /** The timestamp (in seconds) when the current window started. */
+    windowStart: ToField<'u64'>;
+    /** The sum of all outflows in the current window. */
     curQty: ToField<Decimal>;
 }
 export type RateLimiterReified = Reified<RateLimiter, RateLimiterFields>;
+export type RateLimiterJSONField = {
+    config: ToJSON<RateLimiterConfig>;
+    prevQty: ToJSON<Decimal>;
+    windowStart: string;
+    curQty: ToJSON<Decimal>;
+};
+export type RateLimiterJSON = {
+    $typeName: typeof RateLimiter.$typeName;
+    $typeArgs: [];
+} & RateLimiterJSONField;
+/** A structure to manage rate limiting for outflows within a specified time window. */
 export declare class RateLimiter implements StructClass {
     __StructClass: true;
-    static readonly $typeName: string;
+    static get $typeName(): `${string}::rate_limiter::RateLimiter`;
     static readonly $numTypeParams = 0;
     static readonly $isPhantom: readonly [];
-    readonly $typeName: string;
-    readonly $fullTypeName: `${typeof PKG_V1}::rate_limiter::RateLimiter`;
+    readonly $typeName: typeof RateLimiter.$typeName;
+    readonly $fullTypeName: `${string}::rate_limiter::RateLimiter`;
     readonly $typeArgs: [];
-    readonly $isPhantom: readonly [];
+    readonly $isPhantom: typeof RateLimiter.$isPhantom;
+    /** Configuration parameters for the rate limiter. */
     readonly config: ToField<RateLimiterConfig>;
+    /** The sum of all outflows from the previous window. */
     readonly prevQty: ToField<Decimal>;
-    readonly windowStart: ToField<"u64">;
+    /** The timestamp (in seconds) when the current window started. */
+    readonly windowStart: ToField<'u64'>;
+    /** The sum of all outflows in the current window. */
     readonly curQty: ToField<Decimal>;
     private constructor();
     static reified(): RateLimiterReified;
-    static get r(): import("../../_framework/reified").StructClassReified<RateLimiter, RateLimiterFields>;
+    static get r(): RateLimiterReified;
     static phantom(): PhantomReified<ToTypeStr<RateLimiter>>;
-    static get p(): PhantomReified<"0x1f54a9a2d71799553197e9ea24557797c6398d6a65f2d4d3818c9304b75d5e21::rate_limiter::RateLimiter" | "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiter">;
-    static get bcs(): import("@mysten/bcs").BcsStruct<{
-        config: import("@mysten/bcs").BcsStruct<{
-            window_duration: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
-            max_outflow: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
-        }, string>;
-        prev_qty: import("@mysten/bcs").BcsStruct<{
-            value: import("@mysten/bcs").BcsType<string, string | number | bigint, "u256">;
-        }, string>;
-        window_start: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
-        cur_qty: import("@mysten/bcs").BcsStruct<{
-            value: import("@mysten/bcs").BcsType<string, string | number | bigint, "u256">;
-        }, string>;
-    }, string>;
+    static get p(): PhantomReified<ToTypeStr<RateLimiter>>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof RateLimiter.instantiateBcs>;
     static fromFields(fields: Record<string, any>): RateLimiter;
     static fromFieldsWithTypes(item: FieldsWithTypes): RateLimiter;
     static fromBcs(data: Uint8Array): RateLimiter;
-    toJSONField(): {
-        config: {
-            windowDuration: string;
-            maxOutflow: string;
-        };
-        prevQty: {
-            value: string;
-        };
-        windowStart: string;
-        curQty: {
-            value: string;
-        };
-    };
-    toJSON(): {
-        config: {
-            windowDuration: string;
-            maxOutflow: string;
-        };
-        prevQty: {
-            value: string;
-        };
-        windowStart: string;
-        curQty: {
-            value: string;
-        };
-        $typeName: string;
-        $typeArgs: [];
-    };
+    toJSONField(): RateLimiterJSONField;
+    toJSON(): RateLimiterJSON;
     static fromJSONField(field: any): RateLimiter;
     static fromJSON(json: Record<string, any>): RateLimiter;
-    static fetch(client: SuiGrpcClient, id: string): Promise<RateLimiter>;
+    static fromCoreObject(obj: SuiClientTypes.Object<{
+        content: true;
+    }>): RateLimiter;
+    static fetch(client: ClientWithCoreApi, id: string): Promise<RateLimiter>;
 }
 export declare function isRateLimiterConfig(type: string): boolean;
 export interface RateLimiterConfigFields {
-    windowDuration: ToField<"u64">;
-    maxOutflow: ToField<"u64">;
+    /** The duration of the rate limiter window in seconds. */
+    windowDuration: ToField<'u64'>;
+    /** The maximum allowed outflow in a single window. */
+    maxOutflow: ToField<'u64'>;
 }
 export type RateLimiterConfigReified = Reified<RateLimiterConfig, RateLimiterConfigFields>;
+export type RateLimiterConfigJSONField = {
+    windowDuration: string;
+    maxOutflow: string;
+};
+export type RateLimiterConfigJSON = {
+    $typeName: typeof RateLimiterConfig.$typeName;
+    $typeArgs: [];
+} & RateLimiterConfigJSONField;
+/** Configuration for the rate limiter, defining the window duration and maximum outflow. */
 export declare class RateLimiterConfig implements StructClass {
     __StructClass: true;
-    static readonly $typeName: string;
+    static get $typeName(): `${string}::rate_limiter::RateLimiterConfig`;
     static readonly $numTypeParams = 0;
     static readonly $isPhantom: readonly [];
-    readonly $typeName: string;
-    readonly $fullTypeName: `${typeof PKG_V1}::rate_limiter::RateLimiterConfig`;
+    readonly $typeName: typeof RateLimiterConfig.$typeName;
+    readonly $fullTypeName: `${string}::rate_limiter::RateLimiterConfig`;
     readonly $typeArgs: [];
-    readonly $isPhantom: readonly [];
-    readonly windowDuration: ToField<"u64">;
-    readonly maxOutflow: ToField<"u64">;
+    readonly $isPhantom: typeof RateLimiterConfig.$isPhantom;
+    /** The duration of the rate limiter window in seconds. */
+    readonly windowDuration: ToField<'u64'>;
+    /** The maximum allowed outflow in a single window. */
+    readonly maxOutflow: ToField<'u64'>;
     private constructor();
     static reified(): RateLimiterConfigReified;
-    static get r(): import("../../_framework/reified").StructClassReified<RateLimiterConfig, RateLimiterConfigFields>;
+    static get r(): RateLimiterConfigReified;
     static phantom(): PhantomReified<ToTypeStr<RateLimiterConfig>>;
-    static get p(): PhantomReified<"0x1f54a9a2d71799553197e9ea24557797c6398d6a65f2d4d3818c9304b75d5e21::rate_limiter::RateLimiterConfig" | "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::rate_limiter::RateLimiterConfig">;
-    static get bcs(): import("@mysten/bcs").BcsStruct<{
-        window_duration: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
-        max_outflow: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
-    }, string>;
+    static get p(): PhantomReified<ToTypeStr<RateLimiterConfig>>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof RateLimiterConfig.instantiateBcs>;
     static fromFields(fields: Record<string, any>): RateLimiterConfig;
     static fromFieldsWithTypes(item: FieldsWithTypes): RateLimiterConfig;
     static fromBcs(data: Uint8Array): RateLimiterConfig;
-    toJSONField(): {
-        windowDuration: string;
-        maxOutflow: string;
-    };
-    toJSON(): {
-        windowDuration: string;
-        maxOutflow: string;
-        $typeName: string;
-        $typeArgs: [];
-    };
+    toJSONField(): RateLimiterConfigJSONField;
+    toJSON(): RateLimiterConfigJSON;
     static fromJSONField(field: any): RateLimiterConfig;
     static fromJSON(json: Record<string, any>): RateLimiterConfig;
-    static fetch(client: SuiGrpcClient, id: string): Promise<RateLimiterConfig>;
+    static fromCoreObject(obj: SuiClientTypes.Object<{
+        content: true;
+    }>): RateLimiterConfig;
+    static fetch(client: ClientWithCoreApi, id: string): Promise<RateLimiterConfig>;
 }