@waterx/predict-sdk 0.1.0

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

@@ -0,0 +1,1487 @@
+/**************************************************************
+ * 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<USDX>` and credits the account via `put<USDX, 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 table from "./deps/sui/table.js";
+import * as table_1 from "./deps/sui/table.js";
+import * as vec_set from "./deps/sui/vec_set.js";
+import * as type_name from "./deps/std/type_name.js";
+import * as vec_map from "./deps/sui/vec_map.js";
+import * as type_name_1 from "./deps/std/type_name.js";
+import * as type_name_2 from "./deps/std/type_name.js";
+import * as vec_map_1 from "./deps/sui/vec_map.js";
+import * as type_name_3 from "./deps/std/type_name.js";
+import * as type_name_4 from "./deps/std/type_name.js";
+import * as vec_map_2 from "./deps/sui/vec_map.js";
+import * as type_name_5 from "./deps/std/type_name.js";
+import * as vec_set_1 from "./deps/sui/vec_set.js";
+import * as vec_set_2 from "./deps/sui/vec_set.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_map_4 from "./deps/sui/vec_map.js";
+import * as type_name_7 from "./deps/std/type_name.js";
+import * as balance_1 from "./deps/sui/balance.js";
+import * as balance_2 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 AccountRegistry = new MoveStruct({ name: `${$moduleName}::AccountRegistry`, fields: {
+        id: bcs.Address,
+        accounts: table.Table,
+        owner_index: table_1.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>`).
+         * Witness-construction privacy alone is not sufficient — any package can deploy
+         * its own witness type, so without this whitelist any deployed module could drain
+         * any account. Admin opts each protocol in once via
+         * `whitelist_protocol<P>(&AdminCap, registry, clock)`.
+         */
+        protocol_whitelist: 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`.
+         */
+        deposit_policies: vec_map.VecMap(type_name_1.TypeName, type_name_2.TypeName),
+        /**
+         * `T → registered WithdrawPolicy witness TypeName`. Symmetric to
+         * `deposit_policies` for `request_withdraw<T>` / `consume_withdraw`.
+         */
+        withdraw_policies: vec_map_1.VecMap(type_name_3.TypeName, type_name_4.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_2.VecMap(type_name_5.TypeName, bcs.u64()),
+        allowed_versions: vec_set_1.VecSet(bcs.u16()),
+        managers: vec_set_2.VecSet(bcs.Address),
+        paused: bcs.bool()
+    } });
+export const BalanceKey = new MoveTuple({ name: `${$moduleName}::BalanceKey<phantom T>`, fields: [bcs.bool()] });
+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_3.VecMap(type_name_6.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_4.VecMap(type_name_7.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_2.Balance,
+        recipient: bcs.Address,
+        extra_data: bcs.vector(bcs.u8())
+    } });
+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 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: add witness type `P` to the protocol whitelist. Only modules whose
+ * witness type is whitelisted can call `take` / `put` and the witness-gated
+ * data-slot helpers. 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` 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
+    });
+}
+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
+    });
+}
+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
+    });
+}
+export function depositPolicy(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'deposit_policy',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function withdrawPolicy(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'withdraw_policy',
+        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 the deposit policy for `T`. Only the module
+ * that defines `P` can construct one, so this binds `T`'s deposit flow exclusively
+ * to that module. Aborts if `T` is already registered — admin must
+ * `unregister_deposit_policy<T>` first to swap.
+ */
+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 the deposit policy for `T`. Existing `Balance<T>` on accounts is
+ * unaffected; only new `request_deposit<T>` is blocked.
+ */
+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),
+    });
+}
+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),
+    });
+}
+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
+    });
+}
+/**
+ * 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 `Coin<X>`, NFTs, or any other transferable object
+ * externally transferred to the account address. 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. Bypasses the deposit-policy flow — use this for tokens / objects
+ * that have no registered deposit policy (e.g. reward coins TTO'd via
+ * `transfer_coin` from a protocol's claim path).
+ */
+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
+    });
+}
+/**
+ * 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
+    });
+}