@typus/typus-sdk 1.4.84 → 1.5.1

package/dist/src/typus-perp/typus_stake_pool/index.d.ts

@@ -0,0 +1,3 @@
+export declare const PACKAGE_ID = "0xbda4449124bfac6db9983411814d422daefd0c2bf02d4e7053db030f68448eaf";
+export declare const PUBLISHED_AT = "0xbda4449124bfac6db9983411814d422daefd0c2bf02d4e7053db030f68448eaf";
+export declare const PKG_V1 = "0xbda4449124bfac6db9983411814d422daefd0c2bf02d4e7053db030f68448eaf";

package/dist/src/typus-perp/typus_stake_pool/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PKG_V1 = exports.PUBLISHED_AT = exports.PACKAGE_ID = void 0;
+exports.PACKAGE_ID = "0xbda4449124bfac6db9983411814d422daefd0c2bf02d4e7053db030f68448eaf";
+exports.PUBLISHED_AT = "0xbda4449124bfac6db9983411814d422daefd0c2bf02d4e7053db030f68448eaf";
+exports.PKG_V1 = "0xbda4449124bfac6db9983411814d422daefd0c2bf02d4e7053db030f68448eaf";

package/dist/src/typus-perp/typus_stake_pool/init.d.ts

@@ -0,0 +1,2 @@
+import { StructClassLoader } from "../_framework/loader";
+export declare function registerClasses(loader: StructClassLoader): void;

package/dist/src/typus-perp/typus_stake_pool/init.js

@@ -0,0 +1,57 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerClasses = registerClasses;
+var admin = __importStar(require("./admin/structs"));
+var stakePool = __importStar(require("./stake-pool/structs"));
+function registerClasses(loader) {
+    loader.register(admin.Version);
+    loader.register(admin.ManagerCap);
+    loader.register(admin.FeeInfo);
+    loader.register(admin.FeePool);
+    loader.register(admin.SendFeeEvent);
+    loader.register(stakePool.UnsubscribeEvent);
+    loader.register(stakePool.WithdrawIncentiveEvent);
+    loader.register(stakePool.ActivateIncentiveTokenEvent);
+    loader.register(stakePool.AddIncentiveTokenEvent);
+    loader.register(stakePool.DeactivateIncentiveTokenEvent);
+    loader.register(stakePool.DeactivatingShares);
+    loader.register(stakePool.DepositIncentiveEvent);
+    loader.register(stakePool.HarvestPerUserShareEvent);
+    loader.register(stakePool.Incentive);
+    loader.register(stakePool.IncentiveConfig);
+    loader.register(stakePool.IncentiveInfo);
+    loader.register(stakePool.LpUserShare);
+    loader.register(stakePool.NewStakePoolEvent);
+    loader.register(stakePool.RemoveIncentiveTokenEvent);
+    loader.register(stakePool.StakeEvent);
+    loader.register(stakePool.StakePool);
+    loader.register(stakePool.StakePoolConfig);
+    loader.register(stakePool.StakePoolInfo);
+    loader.register(stakePool.StakePoolRegistry);
+    loader.register(stakePool.UnstakeEvent);
+    loader.register(stakePool.UpdateIncentiveConfigEvent);
+    loader.register(stakePool.UpdateUnlockCountdownTsMsEvent);
+}

package/dist/src/typus-perp/typus_stake_pool/stake-pool/functions.d.ts

@@ -0,0 +1,175 @@
+import { Transaction, TransactionArgument, TransactionObjectInput } from "@mysten/sui/transactions";
+export declare function multiplier(tx: Transaction, decimal: bigint | TransactionArgument): import("@mysten/sui/transactions").TransactionResult;
+export declare function init(tx: Transaction): import("@mysten/sui/transactions").TransactionResult;
+export interface UnsubscribeArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+    userShareId: bigint | TransactionArgument;
+    unsubscribedShares: bigint | TransactionArgument | TransactionArgument | null;
+    clock: TransactionObjectInput;
+}
+export declare function unsubscribe(tx: Transaction, typeArg: string, args: UnsubscribeArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawIncentiveArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+    amount: bigint | TransactionArgument | TransactionArgument | null;
+}
+export declare function withdrawIncentive(tx: Transaction, typeArg: string, args: WithdrawIncentiveArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface ActivateIncentiveTokenArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+}
+export declare function activateIncentiveToken(tx: Transaction, typeArg: string, args: ActivateIncentiveTokenArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface AddIncentiveTokenArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+    periodIncentiveAmount: bigint | TransactionArgument;
+    incentiveIntervalTsMs: bigint | TransactionArgument;
+    clock: TransactionObjectInput;
+}
+export declare function addIncentiveToken(tx: Transaction, typeArg: string, args: AddIncentiveTokenArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface AllocateIncentiveArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+    clock: TransactionObjectInput;
+}
+export declare function allocateIncentive(tx: Transaction, args: AllocateIncentiveArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface CalculateIncentiveArgs {
+    stakePool: TransactionObjectInput;
+    incentiveToken: TransactionObjectInput;
+    lpUserShare: TransactionObjectInput;
+}
+export declare function calculateIncentive(tx: Transaction, args: CalculateIncentiveArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface CreateUserLastIncentiveTsMsArgs {
+    stakePool: TransactionObjectInput;
+    currentTsMs: bigint | TransactionArgument;
+}
+export declare function createUserLastIncentiveTsMs(tx: Transaction, args: CreateUserLastIncentiveTsMsArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface DeactivateIncentiveTokenArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+}
+export declare function deactivateIncentiveToken(tx: Transaction, typeArg: string, args: DeactivateIncentiveTokenArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface DepositIncentiveArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+    coin: TransactionObjectInput;
+}
+export declare function depositIncentive(tx: Transaction, typeArg: string, args: DepositIncentiveArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface GetIncentiveArgs {
+    stakePool: TransactionObjectInput;
+    tokenType: TransactionObjectInput;
+}
+export declare function getIncentive(tx: Transaction, args: GetIncentiveArgs): import("@mysten/sui/transactions").TransactionResult;
+export declare function getIncentiveTokens(tx: Transaction, stakePool: TransactionObjectInput): import("@mysten/sui/transactions").TransactionResult;
+export declare function getLastIncentivePriceIndex(tx: Transaction, stakePool: TransactionObjectInput): import("@mysten/sui/transactions").TransactionResult;
+export interface GetMutIncentiveArgs {
+    stakePool: TransactionObjectInput;
+    tokenType: TransactionObjectInput;
+}
+export declare function getMutIncentive(tx: Transaction, args: GetMutIncentiveArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface GetMutStakePoolArgs {
+    id: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+}
+export declare function getMutStakePool(tx: Transaction, args: GetMutStakePoolArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface GetStakePoolArgs {
+    id: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+}
+export declare function getStakePool(tx: Transaction, args: GetStakePoolArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface GetUserShareIdsArgs {
+    stakePool: TransactionObjectInput;
+    user: string | TransactionArgument;
+}
+export declare function getUserShareIds(tx: Transaction, args: GetUserShareIdsArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface GetUserSharesArgs {
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+    user: string | TransactionArgument;
+}
+export declare function getUserShares(tx: Transaction, args: GetUserSharesArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface HarvestPerUserShareArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+    userShareId: bigint | TransactionArgument;
+    clock: TransactionObjectInput;
+}
+export declare function harvestPerUserShare(tx: Transaction, typeArg: string, args: HarvestPerUserShareArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface HarvestProgressUpdatedArgs {
+    stakePool: TransactionObjectInput;
+    lpUserShare: TransactionObjectInput;
+}
+export declare function harvestProgressUpdated(tx: Transaction, args: HarvestProgressUpdatedArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface NewStakePoolArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    unlockCountdownTsMs: bigint | TransactionArgument;
+}
+export declare function newStakePool(tx: Transaction, typeArg: string, args: NewStakePoolArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveIncentiveArgs {
+    stakePool: TransactionObjectInput;
+    tokenType: TransactionObjectInput;
+}
+export declare function removeIncentive(tx: Transaction, args: RemoveIncentiveArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveIncentiveTokenArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+}
+export declare function removeIncentiveToken(tx: Transaction, typeArg: string, args: RemoveIncentiveTokenArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveUserShareByIdArgs {
+    id: TransactionObjectInput;
+    user: string | TransactionArgument;
+    userShareId: bigint | TransactionArgument;
+}
+export declare function removeUserShareById(tx: Transaction, args: RemoveUserShareByIdArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface StakeArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+    lpToken: TransactionObjectInput;
+    userShareId: bigint | TransactionArgument | TransactionArgument | null;
+    clock: TransactionObjectInput;
+}
+export declare function stake(tx: Transaction, typeArg: string, args: StakeArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface StoreUserSharesArgs {
+    id: TransactionObjectInput;
+    user: string | TransactionArgument;
+    userShares: Array<TransactionObjectInput> | TransactionArgument;
+}
+export declare function storeUserShares(tx: Transaction, args: StoreUserSharesArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface UnstakeArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+    userShareId: bigint | TransactionArgument;
+    unstakedShares: bigint | TransactionArgument | TransactionArgument | null;
+    clock: TransactionObjectInput;
+}
+export declare function unstake(tx: Transaction, typeArg: string, args: UnstakeArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateIncentiveConfigArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+    clock: TransactionObjectInput;
+    periodIncentiveAmount: bigint | TransactionArgument | TransactionArgument | null;
+    incentiveIntervalTsMs: bigint | TransactionArgument | TransactionArgument | null;
+    u64Padding: Array<bigint | TransactionArgument> | TransactionArgument | TransactionArgument | null;
+}
+export declare function updateIncentiveConfig(tx: Transaction, typeArg: string, args: UpdateIncentiveConfigArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateUnlockCountdownTsMsArgs {
+    version: TransactionObjectInput;
+    registry: TransactionObjectInput;
+    index: bigint | TransactionArgument;
+    unlockCountdownTsMs: bigint | TransactionArgument;
+}
+export declare function updateUnlockCountdownTsMs(tx: Transaction, args: UpdateUnlockCountdownTsMsArgs): import("@mysten/sui/transactions").TransactionResult;

package/dist/src/typus-perp/typus_stake_pool/stake-pool/functions.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multiplier = multiplier;
+exports.init = init;
+exports.unsubscribe = unsubscribe;
+exports.withdrawIncentive = withdrawIncentive;
+exports.activateIncentiveToken = activateIncentiveToken;
+exports.addIncentiveToken = addIncentiveToken;
+exports.allocateIncentive = allocateIncentive;
+exports.calculateIncentive = calculateIncentive;
+exports.createUserLastIncentiveTsMs = createUserLastIncentiveTsMs;
+exports.deactivateIncentiveToken = deactivateIncentiveToken;
+exports.depositIncentive = depositIncentive;
+exports.getIncentive = getIncentive;
+exports.getIncentiveTokens = getIncentiveTokens;
+exports.getLastIncentivePriceIndex = getLastIncentivePriceIndex;
+exports.getMutIncentive = getMutIncentive;
+exports.getMutStakePool = getMutStakePool;
+exports.getStakePool = getStakePool;
+exports.getUserShareIds = getUserShareIds;
+exports.getUserShares = getUserShares;
+exports.harvestPerUserShare = harvestPerUserShare;
+exports.harvestProgressUpdated = harvestProgressUpdated;
+exports.newStakePool = newStakePool;
+exports.removeIncentive = removeIncentive;
+exports.removeIncentiveToken = removeIncentiveToken;
+exports.removeUserShareById = removeUserShareById;
+exports.stake = stake;
+exports.storeUserShares = storeUserShares;
+exports.unstake = unstake;
+exports.updateIncentiveConfig = updateIncentiveConfig;
+exports.updateUnlockCountdownTsMs = updateUnlockCountdownTsMs;
+var __1 = require("..");
+var structs_1 = require("../../_dependencies/source/0x1/option/structs");
+var util_1 = require("../../_framework/util");
+var structs_2 = require("./structs");
+function multiplier(tx, decimal) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::multiplier"),
+        arguments: [(0, util_1.pure)(tx, decimal, "u64")],
+    });
+}
+function init(tx) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::init"),
+        arguments: [],
+    });
+}
+function unsubscribe(tx, typeArg, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::unsubscribe"),
+        typeArguments: [typeArg],
+        arguments: [
+            (0, util_1.obj)(tx, args.version),
+            (0, util_1.obj)(tx, args.registry),
+            (0, util_1.pure)(tx, args.index, "u64"),
+            (0, util_1.pure)(tx, args.userShareId, "u64"),
+            (0, util_1.pure)(tx, args.unsubscribedShares, "".concat(structs_1.Option.$typeName, "<u64>")),
+            (0, util_1.obj)(tx, args.clock),
+        ],
+    });
+}
+function withdrawIncentive(tx, typeArg, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::withdraw_incentive"),
+        typeArguments: [typeArg],
+        arguments: [
+            (0, util_1.obj)(tx, args.version),
+            (0, util_1.obj)(tx, args.registry),
+            (0, util_1.pure)(tx, args.index, "u64"),
+            (0, util_1.pure)(tx, args.amount, "".concat(structs_1.Option.$typeName, "<u64>")),
+        ],
+    });
+}
+function activateIncentiveToken(tx, typeArg, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::activate_incentive_token"),
+        typeArguments: [typeArg],
+        arguments: [(0, util_1.obj)(tx, args.version), (0, util_1.obj)(tx, args.registry), (0, util_1.pure)(tx, args.index, "u64")],
+    });
+}
+function addIncentiveToken(tx, typeArg, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::add_incentive_token"),
+        typeArguments: [typeArg],
+        arguments: [
+            (0, util_1.obj)(tx, args.version),
+            (0, util_1.obj)(tx, args.registry),
+            (0, util_1.pure)(tx, args.index, "u64"),
+            (0, util_1.pure)(tx, args.periodIncentiveAmount, "u64"),
+            (0, util_1.pure)(tx, args.incentiveIntervalTsMs, "u64"),
+            (0, util_1.obj)(tx, args.clock),
+        ],
+    });
+}
+function allocateIncentive(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::allocate_incentive"),
+        arguments: [(0, util_1.obj)(tx, args.version), (0, util_1.obj)(tx, args.registry), (0, util_1.pure)(tx, args.index, "u64"), (0, util_1.obj)(tx, args.clock)],
+    });
+}
+function calculateIncentive(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::calculate_incentive"),
+        arguments: [(0, util_1.obj)(tx, args.stakePool), (0, util_1.obj)(tx, args.incentiveToken), (0, util_1.obj)(tx, args.lpUserShare)],
+    });
+}
+function createUserLastIncentiveTsMs(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::create_user_last_incentive_ts_ms"),
+        arguments: [(0, util_1.obj)(tx, args.stakePool), (0, util_1.pure)(tx, args.currentTsMs, "u64")],
+    });
+}
+function deactivateIncentiveToken(tx, typeArg, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::deactivate_incentive_token"),
+        typeArguments: [typeArg],
+        arguments: [(0, util_1.obj)(tx, args.version), (0, util_1.obj)(tx, args.registry), (0, util_1.pure)(tx, args.index, "u64")],
+    });
+}
+function depositIncentive(tx, typeArg, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::deposit_incentive"),
+        typeArguments: [typeArg],
+        arguments: [(0, util_1.obj)(tx, args.version), (0, util_1.obj)(tx, args.registry), (0, util_1.pure)(tx, args.index, "u64"), (0, util_1.obj)(tx, args.coin)],
+    });
+}
+function getIncentive(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::get_incentive"),
+        arguments: [(0, util_1.obj)(tx, args.stakePool), (0, util_1.obj)(tx, args.tokenType)],
+    });
+}
+function getIncentiveTokens(tx, stakePool) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::get_incentive_tokens"),
+        arguments: [(0, util_1.obj)(tx, stakePool)],
+    });
+}
+function getLastIncentivePriceIndex(tx, stakePool) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::get_last_incentive_price_index"),
+        arguments: [(0, util_1.obj)(tx, stakePool)],
+    });
+}
+function getMutIncentive(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::get_mut_incentive"),
+        arguments: [(0, util_1.obj)(tx, args.stakePool), (0, util_1.obj)(tx, args.tokenType)],
+    });
+}
+function getMutStakePool(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::get_mut_stake_pool"),
+        arguments: [(0, util_1.obj)(tx, args.id), (0, util_1.pure)(tx, args.index, "u64")],
+    });
+}
+function getStakePool(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::get_stake_pool"),
+        arguments: [(0, util_1.obj)(tx, args.id), (0, util_1.pure)(tx, args.index, "u64")],
+    });
+}
+function getUserShareIds(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::get_user_share_ids"),
+        arguments: [(0, util_1.obj)(tx, args.stakePool), (0, util_1.pure)(tx, args.user, "address")],
+    });
+}
+function getUserShares(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::get_user_shares"),
+        arguments: [(0, util_1.obj)(tx, args.registry), (0, util_1.pure)(tx, args.index, "u64"), (0, util_1.pure)(tx, args.user, "address")],
+    });
+}
+function harvestPerUserShare(tx, typeArg, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::harvest_per_user_share"),
+        typeArguments: [typeArg],
+        arguments: [
+            (0, util_1.obj)(tx, args.version),
+            (0, util_1.obj)(tx, args.registry),
+            (0, util_1.pure)(tx, args.index, "u64"),
+            (0, util_1.pure)(tx, args.userShareId, "u64"),
+            (0, util_1.obj)(tx, args.clock),
+        ],
+    });
+}
+function harvestProgressUpdated(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::harvest_progress_updated"),
+        arguments: [(0, util_1.obj)(tx, args.stakePool), (0, util_1.obj)(tx, args.lpUserShare)],
+    });
+}
+function newStakePool(tx, typeArg, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::new_stake_pool"),
+        typeArguments: [typeArg],
+        arguments: [(0, util_1.obj)(tx, args.version), (0, util_1.obj)(tx, args.registry), (0, util_1.pure)(tx, args.unlockCountdownTsMs, "u64")],
+    });
+}
+function removeIncentive(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::remove_incentive"),
+        arguments: [(0, util_1.obj)(tx, args.stakePool), (0, util_1.obj)(tx, args.tokenType)],
+    });
+}
+function removeIncentiveToken(tx, typeArg, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::remove_incentive_token"),
+        typeArguments: [typeArg],
+        arguments: [(0, util_1.obj)(tx, args.version), (0, util_1.obj)(tx, args.registry), (0, util_1.pure)(tx, args.index, "u64")],
+    });
+}
+function removeUserShareById(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::remove_user_share_by_id"),
+        arguments: [(0, util_1.obj)(tx, args.id), (0, util_1.pure)(tx, args.user, "address"), (0, util_1.pure)(tx, args.userShareId, "u64")],
+    });
+}
+function stake(tx, typeArg, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::stake"),
+        typeArguments: [typeArg],
+        arguments: [
+            (0, util_1.obj)(tx, args.version),
+            (0, util_1.obj)(tx, args.registry),
+            (0, util_1.pure)(tx, args.index, "u64"),
+            (0, util_1.obj)(tx, args.lpToken),
+            (0, util_1.pure)(tx, args.userShareId, "".concat(structs_1.Option.$typeName, "<u64>")),
+            (0, util_1.obj)(tx, args.clock),
+        ],
+    });
+}
+function storeUserShares(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::store_user_shares"),
+        arguments: [(0, util_1.obj)(tx, args.id), (0, util_1.pure)(tx, args.user, "address"), (0, util_1.vector)(tx, "".concat(structs_2.LpUserShare.$typeName), args.userShares)],
+    });
+}
+function unstake(tx, typeArg, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::unstake"),
+        typeArguments: [typeArg],
+        arguments: [
+            (0, util_1.obj)(tx, args.version),
+            (0, util_1.obj)(tx, args.registry),
+            (0, util_1.pure)(tx, args.index, "u64"),
+            (0, util_1.pure)(tx, args.userShareId, "u64"),
+            (0, util_1.pure)(tx, args.unstakedShares, "".concat(structs_1.Option.$typeName, "<u64>")),
+            (0, util_1.obj)(tx, args.clock),
+        ],
+    });
+}
+function updateIncentiveConfig(tx, typeArg, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::update_incentive_config"),
+        typeArguments: [typeArg],
+        arguments: [
+            (0, util_1.obj)(tx, args.version),
+            (0, util_1.obj)(tx, args.registry),
+            (0, util_1.pure)(tx, args.index, "u64"),
+            (0, util_1.obj)(tx, args.clock),
+            (0, util_1.pure)(tx, args.periodIncentiveAmount, "".concat(structs_1.Option.$typeName, "<u64>")),
+            (0, util_1.pure)(tx, args.incentiveIntervalTsMs, "".concat(structs_1.Option.$typeName, "<u64>")),
+            (0, util_1.pure)(tx, args.u64Padding, "".concat(structs_1.Option.$typeName, "<vector<u64>>")),
+        ],
+    });
+}
+function updateUnlockCountdownTsMs(tx, args) {
+    return tx.moveCall({
+        target: "".concat(__1.PUBLISHED_AT, "::stake_pool::update_unlock_countdown_ts_ms"),
+        arguments: [(0, util_1.obj)(tx, args.version), (0, util_1.obj)(tx, args.registry), (0, util_1.pure)(tx, args.index, "u64"), (0, util_1.pure)(tx, args.unlockCountdownTsMs, "u64")],
+    });
+}