@typus/typus-perp-sdk 1.1.30 → 1.1.31-codegen

package/dist/src/generated/typus_stake_pool/stake_pool.js

@@ -0,0 +1,918 @@
+"use strict";
+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.HarvestPerUserShareEvent = exports.UnstakeEvent = exports.UnsubscribeEvent = exports.SnapshotEvent = exports.UpdatePoolInfoU64PaddingEvent = exports.StakeEvent = exports.WithdrawIncentiveEvent = exports.DepositIncentiveEvent = exports.UpdateIncentiveConfigEvent = exports.UpdateUnlockCountdownTsMsEvent = exports.RemoveIncentiveTokenEvent = exports.ActivateIncentiveTokenEvent = exports.DeactivateIncentiveTokenEvent = exports.AddIncentiveTokenEvent = exports.AutoCompoundEvent = exports.NewStakePoolEvent = exports.LpUserShare = exports.DeactivatingShares = exports.StakePool = exports.Incentive = exports.IncentiveInfo = exports.IncentiveConfig = exports.StakePoolConfig = exports.StakePoolInfo = exports.StakePoolRegistry = void 0;
+exports.init = init;
+exports.newStakePool = newStakePool;
+exports.autoCompound = autoCompound;
+exports.addIncentiveToken = addIncentiveToken;
+exports.deactivateIncentiveToken = deactivateIncentiveToken;
+exports.activateIncentiveToken = activateIncentiveToken;
+exports.removeIncentiveToken = removeIncentiveToken;
+exports.updateUnlockCountdownTsMs = updateUnlockCountdownTsMs;
+exports.updateIncentiveConfig = updateIncentiveConfig;
+exports.allocateIncentive = allocateIncentive;
+exports.depositIncentive = depositIncentive;
+exports.withdrawIncentiveV2 = withdrawIncentiveV2;
+exports.stake = stake;
+exports.updatePoolInfoU64Padding = updatePoolInfoU64Padding;
+exports.hotfixPoolInfoU64Padding = hotfixPoolInfoU64Padding;
+exports.snapshot = snapshot;
+exports.unsubscribe = unsubscribe;
+exports.unstake = unstake;
+exports.updateLastIncentivePriceIndex = updateLastIncentivePriceIndex;
+exports.logHarvestedAmount = logHarvestedAmount;
+exports.harvestPerUserShare = harvestPerUserShare;
+exports.calculateIncentive = calculateIncentive;
+exports.harvestProgressUpdated = harvestProgressUpdated;
+exports.multiplier = multiplier;
+exports.getUserShares = getUserShares;
+exports.getUserSharesByUserShareId = getUserSharesByUserShareId;
+exports.getStakePool = getStakePool;
+exports.getMutStakePool = getMutStakePool;
+exports.getIncentiveTokens = getIncentiveTokens;
+exports.getIncentive = getIncentive;
+exports.getMutIncentive = getMutIncentive;
+exports.removeIncentive = removeIncentive;
+exports.getLastIncentivePriceIndex = getLastIncentivePriceIndex;
+exports.withdrawIncentive = withdrawIncentive;
+exports.deprecated = deprecated;
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+const index_1 = require("../utils/index");
+const bcs_1 = require("@mysten/sui/bcs");
+const object = __importStar(require("./deps/sui/object"));
+const type_name = __importStar(require("./deps/std/type_name"));
+const vec_map = __importStar(require("./deps/sui/vec_map"));
+const $moduleName = "@typus/stake-pool::stake_pool";
+exports.StakePoolRegistry = new index_1.MoveStruct({
+    name: `${$moduleName}::StakePoolRegistry`,
+    fields: {
+        id: object.UID,
+        /** The number of pools in the registry. */
+        num_pool: bcs_1.bcs.u64(),
+    },
+});
+exports.StakePoolInfo = new index_1.MoveStruct({
+    name: `${$moduleName}::StakePoolInfo`,
+    fields: {
+        /** The type name of the stake token. */
+        stake_token: type_name.TypeName,
+        /** The index of the pool. */
+        index: bcs_1.bcs.u64(),
+        /** The next user share ID. */
+        next_user_share_id: bcs_1.bcs.u64(),
+        /** The total number of shares in the pool. */
+        total_share: bcs_1.bcs.u64(),
+        /** Whether the pool is active. */
+        active: bcs_1.bcs.bool(),
+        /**
+         * Padding for future use. [new_tlp_price (decimal 4), usd_per_exp,
+         * depositors_count]
+         */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.StakePoolConfig = new index_1.MoveStruct({
+    name: `${$moduleName}::StakePoolConfig`,
+    fields: {
+        /** The unlock countdown in milliseconds. */
+        unlock_countdown_ts_ms: bcs_1.bcs.u64(),
+        /** Padding for future use. */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.IncentiveConfig = new index_1.MoveStruct({
+    name: `${$moduleName}::IncentiveConfig`,
+    fields: {
+        /** The amount of incentive per period. */
+        period_incentive_amount: bcs_1.bcs.u64(),
+        /** The incentive interval in milliseconds. */
+        incentive_interval_ts_ms: bcs_1.bcs.u64(),
+        /** Padding for future use. */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.IncentiveInfo = new index_1.MoveStruct({
+    name: `${$moduleName}::IncentiveInfo`,
+    fields: {
+        /** Whether the incentive is active. */
+        active: bcs_1.bcs.bool(),
+        /** The timestamp of the last allocation. */
+        last_allocate_ts_ms: bcs_1.bcs.u64(),
+        /** The price index for accumulating incentive. */
+        incentive_price_index: bcs_1.bcs.u64(),
+        /** The unallocated amount of incentive. */
+        unallocated_amount: bcs_1.bcs.u64(),
+        /** Padding for future use. */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.Incentive = new index_1.MoveStruct({
+    name: `${$moduleName}::Incentive`,
+    fields: {
+        /** The type name of the incentive token. */
+        token_type: type_name.TypeName,
+        /** The configuration for the incentive. */
+        config: exports.IncentiveConfig,
+        /** Information about the incentive. */
+        info: exports.IncentiveInfo,
+    },
+});
+exports.StakePool = new index_1.MoveStruct({
+    name: `${$moduleName}::StakePool`,
+    fields: {
+        id: object.UID,
+        /** Information about the stake pool. */
+        pool_info: exports.StakePoolInfo,
+        /** Configuration for the stake pool. */
+        config: exports.StakePoolConfig,
+        /** A vector of the incentives in the stake pool. */
+        incentives: bcs_1.bcs.vector(exports.Incentive),
+        /** Padding for future use. */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.DeactivatingShares = new index_1.MoveStruct({
+    name: `${$moduleName}::DeactivatingShares`,
+    fields: {
+        /** The number of shares. */
+        shares: bcs_1.bcs.u64(),
+        /** The timestamp when the user unsubscribed. */
+        unsubscribed_ts_ms: bcs_1.bcs.u64(),
+        /** The timestamp when the shares can be unlocked. */
+        unlocked_ts_ms: bcs_1.bcs.u64(),
+        /** The unsubscribed incentive price index. */
+        unsubscribed_incentive_price_index: vec_map.VecMap(type_name.TypeName, bcs_1.bcs.u64()),
+        /** Padding for future use. */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.LpUserShare = new index_1.MoveStruct({
+    name: `${$moduleName}::LpUserShare`,
+    fields: {
+        /** The address of the user. */
+        user: bcs_1.bcs.Address,
+        /** The ID of the user's share. */
+        user_share_id: bcs_1.bcs.u64(),
+        /** The timestamp when the user staked. */
+        stake_ts_ms: bcs_1.bcs.u64(),
+        /** The total number of shares. */
+        total_shares: bcs_1.bcs.u64(),
+        /** The number of active shares. */
+        active_shares: bcs_1.bcs.u64(),
+        /** A vector of deactivating shares. */
+        deactivating_shares: bcs_1.bcs.vector(exports.DeactivatingShares),
+        /** The last incentive price index. */
+        last_incentive_price_index: vec_map.VecMap(type_name.TypeName, bcs_1.bcs.u64()),
+        /**
+         * Padding for future use. [snapshot_ts_ms, old_tlp_price (decimal 4),
+         * is_auto_compound(deprecated), harvested_amount]
+         */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.NewStakePoolEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::NewStakePoolEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        stake_pool_info: exports.StakePoolInfo,
+        stake_pool_config: exports.StakePoolConfig,
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.AutoCompoundEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::AutoCompoundEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        incentive_token: type_name.TypeName,
+        incentive_price_index: bcs_1.bcs.u64(),
+        total_amount: bcs_1.bcs.u64(),
+        compound_users: bcs_1.bcs.u64(),
+        total_users: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.AddIncentiveTokenEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::AddIncentiveTokenEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        incentive_token: type_name.TypeName,
+        incentive_info: exports.IncentiveInfo,
+        incentive_config: exports.IncentiveConfig,
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.DeactivateIncentiveTokenEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::DeactivateIncentiveTokenEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        incentive_token: type_name.TypeName,
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.ActivateIncentiveTokenEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::ActivateIncentiveTokenEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        incentive_token: type_name.TypeName,
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.RemoveIncentiveTokenEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::RemoveIncentiveTokenEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        incentive_token: type_name.TypeName,
+        incentive_balance_value: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.UpdateUnlockCountdownTsMsEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::UpdateUnlockCountdownTsMsEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        previous_unlock_countdown_ts_ms: bcs_1.bcs.u64(),
+        new_unlock_countdown_ts_ms: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.UpdateIncentiveConfigEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::UpdateIncentiveConfigEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        previous_incentive_config: exports.IncentiveConfig,
+        new_incentive_config: exports.IncentiveConfig,
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.DepositIncentiveEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::DepositIncentiveEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        incentive_token_type: type_name.TypeName,
+        deposit_amount: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.WithdrawIncentiveEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::WithdrawIncentiveEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        incentive_token_type: type_name.TypeName,
+        withdrawal_amount: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.StakeEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::StakeEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        lp_token_type: type_name.TypeName,
+        stake_amount: bcs_1.bcs.u64(),
+        user_share_id: bcs_1.bcs.u64(),
+        stake_ts_ms: bcs_1.bcs.u64(),
+        last_incentive_price_index: vec_map.VecMap(type_name.TypeName, bcs_1.bcs.u64()),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.UpdatePoolInfoU64PaddingEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::UpdatePoolInfoU64PaddingEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.SnapshotEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::SnapshotEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        user_share_id: bcs_1.bcs.u64(),
+        shares: bcs_1.bcs.u64(),
+        tlp_price: bcs_1.bcs.u64(),
+        last_ts_ms: bcs_1.bcs.u64(),
+        current_ts_ms: bcs_1.bcs.u64(),
+        exp: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.UnsubscribeEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::UnsubscribeEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        lp_token_type: type_name.TypeName,
+        user_share_id: bcs_1.bcs.u64(),
+        unsubscribed_shares: bcs_1.bcs.u64(),
+        unsubscribe_ts_ms: bcs_1.bcs.u64(),
+        unlocked_ts_ms: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.UnstakeEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::UnstakeEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        lp_token_type: type_name.TypeName,
+        user_share_id: bcs_1.bcs.u64(),
+        unstake_amount: bcs_1.bcs.u64(),
+        unstake_ts_ms: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.HarvestPerUserShareEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::HarvestPerUserShareEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        incentive_token_type: type_name.TypeName,
+        harvest_amount: bcs_1.bcs.u64(),
+        user_share_id: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+/** Initializes the module. */
+function init(options = {}) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "init",
+    });
+}
+/** [Authorized Function] Creates a new stake pool. */
+function newStakePool(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+    ];
+    const parameterNames = ["version", "registry", "unlockCountdownTsMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "new_stake_pool",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] */
+function autoCompound(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "auto_compound",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Adds a new incentive token to a pool. */
+function addIncentiveToken(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        "u64",
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "periodIncentiveAmount", "incentiveIntervalTsMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "add_incentive_token",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Deactivates an incentive token. */
+function deactivateIncentiveToken(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+    ];
+    const parameterNames = ["version", "registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "deactivate_incentive_token",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Activates an incentive token. */
+function activateIncentiveToken(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+    ];
+    const parameterNames = ["version", "registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "activate_incentive_token",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Removes an incentive token. */
+function removeIncentiveToken(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+    ];
+    const parameterNames = ["version", "registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "remove_incentive_token",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Updates the unlock countdown. */
+function updateUnlockCountdownTsMs(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        "u64",
+    ];
+    const parameterNames = ["version", "registry", "index", "unlockCountdownTsMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "update_unlock_countdown_ts_ms",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [Authorized Function] Updates the incentive configuration. */
+function updateIncentiveConfig(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<vector<u64>>",
+    ];
+    const parameterNames = ["version", "registry", "index", "periodIncentiveAmount", "incentiveIntervalTsMs", "u64Padding"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "update_incentive_config",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** Allocates incentive to the pool. WARNING: no authority check inside */
+function allocateIncentive(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "allocate_incentive",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [Authorized Function] Deposits incentive tokens. */
+function depositIncentive(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+    ];
+    const parameterNames = ["version", "registry", "index", "coin"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "deposit_incentive",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Withdraws incentive tokens. */
+function withdrawIncentiveV2(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "withdraw_incentive_v2",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [User Function] Stake LP tokens. */
+function stake(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "lpToken", "UserShareId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "stake",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Update TLP price for calculating staking exp */
+function updatePoolInfoU64Padding(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        "u64",
+        "u64",
+    ];
+    const parameterNames = ["version", "registry", "index", "tlpPrice", "usdPerExp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "update_pool_info_u64_padding",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [Authorized Function] Update TLP price for calculating staking exp */
+function hotfixPoolInfoU64Padding(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        "vector<u64>",
+    ];
+    const parameterNames = ["version", "registry", "index", "u64Padding"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "hotfix_pool_info_u64_padding",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [User Function] Get the staking exp */
+function snapshot(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "0x4b0f4ee1a40ce37ec81c987cc4e76a665419e74b863319492fc7d26f708b835a::ecosystem::Version",
+        "0x4b0f4ee1a40ce37ec81c987cc4e76a665419e74b863319492fc7d26f708b835a::user::TypusUserRegistry",
+        "u64",
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "typusEcosystemVersion", "typusUserRegistry", "index", "UserShareId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "snapshot",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [User Function] Pre-process to unstake the TLP */
+function unsubscribe(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "UserShareId", "unsubscribedShares"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "unsubscribe",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [User Function] Post-process to unstake the TLP */
+function unstake(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "UserShareId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "unstake",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+function updateLastIncentivePriceIndex(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::stake_pool::LpUserShare`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+        "u64",
+    ];
+    const parameterNames = ["lpUserShare", "incentiveToken", "currentIncentiveIndex"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "update_last_incentive_price_index",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function logHarvestedAmount(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [`${packageAddress}::stake_pool::LpUserShare`, "u64"];
+    const parameterNames = ["userShare", "incentiveValue"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "log_harvested_amount",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [User Function] Harvest the incentive from staking TLP */
+function harvestPerUserShare(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "UserShareId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "harvest_per_user_share",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+function calculateIncentive(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+        `${packageAddress}::stake_pool::LpUserShare`,
+    ];
+    const parameterNames = ["currentIncentiveIndex", "incentiveToken", "lpUserShare"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "calculate_incentive",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function harvestProgressUpdated(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        "0x0000000000000000000000000000000000000000000000000000000000000002::vec_map::VecMap<0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName, u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::vec_map::VecMap<0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName, u64>",
+    ];
+    const parameterNames = ["current", "user"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "harvest_progress_updated",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function multiplier(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = ["u64"];
+    const parameterNames = ["decimal"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "multiplier",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getUserShares(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [`${packageAddress}::stake_pool::StakePoolRegistry`, "u64", "address"];
+    const parameterNames = ["registry", "index", "user"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "get_user_shares",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getUserSharesByUserShareId(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [`${packageAddress}::stake_pool::StakePoolRegistry`, "u64", "u64"];
+    const parameterNames = ["registry", "index", "userShareId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "get_user_shares_by_user_share_id",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getStakePool(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = ["0x0000000000000000000000000000000000000000000000000000000000000002::object::UID", "u64"];
+    const parameterNames = ["id", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "get_stake_pool",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getMutStakePool(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = ["0x0000000000000000000000000000000000000000000000000000000000000002::object::UID", "u64"];
+    const parameterNames = ["id", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "get_mut_stake_pool",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getIncentiveTokens(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [`${packageAddress}::stake_pool::StakePool`];
+    const parameterNames = ["stakePool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "get_incentive_tokens",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getIncentive(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::stake_pool::StakePool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+    ];
+    const parameterNames = ["stakePool", "tokenType"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "get_incentive",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getMutIncentive(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::stake_pool::StakePool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+    ];
+    const parameterNames = ["stakePool", "tokenType"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "get_mut_incentive",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function removeIncentive(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::stake_pool::StakePool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+    ];
+    const parameterNames = ["stakePool", "tokenType"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "remove_incentive",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getLastIncentivePriceIndex(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [`${packageAddress}::stake_pool::StakePool`];
+    const parameterNames = ["stakePool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "get_last_incentive_price_index",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function withdrawIncentive(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::stake_pool::StakePoolRegistry`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+    ];
+    const parameterNames = ["version", "registry", "index", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "withdraw_incentive",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+function deprecated(options = {}) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "stake_pool",
+        function: "deprecated",
+    });
+}