@waterx/sdk 2.1.0

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

@@ -0,0 +1,1723 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * Generalized multi-account framework for the WaterX ecosystem.
+ *
+ * Pure custody layer. Accounts hold per-T `Balance<T>` as dynamic fields keyed by
+ * `BalanceKey<T>()`, with a `VecMap<TypeName, u64>` mirror on each `Account` for
+ * fast enumeration. External flow in/out is mediated by hot-potato
+ * `DepositRequest<T>` / `WithdrawRequest<T>` that the framework issues; a
+ * registered policy module destroys the potato with its own witness and decides
+ * what final asset to put back into the account (e.g. a PSM policy turns
+ * `Coin<USDC>` into `Balance<USD>` and credits the account via `put<USD, P>`).
+ *
+ * Internal protocol ↔ account flow stays witness-gated via `take<T, P>` /
+ * `put<T, P>` with no policy registration involved — the protocol module's witness
+ * is the only authority needed, since only that module can construct a value of
+ * its witness type.
+ *
+ * Types of T:
+ *
+ * - Has registered deposit policy → `request_deposit<T>` works.
+ * - Has registered withdraw policy → `request_withdraw<T>` works.
+ * - Neither → "Parkable". Coins can sit on the account address via
+ *   `transfer_coin<T>` or external `transfer::public_transfer`, but nothing the
+ *   framework does will fold them into the account until a policy is registered
+ *   (or owner drains via `receive_coin`).
+ */
+import { MoveStruct, MoveTuple, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as object_table from "./deps/sui/object_table.js";
+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()
+    } });
+export const AdminCap = new MoveStruct({ name: `${$moduleName}::AdminCap`, fields: {
+        id: bcs.Address
+    } });
+export const WaterXAccount = new MoveStruct({ name: `${$moduleName}::WaterXAccount`, fields: {
+        dummy_field: bcs.bool()
+    } });
+export const AccountRegistry = new MoveStruct({ name: `${$moduleName}::AccountRegistry`, fields: {
+        id: bcs.Address,
+        /**
+         * `ObjectTable` (not plain `Table`) so each `Account` retains a distinct on-chain
+         * address that off-chain callers can query directly via `getObject(account_id)`
+         * instead of walking dynamic-field handles on the registry UID.
+         */
+        accounts: object_table.ObjectTable,
+        owner_index: table.Table,
+        /**
+         * Admin-managed whitelist of protocol witness types allowed to move funds
+         * (`take<T, P>` / `put<T, P>`) and mutate per-account protocol data
+         * (`new_data<P, D>` / `borrow_data_mut<P, D>` / `remove_data<P, D>`). For each
+         * whitelisted `P`, the value is the set of asset types `T` that protocol is
+         * allowed to draw via `take<T, P>` — admin opts each pair in via two phases:
+         * `whitelist_protocol<P>(registry, &AdminCap)` registers `P` with an empty asset
+         * set, then `allow_protocol_asset<P, T>(registry,  &AdminCap)` adds each T.
+         *
+         * Gates:
+         *
+         * - `take<T, P>` requires both `P` whitelisted AND `T` in `protocol_whitelist[P]`
+         *   (plus per-account auth on the caller).
+         * - `put<T, P>` requires only `P` whitelisted. The T-gate stays open even after
+         *   `disallow_protocol_asset<P, T>`, so existing positions can always close.
+         * - `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)),
+        /**
+         * `T → registered DepositPolicy witness TypeName`. Presence means
+         * `request_deposit<T>` / `request_deposit_from_receivings<T>` are permitted; only
+         * the module that defines the registered witness type can call
+         * `consume_deposit<T, P>` to unwrap the resulting `DepositRequest<T>`. Deposit
+         * policy registration is independent of `protocol_whitelist` — a policy can be the
+         * _consumer_ of a request without being allowed to `take`/`put`.
+         * `T → set of DepositPolicy witness TypeNames`. Multiple policies can be
+         * registered per T to support extension (a new policy added alongside the old) and
+         * 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)),
+        /**
+         * `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)),
+        /**
+         * 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),
+        paused: bcs.bool()
+    } });
+export const VaultKey = new MoveTuple({ name: `${$moduleName}::VaultKey<phantom T>`, fields: [bcs.bool()] });
+export const Vault = new MoveStruct({ name: `${$moduleName}::Vault<phantom T>`, fields: {
+        balance: balance_1.Balance,
+        sheet: sheet.Sheet
+    } });
+export const ProtocolDataKey = new MoveTuple({ name: `${$moduleName}::ProtocolDataKey<phantom PROTOCOL>`, fields: [bcs.bool()] });
+export const Delegate = new MoveStruct({ name: `${$moduleName}::Delegate`, fields: {
+        delegate_address: bcs.Address,
+        alias: bcs.string(),
+        /** Framework-level action bitmap (PERM_WITHDRAW etc). */
+        permissions: bcs.u32(),
+        /**
+         * Per-protocol bitmap. Missing key → delegate cannot drive that protocol. Each
+         * 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()),
+        expires_at_ms: bcs.option(bcs.u64())
+    } });
+export const Account = new MoveStruct({ name: `${$moduleName}::Account`, fields: {
+        id: bcs.Address,
+        owner_address: bcs.Address,
+        alias: bcs.string(),
+        delegates: bcs.vector(Delegate),
+        /**
+         * Mirror of the per-T `Balance<T>` values stored as dynamic fields under
+         * `BalanceKey<T>()` on this UID. Always equals the matching stored balance's
+         * `value()`.
+         */
+        balances: vec_map_5.VecMap(type_name_8.TypeName, bcs.u64())
+    } });
+export const DepositRequest = new MoveStruct({ name: `${$moduleName}::DepositRequest<phantom T>`, fields: {
+        account_id: bcs.Address,
+        balance: balance_2.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,
+        recipient: bcs.Address,
+        extra_data: bcs.vector(bcs.u8())
+    } });
+export const AccountKey = new MoveStruct({ name: `${$moduleName}::AccountKey`, fields: {
+        owner: bcs.Address,
+        index: bcs.u64()
+    } });
+export function permNone(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'perm_none',
+    });
+}
+export function permWithdraw(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'perm_withdraw',
+    });
+}
+export function permManageDelegates(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'perm_manage_delegates',
+    });
+}
+export function permReceive(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'perm_receive',
+    });
+}
+export function permAll(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'perm_all',
+    });
+}
+export function aliasMaxLength(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'alias_max_length',
+    });
+}
+export function maxAccountsPerOwner(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'max_accounts_per_owner',
+    });
+}
+export function maxDelegatesPerAccount(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'max_delegates_per_account',
+    });
+}
+export function maxProtocolPermsPerDelegate(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'max_protocol_perms_per_delegate',
+    });
+}
+export function assertVersion(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'assert_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function isVersionAllowed(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        'u16'
+    ];
+    const parameterNames = ["registry", "v"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'is_version_allowed',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function allowVersion(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["registry", "_", "v"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'allow_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function disallowVersion(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["registry", "_", "v"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'disallow_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function isPaused(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'is_paused',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function assertNotPaused(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'assert_not_paused',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function pause(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "managerRequest"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'pause',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function unpause(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'unpause',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function isManager(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        'address'
+    ];
+    const parameterNames = ["registry", "addr"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'is_manager',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function managers(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'managers',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function addManager(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["registry", "_", "manager"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'add_manager',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function removeManager(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["registry", "_", "manager"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'remove_manager',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function isProtocolWhitelisted(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'is_protocol_whitelisted',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function isProtocolAssetAllowed(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'is_protocol_asset_allowed',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function protocolWhitelist(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'protocol_whitelist',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Admin: register witness type `P` with an empty asset set. After this, admin must
+ * call `allow_protocol_asset<P, T>` for each T the protocol may draw. Strict —
+ * aborts if `P` is already listed.
+ */
+export function whitelistProtocol(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'whitelist_protocol',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin: remove witness type `P` (and its entire asset set) from the protocol
+ * whitelist. After this, every `take<T, P>` / `put<T, P>` and witness-gated
+ * data-slot call aborts. Existing data slots and protocol-held balances are
+ * untouched — only future calls are blocked, so admin can pause a misbehaving
+ * protocol without stranding state on accounts.
+ */
+export function delistProtocol(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'delist_protocol',
+        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
+ * whitelisted or if `T` is already in the set.
+ */
+export function allowProtocolAsset(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'allow_protocol_asset',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin: remove asset type `T` from protocol `P`'s allowed-asset set. Blocks
+ * future `take<T, P>` calls but `put<T, P>` on `T` stays open so existing
+ * positions can always close. Aborts if `P` is not whitelisted or if `T` is not in
+ * the set.
+ */
+export function disallowProtocolAsset(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'disallow_protocol_asset',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Returns true if `T` has at least one deposit policy registered. Used by
+ * `request_deposit<T>` to gate inflow and by `withdraw_from_funds<T>` to refuse
+ * policy-managed types.
+ */
+export function isDepositPolicyRegistered(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'is_deposit_policy_registered',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns true if `T` has at least one withdraw policy registered. */
+export function isWithdrawPolicyRegistered(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'is_withdraw_policy_registered',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Returns true if the specific witness `P` is one of T's registered deposit
+ * policies. `consume_deposit<T, P>` aborts `EPolicyMismatch` when this would
+ * return false.
+ */
+export function isDepositPolicyRegisteredFor(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'is_deposit_policy_registered_for',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function isWithdrawPolicyRegisteredFor(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'is_withdraw_policy_registered_for',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Returns the full set of deposit-policy witness typenames registered for `T`, as
+ * a `vector<TypeName>` copy (TypeName is `copy + drop +  store`, so this is
+ * cheap). Aborts if T has no policies. Off-chain consumers wanting iteration
+ * without the copy should walk the full `deposit_policies()` map instead.
+ */
+export function depositPoliciesFor(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'deposit_policies_for',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function withdrawPoliciesFor(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'withdraw_policies_for',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function depositPolicies(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'deposit_policies',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function withdrawPolicies(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'withdraw_policies',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Admin: register witness type `P` as a deposit policy for `T`. Multiple policies
+ * can coexist per T to support extension (a new module added alongside the old)
+ * and migration (consumers switch one at a time). Idempotent — adding an
+ * already-registered `(T, P)` pair is a silent no-op so admin can re-run deploy
+ * scripts safely.
+ */
+export function registerDepositPolicy(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'register_deposit_policy',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function registerWithdrawPolicy(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'register_withdraw_policy',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin: remove `P` from T's deposit-policy set. Other registered policies for `T`
+ * keep working. If `P` is the last entry, the `T` key is cleaned up so
+ * `is_deposit_policy_registered<T>` returns false. Aborts if `(T, P)` isn't
+ * registered.
+ */
+export function unregisterDepositPolicy(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'unregister_deposit_policy',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function unregisterWithdrawPolicy(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'unregister_withdraw_policy',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function createAccount(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["registry", "senderRequest", "alias"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'create_account',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Off-chain view: compute the address a future `create_account` call will produce
+ * for `(owner, index)`. Mirrors `derived_object::derive_address` keyed on
+ * `AccountKey`. Useful for SDKs that want to address an account before it exists,
+ * or to discover all of an owner's accounts by iterating index from 0 up to
+ * `MAX_ACCOUNTS_PER_OWNER` and checking `has_account` against each derived
+ * address.
+ */
+export function deriveAccountAddress(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        'address',
+        'u64'
+    ];
+    const parameterNames = ["registry", "owner", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'derive_account_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function setAlias(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        '0x1::string::String'
+    ];
+    const parameterNames = ["registry", "senderRequest", "accountId", "alias"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'set_alias',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function addDelegate(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        'address',
+        '0x1::string::String',
+        'u32',
+        '0x1::option::Option<u64>',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["registry", "senderRequest", "accountId", "delegateAddress", "alias", "permissions", "expiresAtMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'add_delegate',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Owner-only for live delegates; permissionless once the delegate has passed its
+ * `expires_at_ms`. Lets a keeper / bot prune dead entries without bothering the
+ * owner — an expired delegate carries no authority, so removing it is purely
+ * janitorial.
+ */
+export function removeDelegate(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        'address',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["registry", "senderRequest", "accountId", "delegateAddress"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'remove_delegate',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function updateDelegate(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        'address',
+        '0x1::string::String',
+        'u32',
+        '0x1::option::Option<u64>',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["registry", "senderRequest", "accountId", "delegateAddress", "alias", "permissions", "expiresAtMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'update_delegate',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function setDelegateProtocolPermission(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        'address',
+        'u32',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["registry", "senderRequest", "accountId", "delegateAddress", "permissions"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'set_delegate_protocol_permission',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function unsetDelegateProtocolPermission(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        'address',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["registry", "senderRequest", "accountId", "delegateAddress"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'unset_delegate_protocol_permission',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Wraps an in-PTB `Coin<T>` into a `DepositRequest<T>` for the account.
+ * Permissionless — anyone can pay into any account, since the policy (not the
+ * framework) decides what the eventual credited asset is. `T` must have a
+ * registered deposit policy; aborts otherwise.
+ */
+export function requestDeposit(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        null,
+        'vector<u8>'
+    ];
+    const parameterNames = ["registry", "accountId", "coin", "extraData"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'request_deposit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Drains `Receiving<Coin<T>>` entries addressed to the account's UID into a single
+ * merged `Coin<T>` and wraps it as a `DepositRequest<T>`. Used when a user (or
+ * anyone) previously `transfer_coin`-ed a `Coin<T>` onto the account address and
+ * now wants to fold it into custody. Permissionless for the same reason as
+ * `request_deposit<T>`.
+ */
+export function requestDepositFromReceivings(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        'vector<null>',
+        'vector<u8>'
+    ];
+    const parameterNames = ["registry", "accountId", "receivings", "extraData"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'request_deposit_from_receivings',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Drains every `Balance<T>` sitting at the account's UID-derived address in Sui's
+ * native funds accumulator and wraps the total into a single `DepositRequest<T>`.
+ * Useful for accounts that receive `Coin<T>` via `0x2::balance::send_funds<T>` (or
+ * any path that lands T at `account_id.to_address()` directly) and want it folded
+ * into framework custody through the deposit-policy pipeline.
+ *
+ * The total drained equals `settled_funds_value<T>(root, addr)` as of the last
+ * consensus commit — within the writing PTB itself, that read returns the pre-tx
+ * value, so SDKs should treat this as a between-tx drain. Permissionless
+ * (crediting an account is always allowed), pause-free, requires `T` to have a
+ * registered deposit policy. Returns a deposit request even when the address holds
+ * zero T (the carried balance is `Balance::zero()` in that case) — callers can
+ * short-circuit off-chain by checking `settled_funds_value` first.
+ */
+export function requestDepositFromFunds(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        null,
+        'vector<u8>'
+    ];
+    const parameterNames = ["registry", "accountId", "accumulatorRoot", "extraData"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'request_deposit_from_funds',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Policy-side unwrap. Verifies that `P` is the registered deposit policy for `T`,
+ * then destructures the hot potato. The policy module is responsible for what
+ * happens next — typically swap / convert `Balance<T>` to some `Balance<T_OUT>`
+ * and call `put<T_OUT, P>` to credit the account.
+ */
+export function consumeDeposit(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        `${options.typeArguments[1]}`
+    ];
+    const parameterNames = ["registry", "req", "Witness"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'consume_deposit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Debits `amount` of the account's stored `Balance<T>` and packages it into a
+ * `WithdrawRequest<T>` for the registered withdraw policy. Auth (`PERM_WITHDRAW`
+ * on `T`'s account) and pause are checked here, not in `consume_withdraw`.
+ */
+export function requestWithdraw(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        'u64',
+        'address',
+        'vector<u8>',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["registry", "senderRequest", "accountId", "amount", "recipient", "extraData"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'request_withdraw',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Policy-side unwrap. Verifies that `P` is the registered withdraw policy for `T`,
+ * then destructures the hot potato. The policy module decides what to do with the
+ * `Balance<T>` (transfer to `recipient` as `Coin<T>`, swap to another asset and
+ * transfer, queue for later settlement, etc.).
+ */
+export function consumeWithdraw(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        `${options.typeArguments[1]}`
+    ];
+    const parameterNames = ["registry", "req", "Witness"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'consume_withdraw',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * TTOs a `Coin<T>` to the account's UID address. The coin sits there until someone
+ * calls `request_deposit_from_receivings<T>` (which requires a registered deposit
+ * policy that then folds the coin into the account's stored balance) or
+ * `receive<Coin<T>>` (owner / `PERM_RECEIVE` delegate, no policy needed). Useful
+ * for async / cross-PTB deposits and for routing protocol payouts (e.g. reward
+ * claims) into an account when `T` has no deposit policy.
+ */
+export function transferCoin(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        null
+    ];
+    const parameterNames = ["registry", "accountId", "coin"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'transfer_coin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Account-owner drain of a TTO'd object on the account's UID. Generic over
+ * `T: key + store` — works for NFTs, reward objects, or `Coin<X>` where `X` has no
+ * registered deposit policy.
+ *
+ * **Policy-managed Coin<X> is rejected.** If `T == Coin<X>` and `X` has a deposit
+ * policy registered, this aborts `EUseRequestDepositInstead` to keep policy-routed
+ * inflow on the deposit-policy pipeline — bypassing via `receive` would skip the
+ * conversion / authorization the policy is supposed to enforce. Use
+ * `request_deposit_from_receivings<X>` or `request_deposit_from_funds<X>` for
+ * inflow when X has a deposit policy.
+ *
+ * Auth: account owner or a `PERM_RECEIVE` delegate (kept separate from
+ * `PERM_WITHDRAW` so reward-collection rights don't imply balance-drain rights).
+ * Returns the received object to the caller's PTB.
+ */
+export function receive(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["registry", "senderRequest", "accountId", "receiving"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'receive',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Drains every `Balance<T>` sitting at the account's UID-derived address in Sui's
+ * native funds accumulator and returns it directly as a `Balance<T>`. Symmetric to
+ * `request_deposit_from_funds<T>`, but explicitly for `T` that has **no**
+ * registered deposit policy — policy-managed inflow must route through the
+ * deposit-policy pipeline instead. The intent is to let owners (or `PERM_WITHDRAW`
+ * delegates) pull policy-less inflow (reward tokens TTO'd via `send_funds`,
+ * miscellaneous `Balance<T>` the SDK parked at the address) straight out.
+ *
+ * Auth: same as `request_withdraw<T>` — `PERM_WITHDRAW` or owner. Aborts
+ * `EUseRequestDepositInstead` if `T` has a deposit policy registered. Pause-gated.
+ * Returns `Balance::zero<T>()` when the address holds no T.
+ */
+export function withdrawFromFunds(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["registry", "senderRequest", "accountId", "accumulatorRoot"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'withdraw_from_funds',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Splits `amount` of `Balance<T>` off `account_id` for protocol `P` to use. Three
+ * gates compose:
+ *
+ * 1.  **Witness privacy.** Only the module that defines `P` can produce a value of
+ *     `P`, so only that module can call `take<T, P>`.
+ * 2.  **Protocol whitelist.** `P` must be in `protocol_whitelist` (admin-managed).
+ *     Stops any deployed module that happens to own a `drop` witness from draining
+ *     accounts.
+ * 3.  **Per-account auth.** `sender_request.address()` must be the account's owner
+ *     OR a non-expired delegate — even a legitimate whitelisted protocol cannot
+ *     move funds out of an account that doesn't know the caller. This mirrors EOA
+ *     semantics: the account never pays out without the owner (or a delegated key)
+ *     signing. Per-action bit semantics on `protocol_permissions[P]` remain the
+ *     protocol's responsibility on top of this.
+ *
+ * No deposit/withdraw policy is consulted — `take` / `put` are the
+ * protocol↔account flow and orthogonal to the external deposit/withdraw path that
+ * policies own.
+ */
+export function take(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        'u64',
+        `${options.typeArguments[1]}`,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["registry", "senderRequest", "accountId", "amount", "Witness"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'take',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Joins `bal` into `account_id`'s stored `Balance<T>`. Symmetric to `take<T, P>`.
+ * Zero-value balances are silently destroyed.
+ */
+export function put(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        null,
+        `${options.typeArguments[1]}`
+    ];
+    const parameterNames = ["registry", "accountId", "bal", "Witness"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'put',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function hasAccount(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ];
+    const parameterNames = ["registry", "accountId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'has_account',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Returns `true` when `addr` is the account's owner or a non-expired delegate,
+ * regardless of permission bits. The framework's "is this address known to the
+ * account?" gate — per-action bit semantics are the protocol's responsibility on
+ * top of this.
+ */
+export function isAccountAuthorized(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        'address',
+        'u64'
+    ];
+    const parameterNames = ["registry", "accountId", "addr", "nowMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'is_account_authorized',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function accountCount(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        'address'
+    ];
+    const parameterNames = ["registry", "owner"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'account_count',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function accountIds(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        'address'
+    ];
+    const parameterNames = ["registry", "owner"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'account_ids',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Framework-level effective permissions (used by `request_withdraw`). Owner →
+ * `PERM_ALL`. Delegate → its `permissions` bitmap unless expired. Stranger →
+ * `PERM_NONE`.
+ */
+export function effectivePermissions(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        'address',
+        'u64'
+    ];
+    const parameterNames = ["registry", "accountId", "addr", "nowMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'effective_permissions',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function hasPermission(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        'address',
+        'u32',
+        'u64'
+    ];
+    const parameterNames = ["registry", "accountId", "addr", "permission", "nowMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'has_permission',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Per-protocol effective permissions (used by protocol modules). Owner →
+ * `PERM_ALL` for any protocol. Delegate → the bitmap stored at
+ * `protocol_permissions[TypeName(PROTOCOL)]`, or `PERM_NONE` if absent or expired.
+ * Stranger → `PERM_NONE`.
+ */
+export function effectiveProtocolPermissions(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        'address',
+        'u64'
+    ];
+    const parameterNames = ["registry", "accountId", "addr", "nowMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'effective_protocol_permissions',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function hasProtocolPermission(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        'address',
+        'u32',
+        'u64'
+    ];
+    const parameterNames = ["registry", "accountId", "addr", "permission", "nowMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'has_protocol_permission',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function accountBalance(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ];
+    const parameterNames = ["registry", "accountId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'account_balance',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function accountBalances(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ];
+    const parameterNames = ["registry", "accountId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'account_balances',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Total `Balance<T>` currently held across all accounts. Counter; not derived from
+ * iterating accounts. Excludes balance held by protocols (after `take`) and
+ * balance sitting in hot-potato requests in flight.
+ */
+export function balance(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'balance',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function accountOwner(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["account"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'account_owner',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function accountAlias(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["account"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'account_alias',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function accountId(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["account"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'account_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function accountAddress(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["account"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'account_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function accountDelegates(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["account"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'account_delegates',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function accountBalancesField(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["account"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'account_balances_field',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function delegateAddress(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["delegate"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'delegate_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function delegateAlias(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["delegate"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'delegate_alias',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function delegatePermissions(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["delegate"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'delegate_permissions',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function delegateProtocolPermissions(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["delegate"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'delegate_protocol_permissions',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function delegateExpiresAtMs(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["delegate"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'delegate_expires_at_ms',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function depositRequestAccountId(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["r"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'deposit_request_account_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function depositRequestBalance(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["r"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'deposit_request_balance',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function depositRequestAmount(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["r"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'deposit_request_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function depositRequestExtraData(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["r"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'deposit_request_extra_data',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function withdrawRequestAccountId(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["r"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'withdraw_request_account_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function withdrawRequestBalance(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["r"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'withdraw_request_balance',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function withdrawRequestAmount(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["r"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'withdraw_request_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function withdrawRequestRecipient(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["r"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'withdraw_request_recipient',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function withdrawRequestExtraData(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["r"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'withdraw_request_extra_data',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function newData(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        `${options.typeArguments[0]}`,
+        `${options.typeArguments[1]}`
+    ];
+    const parameterNames = ["registry", "accountId", "Witness", "data"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'new_data',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function borrowData(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ];
+    const parameterNames = ["registry", "accountId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'borrow_data',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function borrowDataMut(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        `${options.typeArguments[0]}`
+    ];
+    const parameterNames = ["registry", "accountId", "Witness"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'borrow_data_mut',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function hasData(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ];
+    const parameterNames = ["registry", "accountId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'has_data',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function removeData(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        `${options.typeArguments[0]}`
+    ];
+    const parameterNames = ["registry", "accountId", "Witness"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'remove_data',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}