@waterx/sdk 2.1.0 → 2.4.0

package/dist/src/generated/waterx_account/account.js

@@ -33,27 +33,8 @@ import * as table from "./deps/sui/table.js";
 import * as vec_map from "./deps/sui/vec_map.js";
 import * as type_name from "./deps/std/type_name.js";
 import * as vec_set from "./deps/sui/vec_set.js";
-import * as type_name_1 from "./deps/std/type_name.js";
-import * as vec_map_1 from "./deps/sui/vec_map.js";
-import * as type_name_2 from "./deps/std/type_name.js";
-import * as vec_set_1 from "./deps/sui/vec_set.js";
-import * as type_name_3 from "./deps/std/type_name.js";
-import * as vec_map_2 from "./deps/sui/vec_map.js";
-import * as type_name_4 from "./deps/std/type_name.js";
-import * as vec_set_2 from "./deps/sui/vec_set.js";
-import * as type_name_5 from "./deps/std/type_name.js";
-import * as vec_map_3 from "./deps/sui/vec_map.js";
-import * as type_name_6 from "./deps/std/type_name.js";
-import * as vec_set_3 from "./deps/sui/vec_set.js";
-import * as vec_set_4 from "./deps/sui/vec_set.js";
 import * as balance_1 from "./deps/sui/balance.js";
 import * as sheet from "./deps/bucket_v2_framework/sheet.js";
-import * as vec_map_4 from "./deps/sui/vec_map.js";
-import * as type_name_7 from "./deps/std/type_name.js";
-import * as vec_map_5 from "./deps/sui/vec_map.js";
-import * as type_name_8 from "./deps/std/type_name.js";
-import * as balance_2 from "./deps/sui/balance.js";
-import * as balance_3 from "./deps/sui/balance.js";
 const $moduleName = '@waterx/account::account';
 export const ACCOUNT = new MoveStruct({ name: `${$moduleName}::ACCOUNT`, fields: {
         dummy_field: bcs.bool()
@@ -91,7 +72,7 @@ export const AccountRegistry = new MoveStruct({ name: `${$moduleName}::AccountRe
          * - `new_data<P, _>` / `borrow_data_mut<P, _>` / `remove_data<P, _>` require only
          *   `P` whitelisted.
          */
-        protocol_whitelist: vec_map.VecMap(type_name.TypeName, vec_set.VecSet(type_name_1.TypeName)),
+        protocol_whitelist: vec_map.VecMap(type_name.TypeName, vec_set.VecSet(type_name.TypeName)),
         /**
          * `T → registered DepositPolicy witness TypeName`. Presence means
          * `request_deposit<T>` / `request_deposit_from_receivings<T>` are permitted; only
@@ -104,21 +85,21 @@ export const AccountRegistry = new MoveStruct({ name: `${$moduleName}::AccountRe
          * migration (both coexist while consumers switch). `request_deposit<T>` requires
          * the set to be non-empty; `consume_deposit<T, P>` requires P to be in the set.
          */
-        deposit_policies: vec_map_1.VecMap(type_name_2.TypeName, vec_set_1.VecSet(type_name_3.TypeName)),
+        deposit_policies: vec_map.VecMap(type_name.TypeName, vec_set.VecSet(type_name.TypeName)),
         /**
          * `T → set of WithdrawPolicy witness TypeNames`. Symmetric to `deposit_policies`
          * for `request_withdraw<T>` / `consume_withdraw`.
          */
-        withdraw_policies: vec_map_2.VecMap(type_name_4.TypeName, vec_set_2.VecSet(type_name_5.TypeName)),
+        withdraw_policies: vec_map.VecMap(type_name.TypeName, vec_set.VecSet(type_name.TypeName)),
         /**
          * Per-T aggregate of `Balance<T>` currently held inside accounts. Incremented in
          * `put<T, P>`, decremented in `take<T, P>` and `request_withdraw<T>`. Does _not_
          * include balance held by protocols (after `take`) or sitting in flight inside a
          * `DepositRequest` / `WithdrawRequest` hot potato.
          */
-        balances: vec_map_3.VecMap(type_name_6.TypeName, bcs.u64()),
-        allowed_versions: vec_set_3.VecSet(bcs.u16()),
-        managers: vec_set_4.VecSet(bcs.Address),
+        balances: vec_map.VecMap(type_name.TypeName, bcs.u64()),
+        allowed_versions: vec_set.VecSet(bcs.u16()),
+        managers: vec_set.VecSet(bcs.Address),
         paused: bcs.bool()
     } });
 export const VaultKey = new MoveTuple({ name: `${$moduleName}::VaultKey<phantom T>`, fields: [bcs.bool()] });
@@ -137,7 +118,7 @@ export const Delegate = new MoveStruct({ name: `${$moduleName}::Delegate`, field
          * protocol's module interprets its own bits. Owner always has `PERM_ALL` per
          * protocol regardless of this field.
          */
-        protocol_permissions: vec_map_4.VecMap(type_name_7.TypeName, bcs.u32()),
+        protocol_permissions: vec_map.VecMap(type_name.TypeName, bcs.u32()),
         expires_at_ms: bcs.option(bcs.u64())
     } });
 export const Account = new MoveStruct({ name: `${$moduleName}::Account`, fields: {
@@ -150,19 +131,20 @@ export const Account = new MoveStruct({ name: `${$moduleName}::Account`, fields:
          * `BalanceKey<T>()` on this UID. Always equals the matching stored balance's
          * `value()`.
          */
-        balances: vec_map_5.VecMap(type_name_8.TypeName, bcs.u64())
+        balances: vec_map.VecMap(type_name.TypeName, bcs.u64())
     } });
 export const DepositRequest = new MoveStruct({ name: `${$moduleName}::DepositRequest<phantom T>`, fields: {
         account_id: bcs.Address,
-        balance: balance_2.Balance,
+        balance: balance_1.Balance,
         extra_data: bcs.vector(bcs.u8())
     } });
 export const WithdrawRequest = new MoveStruct({ name: `${$moduleName}::WithdrawRequest<phantom T>`, fields: {
         account_id: bcs.Address,
-        balance: balance_3.Balance,
+        balance: balance_1.Balance,
         recipient: bcs.Address,
         extra_data: bcs.vector(bcs.u8())
     } });
+export const PausedProtocolsKey = new MoveTuple({ name: `${$moduleName}::PausedProtocolsKey`, fields: [bcs.bool()] });
 export const AccountKey = new MoveStruct({ name: `${$moduleName}::AccountKey`, fields: {
         owner: bcs.Address,
         index: bcs.u64()
@@ -490,6 +472,59 @@ export function delistProtocol(options) {
         typeArguments: options.typeArguments
     });
 }
+/**
+ * Admin: pause protocol `P` WITHOUT delisting it. A paused protocol cannot
+ * `take<_, P>` (new outbound debits) or `new_data<P, _>` (new account state), but
+ * `put<_, P>`, `borrow_data_mut<P, _>`, and `remove_data<P, _>` keep working — so
+ * in-flight refunds, claims, and close/cleanup can complete. Use this instead of
+ * `delist_protocol` for emergency stops; delisting blocks the exit paths too and
+ * strands active per-account state (see audit M09).
+ */
+export function pauseProtocol(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'pause_protocol',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Admin: lift a `pause_protocol<P>`. Idempotent on a non-paused protocol. */
+export function unpauseProtocol(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'unpause_protocol',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function isProtocolPaused(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'is_protocol_paused',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
 /**
  * Admin: add asset type `T` to protocol `P`'s allowed-asset set. After this,
  * `take<T, P>` is permitted (subject to per-account auth). Aborts if `P` is not

package/dist/src/generated/waterx_account/deps/bucket_v2_framework/sheet.js

@@ -6,13 +6,11 @@ import { MoveTuple, MoveStruct } from "../../../utils/index.js";
 import * as type_name from "../std/type_name.js";
 import * as vec_map from "../sui/vec_map.js";
 import * as liability from "./liability.js";
-import * as vec_map_1 from "../sui/vec_map.js";
-import * as liability_1 from "./liability.js";
 import * as vec_set from "../sui/vec_set.js";
 const $moduleName = 'bucket_v2_framework::sheet';
 export const Entity = new MoveTuple({ name: `${$moduleName}::Entity`, fields: [type_name.TypeName] });
 export const Sheet = new MoveStruct({ name: `${$moduleName}::Sheet<phantom CoinType, phantom SelfEntity>`, fields: {
         credits: vec_map.VecMap(Entity, liability.Credit),
-        debts: vec_map_1.VecMap(Entity, liability_1.Debt),
+        debts: vec_map.VecMap(Entity, liability.Debt),
         blacklist: vec_set.VecSet(Entity)
     } });

package/dist/src/generated/waterx_account/direct_rule.d.ts

@@ -30,19 +30,19 @@
  * ```
  */
 import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
-import { type Transaction } from '@mysten/sui/transactions';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 export declare const DirectRule: MoveStruct<{
     dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
 }, "@waterx/account::direct_rule::DirectRule">;
 export interface ConsumeDepositDirectArguments {
     registry: RawTransactionArgument<string>;
-    req: RawTransactionArgument<string>;
+    req: TransactionArgument;
 }
 export interface ConsumeDepositDirectOptions {
     package?: string;
     arguments: ConsumeDepositDirectArguments | [
         registry: RawTransactionArgument<string>,
-        req: RawTransactionArgument<string>
+        req: TransactionArgument
     ];
     typeArguments: [
         string
@@ -55,13 +55,13 @@ export interface ConsumeDepositDirectOptions {
 export declare function consumeDepositDirect(options: ConsumeDepositDirectOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface ConsumeWithdrawDirectArguments {
     registry: RawTransactionArgument<string>;
-    req: RawTransactionArgument<string>;
+    req: TransactionArgument;
 }
 export interface ConsumeWithdrawDirectOptions {
     package?: string;
     arguments: ConsumeWithdrawDirectArguments | [
         registry: RawTransactionArgument<string>,
-        req: RawTransactionArgument<string>
+        req: TransactionArgument
     ];
     typeArguments: [
         string

package/dist/src/generated/waterx_account/events.d.ts

@@ -55,6 +55,16 @@ export declare const ProtocolDelisted: MoveStruct<{
         name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
     }, "std::type_name::TypeName">;
 }, "@waterx/account::events::ProtocolDelisted">;
+export declare const ProtocolPaused: MoveStruct<{
+    protocol: MoveStruct<{
+        name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    }, "std::type_name::TypeName">;
+}, "@waterx/account::events::ProtocolPaused">;
+export declare const ProtocolUnpaused: MoveStruct<{
+    protocol: MoveStruct<{
+        name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    }, "std::type_name::TypeName">;
+}, "@waterx/account::events::ProtocolUnpaused">;
 export declare const ProtocolAssetAllowed: MoveStruct<{
     protocol: MoveStruct<{
         name: import("@mysten/sui/bcs").BcsType<string, string, "string">;

package/dist/src/generated/waterx_account/events.js

@@ -4,31 +4,6 @@
 import { MoveStruct } from "../utils/index.js";
 import { bcs } from '@mysten/sui/bcs';
 import * as type_name from "./deps/std/type_name.js";
-import * as type_name_1 from "./deps/std/type_name.js";
-import * as type_name_2 from "./deps/std/type_name.js";
-import * as type_name_3 from "./deps/std/type_name.js";
-import * as type_name_4 from "./deps/std/type_name.js";
-import * as type_name_5 from "./deps/std/type_name.js";
-import * as type_name_6 from "./deps/std/type_name.js";
-import * as type_name_7 from "./deps/std/type_name.js";
-import * as type_name_8 from "./deps/std/type_name.js";
-import * as type_name_9 from "./deps/std/type_name.js";
-import * as type_name_10 from "./deps/std/type_name.js";
-import * as type_name_11 from "./deps/std/type_name.js";
-import * as type_name_12 from "./deps/std/type_name.js";
-import * as type_name_13 from "./deps/std/type_name.js";
-import * as type_name_14 from "./deps/std/type_name.js";
-import * as type_name_15 from "./deps/std/type_name.js";
-import * as type_name_16 from "./deps/std/type_name.js";
-import * as type_name_17 from "./deps/std/type_name.js";
-import * as type_name_18 from "./deps/std/type_name.js";
-import * as type_name_19 from "./deps/std/type_name.js";
-import * as type_name_20 from "./deps/std/type_name.js";
-import * as type_name_21 from "./deps/std/type_name.js";
-import * as type_name_22 from "./deps/std/type_name.js";
-import * as type_name_23 from "./deps/std/type_name.js";
-import * as type_name_24 from "./deps/std/type_name.js";
-import * as type_name_25 from "./deps/std/type_name.js";
 const $moduleName = '@waterx/account::events';
 export const AccountCreated = new MoveStruct({ name: `${$moduleName}::AccountCreated`, fields: {
         owner: bcs.Address,
@@ -67,73 +42,79 @@ export const DelegateProtocolPermissionSet = new MoveStruct({ name: `${$moduleNa
 export const DelegateProtocolPermissionUnset = new MoveStruct({ name: `${$moduleName}::DelegateProtocolPermissionUnset`, fields: {
         account_object_address: bcs.Address,
         delegate: bcs.Address,
-        protocol: type_name_1.TypeName
+        protocol: type_name.TypeName
     } });
 export const ProtocolWhitelisted = new MoveStruct({ name: `${$moduleName}::ProtocolWhitelisted`, fields: {
-        protocol: type_name_2.TypeName
+        protocol: type_name.TypeName
     } });
 export const ProtocolDelisted = new MoveStruct({ name: `${$moduleName}::ProtocolDelisted`, fields: {
-        protocol: type_name_3.TypeName
+        protocol: type_name.TypeName
+    } });
+export const ProtocolPaused = new MoveStruct({ name: `${$moduleName}::ProtocolPaused`, fields: {
+        protocol: type_name.TypeName
+    } });
+export const ProtocolUnpaused = new MoveStruct({ name: `${$moduleName}::ProtocolUnpaused`, fields: {
+        protocol: type_name.TypeName
     } });
 export const ProtocolAssetAllowed = new MoveStruct({ name: `${$moduleName}::ProtocolAssetAllowed`, fields: {
-        protocol: type_name_4.TypeName,
-        asset: type_name_5.TypeName
+        protocol: type_name.TypeName,
+        asset: type_name.TypeName
     } });
 export const ProtocolAssetDisallowed = new MoveStruct({ name: `${$moduleName}::ProtocolAssetDisallowed`, fields: {
-        protocol: type_name_6.TypeName,
-        asset: type_name_7.TypeName
+        protocol: type_name.TypeName,
+        asset: type_name.TypeName
     } });
 export const DepositPolicyRegistered = new MoveStruct({ name: `${$moduleName}::DepositPolicyRegistered`, fields: {
-        token_type: type_name_8.TypeName,
-        policy: type_name_9.TypeName
+        token_type: type_name.TypeName,
+        policy: type_name.TypeName
     } });
 export const DepositPolicyUnregistered = new MoveStruct({ name: `${$moduleName}::DepositPolicyUnregistered`, fields: {
-        token_type: type_name_10.TypeName,
-        policy: type_name_11.TypeName
+        token_type: type_name.TypeName,
+        policy: type_name.TypeName
     } });
 export const WithdrawPolicyRegistered = new MoveStruct({ name: `${$moduleName}::WithdrawPolicyRegistered`, fields: {
-        token_type: type_name_12.TypeName,
-        policy: type_name_13.TypeName
+        token_type: type_name.TypeName,
+        policy: type_name.TypeName
     } });
 export const WithdrawPolicyUnregistered = new MoveStruct({ name: `${$moduleName}::WithdrawPolicyUnregistered`, fields: {
-        token_type: type_name_14.TypeName,
-        policy: type_name_15.TypeName
+        token_type: type_name.TypeName,
+        policy: type_name.TypeName
     } });
 export const DepositRequested = new MoveStruct({ name: `${$moduleName}::DepositRequested`, fields: {
         account_object_address: bcs.Address,
-        token_type: type_name_16.TypeName,
+        token_type: type_name.TypeName,
         amount: bcs.u64()
     } });
 export const DepositConsumed = new MoveStruct({ name: `${$moduleName}::DepositConsumed`, fields: {
         account_object_address: bcs.Address,
-        token_type: type_name_17.TypeName,
-        policy: type_name_18.TypeName,
+        token_type: type_name.TypeName,
+        policy: type_name.TypeName,
         amount: bcs.u64()
     } });
 export const WithdrawRequested = new MoveStruct({ name: `${$moduleName}::WithdrawRequested`, fields: {
         account_object_address: bcs.Address,
-        token_type: type_name_19.TypeName,
+        token_type: type_name.TypeName,
         amount: bcs.u64(),
         requested_by: bcs.Address,
         recipient: bcs.Address
     } });
 export const WithdrawConsumed = new MoveStruct({ name: `${$moduleName}::WithdrawConsumed`, fields: {
         account_object_address: bcs.Address,
-        token_type: type_name_20.TypeName,
-        policy: type_name_21.TypeName,
+        token_type: type_name.TypeName,
+        policy: type_name.TypeName,
         amount: bcs.u64(),
         recipient: bcs.Address
     } });
 export const TakenByProtocol = new MoveStruct({ name: `${$moduleName}::TakenByProtocol`, fields: {
         account_object_address: bcs.Address,
-        protocol: type_name_22.TypeName,
-        token_type: type_name_23.TypeName,
+        protocol: type_name.TypeName,
+        token_type: type_name.TypeName,
         amount: bcs.u64()
     } });
 export const ReturnedByProtocol = new MoveStruct({ name: `${$moduleName}::ReturnedByProtocol`, fields: {
         account_object_address: bcs.Address,
-        protocol: type_name_24.TypeName,
-        token_type: type_name_25.TypeName,
+        protocol: type_name.TypeName,
+        token_type: type_name.TypeName,
         amount: bcs.u64()
     } });
 export const ManagerAdded = new MoveStruct({ name: `${$moduleName}::ManagerAdded`, fields: {

package/dist/src/generated/waterx_constant_rule/constant_rule.d.ts

@@ -0,0 +1,68 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+export declare const ConstantRule: MoveStruct<{
+    dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@waterx/constant-rule::constant_rule::ConstantRule">;
+export declare const Config: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** Ticker (e.g. `b"USD".to_string()`) → constant `Float` price returned by `feed`. */
+    prices: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: string;
+            value: {
+                value: string;
+            };
+        }[], Iterable<{
+            key: string;
+            value: {
+                value: string | number | bigint;
+            };
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<string, bucket_v2_framework::float::Float>">;
+}, "@waterx/constant-rule::constant_rule::Config">;
+export declare const ConstantPriceSet: MoveStruct<{
+    symbol: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    scaled_price: import("@mysten/sui/bcs").BcsType<string | null, string | number | bigint | null | undefined, "Option<u128>">;
+}, "@waterx/constant-rule::constant_rule::ConstantPriceSet">;
+export interface FeedArguments {
+    collector: TransactionArgument;
+    config: RawTransactionArgument<string>;
+}
+export interface FeedOptions {
+    package?: string;
+    arguments: FeedArguments | [
+        collector: TransactionArgument,
+        config: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Contributes the configured constant for `collector.symbol()` to the
+ * `PriceCollector`. Abstains (records `none`) when no constant is configured so
+ * other rules in the same collector can still satisfy `weight_threshold`.
+ */
+export declare function feed(options: FeedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetConstantPriceArguments {
+    config: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+    scaledPrice: RawTransactionArgument<number | bigint | null>;
+}
+export interface SetConstantPriceOptions {
+    package?: string;
+    arguments: SetConstantPriceArguments | [
+        config: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>,
+        scaledPrice: RawTransactionArgument<number | bigint | null>
+    ];
+}
+/**
+ * Sets the constant `Float` price for `symbol` (passed as the raw 1e9-scaled
+ * `u128`). Passing `none` removes the entry. Emits `ConstantPriceSet`.
+ */
+export declare function setConstantPrice(options: SetConstantPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/src/generated/waterx_constant_rule/constant_rule.js

@@ -0,0 +1,59 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as vec_map from "./deps/sui/vec_map.js";
+import * as float from "./deps/bucket_v2_framework/float.js";
+const $moduleName = '@waterx/constant-rule::constant_rule';
+export const ConstantRule = new MoveStruct({ name: `${$moduleName}::ConstantRule`, fields: {
+        dummy_field: bcs.bool()
+    } });
+export const Config = new MoveStruct({ name: `${$moduleName}::Config`, fields: {
+        id: bcs.Address,
+        /** Ticker (e.g. `b"USD".to_string()`) → constant `Float` price returned by `feed`. */
+        prices: vec_map.VecMap(bcs.string(), float.Float)
+    } });
+export const ConstantPriceSet = new MoveStruct({ name: `${$moduleName}::ConstantPriceSet`, fields: {
+        symbol: bcs.string(),
+        scaled_price: bcs.option(bcs.u128())
+    } });
+/**
+ * Contributes the configured constant for `collector.symbol()` to the
+ * `PriceCollector`. Abstains (records `none`) when no constant is configured so
+ * other rules in the same collector can still satisfy `weight_threshold`.
+ */
+export function feed(options) {
+    const packageAddress = options.package ?? '@waterx/constant-rule';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["collector", "config"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'constant_rule',
+        function: 'feed',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Sets the constant `Float` price for `symbol` (passed as the raw 1e9-scaled
+ * `u128`). Passing `none` removes the entry. Emits `ConstantPriceSet`.
+ */
+export function setConstantPrice(options) {
+    const packageAddress = options.package ?? '@waterx/constant-rule';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String',
+        '0x1::option::Option<u128>'
+    ];
+    const parameterNames = ["config", "Cap", "symbol", "scaledPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'constant_rule',
+        function: 'set_constant_price',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/dist/src/generated/waterx_constant_rule/deps/bucket_v2_framework/float.d.ts

@@ -0,0 +1,8 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Module for floating points */
+import { MoveStruct } from '../../../utils/index.ts';
+export declare const Float: MoveStruct<{
+    value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+}, "bucket_v2_framework::float::Float">;

package/dist/src/generated/waterx_constant_rule/deps/bucket_v2_framework/float.js

@@ -0,0 +1,10 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Module for floating points */
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'bucket_v2_framework::float';
+export const Float = new MoveStruct({ name: `${$moduleName}::Float`, fields: {
+        value: bcs.u128()
+    } });

package/dist/src/generated/waterx_constant_rule/deps/sui/vec_map.d.ts

@@ -0,0 +1,36 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.ts';
+/** An entry in the map */
+export declare function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]): MoveStruct<{
+    key: K;
+    value: V;
+}, `0x2::vec_map::Entry<${K["name"]}, ${V["name"]}>`>;
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export declare function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]): MoveStruct<{
+    contents: BcsType<{
+        key: K extends BcsType<infer U, any, string> ? U : never;
+        value: V extends BcsType<infer U, any, string> ? U : never;
+    }[], Iterable<{
+        key: K extends BcsType<any, infer U_1, string> ? U_1 : never;
+        value: V extends BcsType<any, infer U_1, string> ? U_1 : never;
+    }> & {
+        length: number;
+    }, string>;
+}, `0x2::vec_map::VecMap<${K["name"]}, ${V["name"]}>`>;

package/dist/src/generated/waterx_constant_rule/deps/sui/vec_map.js

@@ -0,0 +1,27 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from "../../../utils/index.js";
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry(...typeParameters) {
+    return new MoveStruct({ name: `${$moduleName}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+            key: typeParameters[0],
+            value: typeParameters[1]
+        } });
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap(...typeParameters) {
+    return new MoveStruct({ name: `${$moduleName}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+            contents: bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+        } });
+}

package/dist/src/generated/waterx_credit/credit_registry.d.ts

@@ -3,7 +3,7 @@
  **************************************************************/
 import { MoveTuple, MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
 import { type BcsType } from '@mysten/sui/bcs';
-import { type Transaction } from '@mysten/sui/transactions';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 export declare const CapKey: MoveTuple<readonly [BcsType<boolean, boolean, "bool">], "@waterx/credit::credit_registry::CapKey">;
 export declare const Mint: MoveStruct<{
     amount: BcsType<string, string | number | bigint, "u64">;
@@ -428,7 +428,7 @@ export interface CollectArguments<M extends BcsType<any>> {
     Witness: RawTransactionArgument<M>;
     version: RawTransactionArgument<number>;
     memo: RawTransactionArgument<string>;
-    balance: RawTransactionArgument<string>;
+    balance: TransactionArgument;
 }
 export interface CollectOptions<M extends BcsType<any>> {
     package?: string;
@@ -437,7 +437,7 @@ export interface CollectOptions<M extends BcsType<any>> {
         Witness: RawTransactionArgument<M>,
         version: RawTransactionArgument<number>,
         memo: RawTransactionArgument<string>,
-        balance: RawTransactionArgument<string>
+        balance: TransactionArgument
     ];
     typeArguments: [
         string,
@@ -449,13 +449,13 @@ export interface CollectOptions<M extends BcsType<any>> {
 export declare function collect<M extends BcsType<any>>(options: CollectOptions<M>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface ClaimArguments {
     registry: RawTransactionArgument<string>;
-    request: RawTransactionArgument<string>;
+    request: TransactionArgument;
 }
 export interface ClaimOptions {
     package?: string;
     arguments: ClaimArguments | [
         registry: RawTransactionArgument<string>,
-        request: RawTransactionArgument<string>
+        request: TransactionArgument
     ];
     typeArguments: [
         string,
@@ -498,22 +498,22 @@ export interface ModuleConfigMapOptions {
 }
 export declare function moduleConfigMap(options: ModuleConfigMapOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface LimitedSupplyArguments {
-    config: RawTransactionArgument<string>;
+    config: TransactionArgument;
 }
 export interface LimitedSupplyOptions {
     package?: string;
     arguments: LimitedSupplyArguments | [
-        config: RawTransactionArgument<string>
+        config: TransactionArgument
     ];
 }
 export declare function limitedSupply(options: LimitedSupplyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface ValidVersionsArguments {
-    config: RawTransactionArgument<string>;
+    config: TransactionArgument;
 }
 export interface ValidVersionsOptions {
     package?: string;
     arguments: ValidVersionsArguments | [
-        config: RawTransactionArgument<string>
+        config: TransactionArgument
     ];
 }
 export declare function validVersions(options: ValidVersionsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;