@waterx/sdk 2.1.0

package/dist/src/generated/waterx_staking/waterx_staking.js

@@ -0,0 +1,731 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as double from "./deps/bucket_v2_framework/double.js";
+import * as balance from "./deps/sui/balance.js";
+import * as balance_1 from "./deps/sui/balance.js";
+import * as balance_2 from "./deps/sui/balance.js";
+import * as double_1 from "./deps/bucket_v2_framework/double.js";
+import * as double_2 from "./deps/bucket_v2_framework/double.js";
+import * as table from "./deps/sui/table.js";
+import * as vec_set from "./deps/sui/vec_set.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 balance_3 from "./deps/sui/balance.js";
+import * as table_1 from "./deps/sui/table.js";
+import * as vec_set_3 from "./deps/sui/vec_set.js";
+import * as vec_set_4 from "./deps/sui/vec_set.js";
+const $moduleName = '@waterx/staking::waterx_staking';
+export const Create = new MoveStruct({ name: `${$moduleName}::Create`, fields: {
+        vault_id: bcs.Address,
+        asset_type: bcs.string()
+    } });
+export const AddRewarder = new MoveStruct({ name: `${$moduleName}::AddRewarder`, fields: {
+        vault_id: bcs.Address,
+        rewarder_id: bcs.Address,
+        asset_type: bcs.string(),
+        reward_type: bcs.string()
+    } });
+export const UpdateFlowRate = new MoveStruct({ name: `${$moduleName}::UpdateFlowRate`, fields: {
+        vault_id: bcs.Address,
+        rewarder_id: bcs.Address,
+        asset_type: bcs.string(),
+        reward_type: bcs.string(),
+        flow_rate: bcs.u256()
+    } });
+export const RewardEarned = new MoveStruct({ name: `${$moduleName}::RewardEarned`, fields: {
+        vault_id: bcs.Address,
+        rewarder_id: bcs.Address,
+        asset_type: bcs.string(),
+        reward_type: bcs.string(),
+        reward_amount: bcs.u64()
+    } });
+export const Deposit = new MoveStruct({ name: `${$moduleName}::Deposit`, fields: {
+        vault_id: bcs.Address,
+        asset_type: bcs.string(),
+        account_address: bcs.Address,
+        stake_amount: bcs.u64()
+    } });
+export const Redeem = new MoveStruct({ name: `${$moduleName}::Redeem`, fields: {
+        vault_id: bcs.Address,
+        asset_type: bcs.string(),
+        account_address: bcs.Address,
+        withdrawal_amount: bcs.u64()
+    } });
+export const ClaimReward = new MoveStruct({ name: `${$moduleName}::ClaimReward`, fields: {
+        vault_id: bcs.Address,
+        rewarder_id: bcs.Address,
+        asset_type: bcs.string(),
+        reward_type: bcs.string(),
+        account_address: bcs.Address,
+        reward_amount: bcs.u64(),
+        cumulative_reward_amount: bcs.u64()
+    } });
+export const StakePosition = new MoveStruct({ name: `${$moduleName}::StakePosition`, fields: {
+        stake_amount: bcs.u64(),
+        pending_rewarder_sync: bcs.bool()
+    } });
+export const RewarderKey = new MoveStruct({ name: `${$moduleName}::RewarderKey<phantom R>`, fields: {
+        dummy_field: bcs.bool()
+    } });
+export const RewardData = new MoveStruct({ name: `${$moduleName}::RewardData<phantom R>`, fields: {
+        unit: double.Double,
+        reward: balance.Balance,
+        cumulative_reward_amount: bcs.u64()
+    } });
+export const Rewarder = new MoveStruct({ name: `${$moduleName}::Rewarder<phantom STAKE, phantom R>`, fields: {
+        id: bcs.Address,
+        source: balance_1.Balance,
+        pool: balance_2.Balance,
+        flow_rate: double_1.Double,
+        unit: double_2.Double,
+        timestamp: bcs.u64(),
+        total_stake_snapshot: bcs.u64(),
+        reward_table: table.Table
+    } });
+export const StakeDataDisplay = new MoveStruct({ name: `${$moduleName}::StakeDataDisplay`, fields: {
+        stake_coin_type: bcs.string(),
+        reward_coin_type: bcs.string(),
+        stake_amount: bcs.u64(),
+        claimable_reward_amount: bcs.u64(),
+        cumulative_reward_amount: bcs.u64()
+    } });
+export const DepositChecker = new MoveStruct({ name: `${$moduleName}::DepositChecker<phantom STAKE>`, fields: {
+        account: bcs.Address,
+        prev_stake_amount: bcs.u64(),
+        rewarder_ids: vec_set.VecSet(bcs.Address)
+    } });
+export const WithdrawChecker = new MoveStruct({ name: `${$moduleName}::WithdrawChecker<phantom STAKE>`, fields: {
+        account: bcs.Address,
+        prev_stake_amount: bcs.u64(),
+        rewarder_ids: vec_set_1.VecSet(bcs.Address)
+    } });
+export const AdminCap = new MoveStruct({ name: `${$moduleName}::AdminCap`, fields: {
+        id: bcs.Address
+    } });
+export const StakingPool = new MoveStruct({ name: `${$moduleName}::StakingPool<phantom STAKE>`, fields: {
+        id: bcs.Address,
+        versions: vec_set_2.VecSet(bcs.u16()),
+        stake: balance_3.Balance,
+        stake_table: table_1.Table,
+        managers: vec_set_3.VecSet(bcs.Address),
+        stake_cap: bcs.u64(),
+        rewarder_ids: vec_set_4.VecSet(bcs.Address)
+    } });
+export function packageVersion(options = {}) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'package_version',
+    });
+}
+export function permDepositStake(options = {}) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'perm_deposit_stake',
+    });
+}
+export function permRedeemStake(options = {}) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'perm_redeem_stake',
+    });
+}
+export function permClaimReward(options = {}) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'perm_claim_reward',
+    });
+}
+/** === Admin Functions === */
+export function _new(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["AdminCap", "stakeCap"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function _default(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["adminCap", "stakeCap"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'default',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function addRewarder(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["self", "Cap", "flowAmount", "flowInterval", "startTime"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'add_rewarder',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function withdrawFromSource(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::clock::Clock',
+        'u64'
+    ];
+    const parameterNames = ["self", "Cap", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'withdraw_from_source',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function setStakeCap(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["self", "Cap", "stakeCap"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'set_stake_cap',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function addManager(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["self", "Cap", "manager"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'add_manager',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function removeManager(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["self", "Cap", "manager"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'remove_manager',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function addVersion(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["self", "Cap", "version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'add_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function removeVersion(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["self", "Cap", "version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'remove_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** === Manager Functions === */
+export function updateFlowRate(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        '0x2::clock::Clock',
+        'u64',
+        'u64',
+        null
+    ];
+    const parameterNames = ["self", "flowAmount", "flowInterval", "request"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'update_flow_rate',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function depositToSourceByManager(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        '0x2::clock::Clock',
+        null,
+        'u64',
+        null
+    ];
+    const parameterNames = ["self", "coin", "flowInterval", "managerReq"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'deposit_to_source_by_manager',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** === Public Functions === */
+export function depositToSource(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["self", "coin"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'deposit_to_source',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function supply(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["self", "coin"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'supply',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function depositToPool(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["self", "coin"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'deposit_to_pool',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Stakes `stake_amount` of `STAKE` drawn from the caller's wxa account into this
+ * distributor. Auth: `acc_req.address()` must hold `PERM_DEPOSIT_STAKE` on
+ * `account_id` (owner has all bits). The stake position is keyed by the wxa
+ * account's UID-derived address, so delegate-driven deposits credit the same
+ * position as the owner.
+ */
+export function deposit(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["self", "wxaRegistry", "accountId", "accReq", "stakeAmount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'deposit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function settleRewarderOnDeposit(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["checker", "self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'settle_rewarder_on_deposit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function destroyDepositChecker(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["checker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'destroy_deposit_checker',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Redeems `withdrawal_amount` of `STAKE` from the caller's stake position back
+ * into their wxa account's stored `Balance<STAKE>`. Auth: `acc_req.address()` must
+ * hold `PERM_REDEEM_STAKE` on `account_id`. The stake position is keyed by the wxa
+ * account's UID-derived address.
+ */
+export function redeem(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["self", "wxaRegistry", "accountId", "accReq", "withdrawalAmount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'redeem',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function settleRewarderOnWithdraw(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["checker", "self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'settle_rewarder_on_withdraw',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function destroyWithdrawChecker(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["checker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'destroy_withdraw_checker',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Claims any accrued reward `R` for `account_id`'s stake position and credits the
+ * resulting `Balance<R>` directly into the wxa account's stored balance via
+ * `put<R, WaterXStaking>`. The user can later extract it via the normal
+ * `request_withdraw<R>` flow (or restake / reuse it from stored balance). Auth:
+ * `request.address()` must hold `PERM_CLAIM_REWARD` on `account_id`. Zero-amount
+ * claims are a no-op.
+ */
+export function claim(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["self", "wxaRegistry", "accountId", "request"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'claim',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** === View Functions === */
+export function id(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function rewarderIds(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'rewarder_ids',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function rewarderExists(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'rewarder_exists',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function getRewarder(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'get_rewarder',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function rewarderId(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'rewarder_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function rewarderSourceAmount(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'rewarder_source_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function rewarderPoolAmount(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'rewarder_pool_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function rewarderFlowRate(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'rewarder_flow_rate',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function rewarderTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'rewarder_timestamp',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function rewarderTotalStakeSnapshot(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'rewarder_total_stake_snapshot',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function stakeExists(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        'address'
+    ];
+    const parameterNames = ["self", "account"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'stake_exists',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function totalStakeAmount(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'total_stake_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function realtimeRewardAmount(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        'address',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["self", "account"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'realtime_reward_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function withdrawableAmount(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        'address'
+    ];
+    const parameterNames = ["self", "account"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'withdrawable_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function getStakeData(options) {
+    const packageAddress = options.package ?? '@waterx/staking';
+    const argumentsTypes = [
+        null,
+        'address',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["self", "account"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_staking',
+        function: 'get_stake_data',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}