@waterx/sdk 2.4.1 → 3.0.0

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

@@ -1,1758 +0,0 @@
-/**************************************************************
- * 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 balance_1 from "./deps/sui/balance.js";
-import * as sheet from "./deps/bucket_v2_framework/sheet.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.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.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.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.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()] });
-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.VecMap(type_name.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.VecMap(type_name.TypeName, bcs.u64())
-    } });
-export const DepositRequest = new MoveStruct({ name: `${$moduleName}::DepositRequest<phantom T>`, fields: {
-        account_id: bcs.Address,
-        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_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()
-    } });
-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: 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
- * 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
-    });
-}