@waterx/sdk 3.0.1 → 3.0.3

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

@@ -0,0 +1,1929 @@
+"use strict";
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountKey = exports.PausedProtocolsKey = exports.WithdrawRequest = exports.DepositRequest = exports.Account = exports.Delegate = exports.ProtocolDataKey = exports.Vault = exports.VaultKey = exports.AccountRegistry = exports.WaterXAccount = exports.AdminCap = exports.ACCOUNT = void 0;
+exports.permNone = permNone;
+exports.permWithdraw = permWithdraw;
+exports.permManageDelegates = permManageDelegates;
+exports.permReceive = permReceive;
+exports.permAll = permAll;
+exports.aliasMaxLength = aliasMaxLength;
+exports.maxAccountsPerOwner = maxAccountsPerOwner;
+exports.maxDelegatesPerAccount = maxDelegatesPerAccount;
+exports.maxProtocolPermsPerDelegate = maxProtocolPermsPerDelegate;
+exports.assertVersion = assertVersion;
+exports.isVersionAllowed = isVersionAllowed;
+exports.allowVersion = allowVersion;
+exports.disallowVersion = disallowVersion;
+exports.isPaused = isPaused;
+exports.assertNotPaused = assertNotPaused;
+exports.pause = pause;
+exports.unpause = unpause;
+exports.isManager = isManager;
+exports.managers = managers;
+exports.addManager = addManager;
+exports.removeManager = removeManager;
+exports.isProtocolWhitelisted = isProtocolWhitelisted;
+exports.isProtocolAssetAllowed = isProtocolAssetAllowed;
+exports.protocolWhitelist = protocolWhitelist;
+exports.whitelistProtocol = whitelistProtocol;
+exports.delistProtocol = delistProtocol;
+exports.pauseProtocol = pauseProtocol;
+exports.unpauseProtocol = unpauseProtocol;
+exports.isProtocolPaused = isProtocolPaused;
+exports.allowProtocolAsset = allowProtocolAsset;
+exports.disallowProtocolAsset = disallowProtocolAsset;
+exports.isDepositPolicyRegistered = isDepositPolicyRegistered;
+exports.isWithdrawPolicyRegistered = isWithdrawPolicyRegistered;
+exports.isDepositPolicyRegisteredFor = isDepositPolicyRegisteredFor;
+exports.isWithdrawPolicyRegisteredFor = isWithdrawPolicyRegisteredFor;
+exports.depositPoliciesFor = depositPoliciesFor;
+exports.withdrawPoliciesFor = withdrawPoliciesFor;
+exports.depositPolicies = depositPolicies;
+exports.withdrawPolicies = withdrawPolicies;
+exports.registerDepositPolicy = registerDepositPolicy;
+exports.registerWithdrawPolicy = registerWithdrawPolicy;
+exports.unregisterDepositPolicy = unregisterDepositPolicy;
+exports.unregisterWithdrawPolicy = unregisterWithdrawPolicy;
+exports.createAccount = createAccount;
+exports.deriveAccountAddress = deriveAccountAddress;
+exports.setAlias = setAlias;
+exports.addDelegate = addDelegate;
+exports.removeDelegate = removeDelegate;
+exports.updateDelegate = updateDelegate;
+exports.setDelegateProtocolPermission = setDelegateProtocolPermission;
+exports.unsetDelegateProtocolPermission = unsetDelegateProtocolPermission;
+exports.requestDeposit = requestDeposit;
+exports.requestDepositFromReceivings = requestDepositFromReceivings;
+exports.requestDepositFromFunds = requestDepositFromFunds;
+exports.consumeDeposit = consumeDeposit;
+exports.requestWithdraw = requestWithdraw;
+exports.consumeWithdraw = consumeWithdraw;
+exports.transferCoin = transferCoin;
+exports.receive = receive;
+exports.withdrawFromFunds = withdrawFromFunds;
+exports.take = take;
+exports.put = put;
+exports.hasAccount = hasAccount;
+exports.isAccountAuthorized = isAccountAuthorized;
+exports.isAccountOwner = isAccountOwner;
+exports.accountCount = accountCount;
+exports.accountIds = accountIds;
+exports.effectivePermissions = effectivePermissions;
+exports.hasPermission = hasPermission;
+exports.effectiveProtocolPermissions = effectiveProtocolPermissions;
+exports.hasProtocolPermission = hasProtocolPermission;
+exports.accountBalance = accountBalance;
+exports.accountBalances = accountBalances;
+exports.balance = balance;
+exports.accountOwner = accountOwner;
+exports.accountAlias = accountAlias;
+exports.accountId = accountId;
+exports.accountAddress = accountAddress;
+exports.accountDelegates = accountDelegates;
+exports.accountBalancesField = accountBalancesField;
+exports.delegateAddress = delegateAddress;
+exports.delegateAlias = delegateAlias;
+exports.delegatePermissions = delegatePermissions;
+exports.delegateProtocolPermissions = delegateProtocolPermissions;
+exports.delegateExpiresAtMs = delegateExpiresAtMs;
+exports.depositRequestAccountId = depositRequestAccountId;
+exports.depositRequestBalance = depositRequestBalance;
+exports.depositRequestAmount = depositRequestAmount;
+exports.depositRequestExtraData = depositRequestExtraData;
+exports.withdrawRequestAccountId = withdrawRequestAccountId;
+exports.withdrawRequestBalance = withdrawRequestBalance;
+exports.withdrawRequestAmount = withdrawRequestAmount;
+exports.withdrawRequestRecipient = withdrawRequestRecipient;
+exports.withdrawRequestExtraData = withdrawRequestExtraData;
+exports.newData = newData;
+exports.borrowData = borrowData;
+exports.borrowDataMut = borrowDataMut;
+exports.hasData = hasData;
+exports.removeData = removeData;
+/**
+ * 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`).
+ */
+const index_ts_1 = require("../utils/index.js");
+const bcs_1 = require("@mysten/sui/bcs");
+const object_table = __importStar(require("./deps/sui/object_table.js"));
+const table = __importStar(require("./deps/sui/table.js"));
+const vec_map = __importStar(require("./deps/sui/vec_map.js"));
+const type_name = __importStar(require("./deps/std/type_name.js"));
+const vec_set = __importStar(require("./deps/sui/vec_set.js"));
+const balance_1 = __importStar(require("./deps/sui/balance.js"));
+const sheet = __importStar(require("./deps/bucket_v2_framework/sheet.js"));
+const $moduleName = '@waterx/account::account';
+exports.ACCOUNT = new index_ts_1.MoveStruct({ name: `${$moduleName}::ACCOUNT`, fields: {
+        dummy_field: bcs_1.bcs.bool()
+    } });
+exports.AdminCap = new index_ts_1.MoveStruct({ name: `${$moduleName}::AdminCap`, fields: {
+        id: bcs_1.bcs.Address
+    } });
+exports.WaterXAccount = new index_ts_1.MoveStruct({ name: `${$moduleName}::WaterXAccount`, fields: {
+        dummy_field: bcs_1.bcs.bool()
+    } });
+exports.AccountRegistry = new index_ts_1.MoveStruct({ name: `${$moduleName}::AccountRegistry`, fields: {
+        id: bcs_1.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_1.bcs.u64()),
+        allowed_versions: vec_set.VecSet(bcs_1.bcs.u16()),
+        managers: vec_set.VecSet(bcs_1.bcs.Address),
+        paused: bcs_1.bcs.bool()
+    } });
+exports.VaultKey = new index_ts_1.MoveTuple({ name: `${$moduleName}::VaultKey<phantom T>`, fields: [bcs_1.bcs.bool()] });
+exports.Vault = new index_ts_1.MoveStruct({ name: `${$moduleName}::Vault<phantom T>`, fields: {
+        balance: balance_1.Balance,
+        sheet: sheet.Sheet
+    } });
+exports.ProtocolDataKey = new index_ts_1.MoveTuple({ name: `${$moduleName}::ProtocolDataKey<phantom PROTOCOL>`, fields: [bcs_1.bcs.bool()] });
+exports.Delegate = new index_ts_1.MoveStruct({ name: `${$moduleName}::Delegate`, fields: {
+        delegate_address: bcs_1.bcs.Address,
+        alias: bcs_1.bcs.string(),
+        /**
+         * Framework-level action bitmap (`PERM_WITHDRAW`, `PERM_RECEIVE`,
+         * `PERM_MANAGE_DELEGATES`). **Vestigial — retained for ABI/bitmap stability but no
+         * longer the live authority for any path.** All three bits now gate nothing: the
+         * funds-out paths (`request_withdraw` / `withdraw_from_funds` / `receive`) and
+         * delegate-perm management (`set/unset_delegate_protocol_permission`) are
+         * owner-only. Delegate authority lives entirely in `protocol_permissions` below
+         * plus the per-account `take`/`put` gate. `effective_permissions` /
+         * `has_permission` remain as public views but no internal path consults them.
+         */
+        permissions: bcs_1.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_1.bcs.u32()),
+        expires_at_ms: bcs_1.bcs.option(bcs_1.bcs.u64())
+    } });
+exports.Account = new index_ts_1.MoveStruct({ name: `${$moduleName}::Account`, fields: {
+        id: bcs_1.bcs.Address,
+        owner_address: bcs_1.bcs.Address,
+        alias: bcs_1.bcs.string(),
+        delegates: bcs_1.bcs.vector(exports.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_1.bcs.u64())
+    } });
+exports.DepositRequest = new index_ts_1.MoveStruct({ name: `${$moduleName}::DepositRequest<phantom T>`, fields: {
+        account_id: bcs_1.bcs.Address,
+        balance: balance_1.Balance,
+        extra_data: bcs_1.bcs.vector(bcs_1.bcs.u8())
+    } });
+exports.WithdrawRequest = new index_ts_1.MoveStruct({ name: `${$moduleName}::WithdrawRequest<phantom T>`, fields: {
+        account_id: bcs_1.bcs.Address,
+        balance: balance_1.Balance,
+        recipient: bcs_1.bcs.Address,
+        extra_data: bcs_1.bcs.vector(bcs_1.bcs.u8())
+    } });
+exports.PausedProtocolsKey = new index_ts_1.MoveTuple({ name: `${$moduleName}::PausedProtocolsKey`, fields: [bcs_1.bcs.bool()] });
+exports.AccountKey = new index_ts_1.MoveStruct({ name: `${$moduleName}::AccountKey`, fields: {
+        owner: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64()
+    } });
+function permNone(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'perm_none',
+    });
+}
+function permWithdraw(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'perm_withdraw',
+    });
+}
+function permManageDelegates(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'perm_manage_delegates',
+    });
+}
+function permReceive(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'perm_receive',
+    });
+}
+function permAll(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'perm_all',
+    });
+}
+function aliasMaxLength(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'alias_max_length',
+    });
+}
+function maxAccountsPerOwner(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'max_accounts_per_owner',
+    });
+}
+function maxDelegatesPerAccount(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'max_delegates_per_account',
+    });
+}
+function maxProtocolPermsPerDelegate(options = {}) {
+    const packageAddress = options.package ?? '@waterx/account';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'max_protocol_perms_per_delegate',
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.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).
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Admin: lift a `pause_protocol<P>`. Idempotent on a non-paused protocol. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns true if `T` has at least one withdraw policy registered. */
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.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>`.
+ */
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.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 (owner-only — see
+ * the gate below; `PERM_WITHDRAW` delegates are rejected) and pause are checked
+ * here, not in `consume_withdraw`.
+ */
+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: (0, index_ts_1.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.).
+ */
+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: (0, index_ts_1.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-only, 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.
+ */
+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: (0, index_ts_1.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 only. Receiving a TTO'd object hands it to the caller's PTB
+ * — an off-platform exfil path — so a delegate can never drive it, even one
+ * holding `PERM_RECEIVE`. The `PERM_RECEIVE` bit is retained for ABI stability but
+ * no longer gates any path. Returns the received object to the caller's PTB.
+ */
+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: (0, index_ts_1.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 the account owner 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>` — owner-only. A delegate is rejected even
+ * one holding `PERM_WITHDRAW` (the bit no longer gates this path; retained for ABI
+ * stability only). Aborts `EUseRequestDepositInstead` if `T` has a deposit policy
+ * registered. Pause-gated. Returns `Balance::zero<T>()` when the address holds no
+ * T.
+ */
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Returns `true` only when `addr` is the account's **owner** — delegates are
+ * excluded regardless of their permission bits or expiry. Protocols use this for
+ * owner-only actions that must never be delegate-driven (e.g. collateral
+ * withdrawal): defense-in-depth so a phished or compromised delegate key can never
+ * move funds, only the owner's own signature can. Contrast `is_account_authorized`
+ * (owner OR live delegate).
+ */
+function isAccountOwner(options) {
+    const packageAddress = options.package ?? '@waterx/account';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        'address'
+    ];
+    const parameterNames = ["registry", "accountId", "addr"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'is_account_owner',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.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`.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.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`.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}