@typus/typus-perp-sdk 1.1.32-codegen-exp2 → 1.1.32-codegen-exp3

package/dist/src/fetch.d.ts

@@ -191,10 +191,13 @@ export declare function getStakePools(client: TypusClient): Promise<{
         next_user_share_id: string;
         total_share: string;
         active: boolean;
+        new_tlp_price: string;
+        depositors_count: string;
         u64_padding: string[];
     };
     config: {
         unlock_countdown_ts_ms: string;
+        usd_per_exp: string;
         u64_padding: string[];
     };
     incentives: {
@@ -228,10 +231,13 @@ export declare function getStakePool(client: TypusClient, objectId: string): Pro
         next_user_share_id: string;
         total_share: string;
         active: boolean;
+        new_tlp_price: string;
+        depositors_count: string;
         u64_padding: string[];
     };
     config: {
         unlock_countdown_ts_ms: string;
+        usd_per_exp: string;
         u64_padding: string[];
     };
     incentives: {
@@ -338,7 +344,36 @@ export declare function getMarkets(client: TypusClient, input: {
 export declare function getUserOrders(client: TypusClient, input: {
     user: string;
     indexes: string[];
-}): Promise<void>;
+}): Promise<{
+    id: {
+        id: string;
+    };
+    create_ts_ms: string;
+    order_id: string;
+    linked_position_id: string | null;
+    user: string;
+    collateral_token: {
+        name: string;
+    };
+    collateral_token_decimal: string;
+    symbol: {
+        base_token: {
+            name: string;
+        };
+        quote_token: {
+            name: string;
+        };
+    };
+    leverage_mbp: string;
+    reduce_only: boolean;
+    is_long: boolean;
+    is_stop_order: boolean;
+    size: string;
+    size_decimal: string;
+    trigger_price: string;
+    oracle_price_when_placing: string;
+    u64_padding: string[];
+}[]>;
 export declare function getUserPositions(client: TypusClient, input: {
     user: string;
     indexes: string[];
@@ -402,7 +437,39 @@ export declare function parseOptionBidReceipts(positions: (typeof Position.$infe
 export declare function getUserStake(client: TypusClient, input: {
     user: string;
     indexes: string[];
-}): Promise<any[]>;
+}): Promise<[{
+    user: string;
+    user_share_id: string;
+    stake_ts_ms: string;
+    total_shares: string;
+    active_shares: string;
+    deactivating_shares: {
+        shares: string;
+        unsubscribed_ts_ms: string;
+        unlocked_ts_ms: string;
+        unsubscribed_incentive_price_index: {
+            contents: {
+                key: {
+                    name: string;
+                };
+                value: string;
+            }[];
+        };
+        u64_padding: string[];
+    }[];
+    last_incentive_price_index: {
+        contents: {
+            key: {
+                name: string;
+            };
+            value: string;
+        }[];
+    };
+    snapshot_ts_ms: string;
+    tlp_price: string;
+    harvested_amount: string;
+    u64_padding: string[];
+} | null, string[]][]>;
 /**
  * @returns deactivatingShares[]
  */

package/dist/src/fetch.js

@@ -127,31 +127,20 @@ async function getUserOrders(client, input) {
     }
     let res = await client.devInspectTransactionBlock({ sender: input.user, transactionBlock: tx });
     // console.log(res);
-    res.results?.map((x) => {
+    let orders = [];
+    for (var x = 0; x < input.indexes.length; x++) {
         // @ts-ignore
-        let returnValues = x.returnValues[0][0];
+        let returnValues = res.results[x].returnValues[0][0];
         // console.log(returnValues);
         let reader = new bcs_1.BcsReader(new Uint8Array(returnValues));
-        let yy = reader.readVec((reader) => {
+        reader.readVec((reader) => {
             let length = reader.readULEB();
             let bytes = reader.readBytes(length);
             let order = position_1.TradingOrder.parse(bytes);
-            return order;
+            orders.push(order);
         });
-    });
-    // for (var x = 0; x < input.indexes.length; x++) {
-    //     // @ts-ignore
-    //     let returnValues = res.results[x].returnValues[0][0];
-    //     // console.log(returnValues);
-    //     let reader = new BcsReader(new Uint8Array(returnValues));
-    //     reader.readVec((reader) => {
-    //         let length = reader.readULEB();
-    //         let bytes = reader.readBytes(length);
-    //         let order = TradingOrder.parse(bytes);
-    //         orders.push(order);
-    //     });
-    // }
-    // return orders;
+    }
+    return orders;
 }
 async function getUserPositions(client, input) {
     let tx = new transactions_1.Transaction();
@@ -231,7 +220,7 @@ async function getUserStake(client, input) {
             let length = reader.readULEB();
             console.log(length);
             if (length == 0) {
-                results.push([]);
+                results.push([null, []]);
                 continue;
             }
             // let lpShare = LpUserShare.fromFields(LpUserShare.bcs.read(reader));

package/dist/src/generated/typus_stake_pool/admin.d.ts

@@ -5,7 +5,8 @@
  * The `admin` module provides administrative functionalities for the Typus Stake
  * Pool. It includes version management, authority control, and fee handling.
  */
-import { MoveStruct } from "../utils/index";
+import { MoveStruct, type RawTransactionArgument } from "../utils/index";
+import { type Transaction } from "@mysten/sui/transactions";
 export declare const FeeInfo: MoveStruct<{
     /** The type name of the token. */
     token: MoveStruct<{
@@ -98,3 +99,136 @@ export declare const SendFeeEvent: MoveStruct<{
     /** The amount of fees sent. */
     amount: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
 }, "@typus/stake-pool::admin::SendFeeEvent">;
+export interface VersionCheckArguments {
+    version: RawTransactionArgument<string>;
+}
+export interface VersionCheckOptions {
+    package?: string;
+    arguments: VersionCheckArguments | [version: RawTransactionArgument<string>];
+}
+/** Checks if the contract version is valid. */
+export declare function versionCheck(options: VersionCheckOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpgradeArguments {
+    version: RawTransactionArgument<string>;
+}
+export interface UpgradeOptions {
+    package?: string;
+    arguments: UpgradeArguments | [version: RawTransactionArgument<string>];
+}
+/** Upgrades the contract version. WARNING: no authority check inside */
+export declare function upgrade(options: UpgradeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InitOptions {
+    package?: string;
+    arguments?: [];
+}
+/** Initializes the contract. */
+export declare function init(options?: InitOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifyArguments {
+    version: RawTransactionArgument<string>;
+}
+export interface VerifyOptions {
+    package?: string;
+    arguments: VerifyArguments | [version: RawTransactionArgument<string>];
+}
+/** [Authorized Function] Verifies if the sender is an authorized user. */
+export declare function verify(options: VerifyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddAuthorizedUserArguments {
+    version: RawTransactionArgument<string>;
+    userAddress: RawTransactionArgument<string>;
+}
+export interface AddAuthorizedUserOptions {
+    package?: string;
+    arguments: AddAuthorizedUserArguments | [version: RawTransactionArgument<string>, userAddress: RawTransactionArgument<string>];
+}
+/** [Authorized Function] Adds an authorized user. */
+export declare function addAuthorizedUser(options: AddAuthorizedUserOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveAuthorizedUserArguments {
+    version: RawTransactionArgument<string>;
+    userAddress: RawTransactionArgument<string>;
+}
+export interface RemoveAuthorizedUserOptions {
+    package?: string;
+    arguments: RemoveAuthorizedUserArguments | [version: RawTransactionArgument<string>, userAddress: RawTransactionArgument<string>];
+}
+/** [Authorized Function] Removes an authorized user. */
+export declare function removeAuthorizedUser(options: RemoveAuthorizedUserOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface InstallEcosystemManagerCapEntryArguments {
+    version: RawTransactionArgument<string>;
+    typusEcosystemVersion: RawTransactionArgument<string>;
+}
+export interface InstallEcosystemManagerCapEntryOptions {
+    package?: string;
+    arguments: InstallEcosystemManagerCapEntryArguments | [version: RawTransactionArgument<string>, typusEcosystemVersion: RawTransactionArgument<string>];
+}
+/**
+ * [Authorized Function] Installs the ecosystem manager cap. TODO: can be remove
+ * after install
+ */
+export declare function installEcosystemManagerCapEntry(options: InstallEcosystemManagerCapEntryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddTailsExpAmountArguments {
+    version: RawTransactionArgument<string>;
+    typusEcosystemVersion: RawTransactionArgument<string>;
+    typusUserRegistry: RawTransactionArgument<string>;
+    user: RawTransactionArgument<string>;
+    amount: RawTransactionArgument<number | bigint>;
+}
+export interface AddTailsExpAmountOptions {
+    package?: string;
+    arguments: AddTailsExpAmountArguments | [
+        version: RawTransactionArgument<string>,
+        typusEcosystemVersion: RawTransactionArgument<string>,
+        typusUserRegistry: RawTransactionArgument<string>,
+        user: RawTransactionArgument<string>,
+        amount: RawTransactionArgument<number | bigint>
+    ];
+}
+/** Adds tails experience points to a user. */
+export declare function addTailsExpAmount(options: AddTailsExpAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SendFeeArguments {
+    version: RawTransactionArgument<string>;
+}
+export interface SendFeeOptions {
+    package?: string;
+    arguments: SendFeeArguments | [version: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+/**
+ * Sends the collected fees to the fee address. Safe with constant address as
+ * receiver
+ */
+export declare function sendFee(options: SendFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ChargeFeeArguments {
+    version: RawTransactionArgument<string>;
+    balance: RawTransactionArgument<string>;
+}
+export interface ChargeFeeOptions {
+    package?: string;
+    arguments: ChargeFeeArguments | [version: RawTransactionArgument<string>, balance: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+/** Charges a protocol fee. WARNING: no authority check inside */
+export declare function chargeFee(options: ChargeFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SendLiquidatorFeeArguments {
+    version: RawTransactionArgument<string>;
+}
+export interface SendLiquidatorFeeOptions {
+    package?: string;
+    arguments: SendLiquidatorFeeArguments | [version: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+/**
+ * Sends the liquidator fees to the fee address. Safe with constant address as
+ * receiver
+ */
+export declare function sendLiquidatorFee(options: SendLiquidatorFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ChargeLiquidatorFeeArguments {
+    version: RawTransactionArgument<string>;
+    balance: RawTransactionArgument<string>;
+}
+export interface ChargeLiquidatorFeeOptions {
+    package?: string;
+    arguments: ChargeLiquidatorFeeArguments | [version: RawTransactionArgument<string>, balance: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+/** Charges a liquidator fee. WARNING: no authority check inside */
+export declare function chargeLiquidatorFee(options: ChargeLiquidatorFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

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

@@ -37,6 +37,18 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SendFeeEvent = exports.Version = exports.FeePool = exports.FeeInfo = void 0;
+exports.versionCheck = versionCheck;
+exports.upgrade = upgrade;
+exports.init = init;
+exports.verify = verify;
+exports.addAuthorizedUser = addAuthorizedUser;
+exports.removeAuthorizedUser = removeAuthorizedUser;
+exports.installEcosystemManagerCapEntry = installEcosystemManagerCapEntry;
+exports.addTailsExpAmount = addTailsExpAmount;
+exports.sendFee = sendFee;
+exports.chargeFee = chargeFee;
+exports.sendLiquidatorFee = sendLiquidatorFee;
+exports.chargeLiquidatorFee = chargeLiquidatorFee;
 /**
  * The `admin` module provides administrative functionalities for the Typus Stake
  * Pool. It includes version management, authority control, and fee handling.
@@ -89,3 +101,172 @@ exports.SendFeeEvent = new index_1.MoveStruct({
         amount: bcs_1.bcs.u64(),
     },
 });
+/** Checks if the contract version is valid. */
+function versionCheck(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [`${packageAddress}::admin::Version`];
+    const parameterNames = ["version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "admin",
+        function: "version_check",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Upgrades the contract version. WARNING: no authority check inside */
+function upgrade(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [`${packageAddress}::admin::Version`];
+    const parameterNames = ["version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "admin",
+        function: "upgrade",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Initializes the contract. */
+function init(options = {}) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "admin",
+        function: "init",
+    });
+}
+/** [Authorized Function] Verifies if the sender is an authorized user. */
+function verify(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [`${packageAddress}::admin::Version`];
+    const parameterNames = ["version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "admin",
+        function: "verify",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [Authorized Function] Adds an authorized user. */
+function addAuthorizedUser(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [`${packageAddress}::admin::Version`, "address"];
+    const parameterNames = ["version", "userAddress"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "admin",
+        function: "add_authorized_user",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [Authorized Function] Removes an authorized user. */
+function removeAuthorizedUser(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [`${packageAddress}::admin::Version`, "address"];
+    const parameterNames = ["version", "userAddress"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "admin",
+        function: "remove_authorized_user",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * [Authorized Function] Installs the ecosystem manager cap. TODO: can be remove
+ * after install
+ */
+function installEcosystemManagerCapEntry(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::ecosystem::Version",
+    ];
+    const parameterNames = ["version", "typusEcosystemVersion"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "admin",
+        function: "install_ecosystem_manager_cap_entry",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Adds tails experience points to a user. */
+function addTailsExpAmount(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::ecosystem::Version",
+        "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::user::TypusUserRegistry",
+        "address",
+        "u64",
+    ];
+    const parameterNames = ["version", "typusEcosystemVersion", "typusUserRegistry", "user", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "admin",
+        function: "add_tails_exp_amount",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Sends the collected fees to the fee address. Safe with constant address as
+ * receiver
+ */
+function sendFee(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [`${packageAddress}::admin::Version`];
+    const parameterNames = ["version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "admin",
+        function: "send_fee",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** Charges a protocol fee. WARNING: no authority check inside */
+function chargeFee(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `0x0000000000000000000000000000000000000000000000000000000000000002::balance::Balance<${options.typeArguments[0]}>`,
+    ];
+    const parameterNames = ["version", "balance"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "admin",
+        function: "charge_fee",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Sends the liquidator fees to the fee address. Safe with constant address as
+ * receiver
+ */
+function sendLiquidatorFee(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [`${packageAddress}::admin::Version`];
+    const parameterNames = ["version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "admin",
+        function: "send_liquidator_fee",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** Charges a liquidator fee. WARNING: no authority check inside */
+function chargeLiquidatorFee(options) {
+    const packageAddress = options.package ?? "@typus/stake-pool";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `0x0000000000000000000000000000000000000000000000000000000000000002::balance::Balance<${options.typeArguments[0]}>`,
+    ];
+    const parameterNames = ["version", "balance"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "admin",
+        function: "charge_liquidator_fee",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}

package/dist/src/generated/typus_stake_pool/stake_pool.d.ts

@@ -23,10 +23,11 @@ export declare const StakePoolInfo: MoveStruct<{
     total_share: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
     /** Whether the pool is active. */
     active: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
-    /**
-     * Padding for future use. [new_tlp_price (decimal 4), usd_per_exp,
-     * depositors_count]
-     */
+    /** tlp price (decimal 4) */
+    new_tlp_price: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** number of depositor */
+    depositors_count: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Padding for future use. */
     u64_padding: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
         length: number;
     }, string>;
@@ -34,6 +35,8 @@ export declare const StakePoolInfo: MoveStruct<{
 export declare const StakePoolConfig: MoveStruct<{
     /** The unlock countdown in milliseconds. */
     unlock_countdown_ts_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** for exp calculation */
+    usd_per_exp: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
     /** Padding for future use. */
     u64_padding: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
         length: number;
@@ -113,10 +116,11 @@ export declare const StakePool: MoveStruct<{
         total_share: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
         /** Whether the pool is active. */
         active: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
-        /**
-         * Padding for future use. [new_tlp_price (decimal 4), usd_per_exp,
-         * depositors_count]
-         */
+        /** tlp price (decimal 4) */
+        new_tlp_price: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        /** number of depositor */
+        depositors_count: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        /** Padding for future use. */
         u64_padding: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
             length: number;
         }, string>;
@@ -125,6 +129,8 @@ export declare const StakePool: MoveStruct<{
     config: MoveStruct<{
         /** The unlock countdown in milliseconds. */
         unlock_countdown_ts_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        /** for exp calculation */
+        usd_per_exp: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
         /** Padding for future use. */
         u64_padding: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
             length: number;
@@ -264,10 +270,13 @@ export declare const LpUserShare: MoveStruct<{
             length: number;
         }, string>;
     }, "0x2::vec_map::VecMap<std::type_name::TypeName, u64>">;
-    /**
-     * Padding for future use. [snapshot_ts_ms, old_tlp_price (decimal 4),
-     * is_auto_compound(deprecated), harvested_amount]
-     */
+    /** The last snapshot ts for exp. */
+    snapshot_ts_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** old tlp price for exp with decimal 4 */
+    tlp_price: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** accumulated harvested amount */
+    harvested_amount: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Padding for future use. */
     u64_padding: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
         length: number;
     }, string>;
@@ -287,10 +296,11 @@ export declare const NewStakePoolEvent: MoveStruct<{
         total_share: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
         /** Whether the pool is active. */
         active: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
-        /**
-         * Padding for future use. [new_tlp_price (decimal 4), usd_per_exp,
-         * depositors_count]
-         */
+        /** tlp price (decimal 4) */
+        new_tlp_price: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        /** number of depositor */
+        depositors_count: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        /** Padding for future use. */
         u64_padding: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
             length: number;
         }, string>;
@@ -298,6 +308,8 @@ export declare const NewStakePoolEvent: MoveStruct<{
     stake_pool_config: MoveStruct<{
         /** The unlock countdown in milliseconds. */
         unlock_countdown_ts_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        /** for exp calculation */
+        usd_per_exp: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
         /** Padding for future use. */
         u64_padding: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
             length: number;
@@ -732,7 +744,6 @@ export interface StakeArguments {
     registry: RawTransactionArgument<string>;
     index: RawTransactionArgument<number | bigint>;
     lpToken: RawTransactionArgument<string>;
-    UserShareId: RawTransactionArgument<number | bigint | null>;
 }
 export interface StakeOptions {
     package?: string;
@@ -740,8 +751,7 @@ export interface StakeOptions {
         version: RawTransactionArgument<string>,
         registry: RawTransactionArgument<string>,
         index: RawTransactionArgument<number | bigint>,
-        lpToken: RawTransactionArgument<string>,
-        UserShareId: RawTransactionArgument<number | bigint | null>
+        lpToken: RawTransactionArgument<string>
     ];
     typeArguments: [string];
 }
@@ -766,30 +776,12 @@ export interface UpdatePoolInfoU64PaddingOptions {
 }
 /** [Authorized Function] Update TLP price for calculating staking exp */
 export declare function updatePoolInfoU64Padding(options: UpdatePoolInfoU64PaddingOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface HotfixPoolInfoU64PaddingArguments {
-    version: RawTransactionArgument<string>;
-    registry: RawTransactionArgument<string>;
-    index: RawTransactionArgument<number | bigint>;
-    u64Padding: RawTransactionArgument<number | bigint[]>;
-}
-export interface HotfixPoolInfoU64PaddingOptions {
-    package?: string;
-    arguments: HotfixPoolInfoU64PaddingArguments | [
-        version: RawTransactionArgument<string>,
-        registry: RawTransactionArgument<string>,
-        index: RawTransactionArgument<number | bigint>,
-        u64Padding: RawTransactionArgument<number | bigint[]>
-    ];
-}
-/** [Authorized Function] Update TLP price for calculating staking exp */
-export declare function hotfixPoolInfoU64Padding(options: HotfixPoolInfoU64PaddingOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface SnapshotArguments {
     version: RawTransactionArgument<string>;
     registry: RawTransactionArgument<string>;
     typusEcosystemVersion: RawTransactionArgument<string>;
     typusUserRegistry: RawTransactionArgument<string>;
     index: RawTransactionArgument<number | bigint>;
-    UserShareId: RawTransactionArgument<number | bigint>;
 }
 export interface SnapshotOptions {
     package?: string;
@@ -798,8 +790,7 @@ export interface SnapshotOptions {
         registry: RawTransactionArgument<string>,
         typusEcosystemVersion: RawTransactionArgument<string>,
         typusUserRegistry: RawTransactionArgument<string>,
-        index: RawTransactionArgument<number | bigint>,
-        UserShareId: RawTransactionArgument<number | bigint>
+        index: RawTransactionArgument<number | bigint>
     ];
 }
 /** [User Function] Get the staking exp */
@@ -808,7 +799,6 @@ export interface UnsubscribeArguments {
     version: RawTransactionArgument<string>;
     registry: RawTransactionArgument<string>;
     index: RawTransactionArgument<number | bigint>;
-    UserShareId: RawTransactionArgument<number | bigint>;
     unsubscribedShares: RawTransactionArgument<number | bigint | null>;
 }
 export interface UnsubscribeOptions {
@@ -817,7 +807,6 @@ export interface UnsubscribeOptions {
         version: RawTransactionArgument<string>,
         registry: RawTransactionArgument<string>,
         index: RawTransactionArgument<number | bigint>,
-        UserShareId: RawTransactionArgument<number | bigint>,
         unsubscribedShares: RawTransactionArgument<number | bigint | null>
     ];
     typeArguments: [string];
@@ -828,15 +817,13 @@ export interface UnstakeArguments {
     version: RawTransactionArgument<string>;
     registry: RawTransactionArgument<string>;
     index: RawTransactionArgument<number | bigint>;
-    UserShareId: RawTransactionArgument<number | bigint>;
 }
 export interface UnstakeOptions {
     package?: string;
     arguments: UnstakeArguments | [
         version: RawTransactionArgument<string>,
         registry: RawTransactionArgument<string>,
-        index: RawTransactionArgument<number | bigint>,
-        UserShareId: RawTransactionArgument<number | bigint>
+        index: RawTransactionArgument<number | bigint>
     ];
     typeArguments: [string];
 }
@@ -869,15 +856,13 @@ export interface HarvestPerUserShareArguments {
     version: RawTransactionArgument<string>;
     registry: RawTransactionArgument<string>;
     index: RawTransactionArgument<number | bigint>;
-    UserShareId: RawTransactionArgument<number | bigint>;
 }
 export interface HarvestPerUserShareOptions {
     package?: string;
     arguments: HarvestPerUserShareArguments | [
         version: RawTransactionArgument<string>,
         registry: RawTransactionArgument<string>,
-        index: RawTransactionArgument<number | bigint>,
-        UserShareId: RawTransactionArgument<number | bigint>
+        index: RawTransactionArgument<number | bigint>
     ];
     typeArguments: [string];
 }
@@ -999,25 +984,3 @@ export interface GetLastIncentivePriceIndexOptions {
     arguments: GetLastIncentivePriceIndexArguments | [stakePool: RawTransactionArgument<string>];
 }
 export declare function getLastIncentivePriceIndex(options: GetLastIncentivePriceIndexOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface WithdrawIncentiveArguments {
-    version: RawTransactionArgument<string>;
-    registry: RawTransactionArgument<string>;
-    index: RawTransactionArgument<number | bigint>;
-    amount: RawTransactionArgument<number | bigint | null>;
-}
-export interface WithdrawIncentiveOptions {
-    package?: string;
-    arguments: WithdrawIncentiveArguments | [
-        version: RawTransactionArgument<string>,
-        registry: RawTransactionArgument<string>,
-        index: RawTransactionArgument<number | bigint>,
-        amount: RawTransactionArgument<number | bigint | null>
-    ];
-    typeArguments: [string];
-}
-export declare function withdrawIncentive(options: WithdrawIncentiveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface DeprecatedOptions {
-    package?: string;
-    arguments?: [];
-}
-export declare function deprecated(options?: DeprecatedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

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

@@ -48,7 +48,6 @@ exports.depositIncentive = depositIncentive;
 exports.withdrawIncentiveV2 = withdrawIncentiveV2;
 exports.stake = stake;
 exports.updatePoolInfoU64Padding = updatePoolInfoU64Padding;
-exports.hotfixPoolInfoU64Padding = hotfixPoolInfoU64Padding;
 exports.snapshot = snapshot;
 exports.unsubscribe = unsubscribe;
 exports.unstake = unstake;
@@ -67,8 +66,6 @@ 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 *
  **************************************************************/
@@ -99,10 +96,11 @@ exports.StakePoolInfo = new index_1.MoveStruct({
         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]
-         */
+        /** tlp price (decimal 4) */
+        new_tlp_price: bcs_1.bcs.u64(),
+        /** number of depositor */
+        depositors_count: bcs_1.bcs.u64(),
+        /** Padding for future use. */
         u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
     },
 });
@@ -111,6 +109,8 @@ exports.StakePoolConfig = new index_1.MoveStruct({
     fields: {
         /** The unlock countdown in milliseconds. */
         unlock_countdown_ts_ms: bcs_1.bcs.u64(),
+        /** for exp calculation */
+        usd_per_exp: bcs_1.bcs.u64(),
         /** Padding for future use. */
         u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
     },
@@ -198,10 +198,13 @@ exports.LpUserShare = new index_1.MoveStruct({
         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]
-         */
+        /** The last snapshot ts for exp. */
+        snapshot_ts_ms: bcs_1.bcs.u64(),
+        /** old tlp price for exp with decimal 4 */
+        tlp_price: bcs_1.bcs.u64(),
+        /** accumulated harvested amount */
+        harvested_amount: bcs_1.bcs.u64(),
+        /** Padding for future use. */
         u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
     },
 });
@@ -592,10 +595,9 @@ function stake(options) {
         `${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"];
+    const parameterNames = ["version", "registry", "index", "lpToken"];
     return (tx) => tx.moveCall({
         package: packageAddress,
         module: "stake_pool",
@@ -622,36 +624,18 @@ function updatePoolInfoU64Padding(options) {
         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",
+        "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::ecosystem::Version",
+        "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::user::TypusUserRegistry",
         "u64",
         "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
     ];
-    const parameterNames = ["version", "registry", "typusEcosystemVersion", "typusUserRegistry", "index", "UserShareId"];
+    const parameterNames = ["version", "registry", "typusEcosystemVersion", "typusUserRegistry", "index"];
     return (tx) => tx.moveCall({
         package: packageAddress,
         module: "stake_pool",
@@ -666,11 +650,10 @@ function unsubscribe(options) {
         `${packageAddress}::admin::Version`,
         `${packageAddress}::stake_pool::StakePoolRegistry`,
         "u64",
-        "u64",
         "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
         "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
     ];
-    const parameterNames = ["version", "registry", "index", "UserShareId", "unsubscribedShares"];
+    const parameterNames = ["version", "registry", "index", "unsubscribedShares"];
     return (tx) => tx.moveCall({
         package: packageAddress,
         module: "stake_pool",
@@ -686,10 +669,9 @@ function unstake(options) {
         `${packageAddress}::admin::Version`,
         `${packageAddress}::stake_pool::StakePoolRegistry`,
         "u64",
-        "u64",
         "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
     ];
-    const parameterNames = ["version", "registry", "index", "UserShareId"];
+    const parameterNames = ["version", "registry", "index"];
     return (tx) => tx.moveCall({
         package: packageAddress,
         module: "stake_pool",
@@ -731,10 +713,9 @@ function harvestPerUserShare(options) {
         `${packageAddress}::admin::Version`,
         `${packageAddress}::stake_pool::StakePoolRegistry`,
         "u64",
-        "u64",
         "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
     ];
-    const parameterNames = ["version", "registry", "index", "UserShareId"];
+    const parameterNames = ["version", "registry", "index"];
     return (tx) => tx.moveCall({
         package: packageAddress,
         module: "stake_pool",
@@ -891,28 +872,3 @@ function getLastIncentivePriceIndex(options) {
         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",
-    });
-}

package/dist/src/index.js

@@ -36,13 +36,13 @@ exports.PERP_PKG_V1 = exports.NETWORK == "MAINNET"
     : "0x29d1dcc803ec1cc1b4c98a8c818c655ecf432ebd2f85757bffc21806d329e240";
 exports.STAKE_PACKAGE_ID = exports.NETWORK == "MAINNET"
     ? "0xc427209145715a00a93d7e674a95c556a7147d79fda1bbaeb1a1cac5f9923966"
-    : "0xcfe3d323fec2dde129480328dbcf075bc47bac50f916f33746d74f1c875acd2e";
+    : "0xa59d5f571a6f57ee5faf842ec633245afb78ca3721b8b1194052c69ad6a12230";
 exports.STAKE_PUBLISHED_AT = exports.NETWORK == "MAINNET"
     ? "0xdf96424bc1ba70a6e53c07b2b55c597eccb8a21f722a917a5b4c9d8514b2d858"
-    : "0xcfe3d323fec2dde129480328dbcf075bc47bac50f916f33746d74f1c875acd2e";
+    : "0xa59d5f571a6f57ee5faf842ec633245afb78ca3721b8b1194052c69ad6a12230";
 exports.STAKE_PKG_V1 = exports.NETWORK == "MAINNET"
     ? "0xc427209145715a00a93d7e674a95c556a7147d79fda1bbaeb1a1cac5f9923966"
-    : "0xcfe3d323fec2dde129480328dbcf075bc47bac50f916f33746d74f1c875acd2e";
+    : "0xa59d5f571a6f57ee5faf842ec633245afb78ca3721b8b1194052c69ad6a12230";
 // lp_pool::Registry
 exports.LP_POOL = exports.NETWORK == "MAINNET"
     ? "0xfee68e535bf24702be28fa38ea2d5946e617e0035027d5ca29dbed99efd82aaa"
@@ -64,10 +64,10 @@ exports.TLP_TREASURY_CAP = exports.NETWORK == "MAINNET"
 // StakePoolRegistry
 exports.STAKE_POOL = exports.NETWORK == "MAINNET"
     ? "0x2cdf93717f87a8a7aeb98b27777b3b643f0ae2b277f44e6bcda0fc655a47d3e0"
-    : "0xc48d38a6cd76ac6628ba98f1bdad7ade8d4b5273066aa4408a81e5e00a92363e";
+    : "0xa43479d938b1d46e2dc3ae0558a54c2ab32312a1da8eeaa8d5b49238e739b2fa";
 exports.STAKE_POOL_VERSION = exports.NETWORK == "MAINNET"
     ? "0xdf3ed1599218b2415b2cd7fa06296f7f647676019b2873ec18e55a626c584f1b"
-    : "0x138583562f9f8fc6261e8fd752a105eb42c8887f83efaba87b42a757f3d98765";
+    : "0x57221de2517aee3d628be7fcf07afb9f6021edb06b519e57bd84ec5d37fff6f5";
 exports.COMPETITION_CONFIG = exports.NETWORK == "MAINNET"
     ? "0x36056abf9adde86f81667dad680a8ac98868c9fc1cb4d519fd2222d5d4522906"
     : "0xbb246d6ee24d7c751777d81cbf95ffcfcda26910fecfdcfedab81b2b8e48dfe5";

package/dist/src/user/order.d.ts

@@ -3,6 +3,7 @@ import { TOKEN } from "@typus/typus-sdk/dist/src/constants";
 import { Transaction } from "@mysten/sui/transactions";
 import { TypusClient } from "../../src/client";
 export declare function createTradingOrder(client: TypusClient, tx: Transaction, input: {
+    perpIndex: string;
     coins: string[];
     cToken: TOKEN;
     amount: string;
@@ -17,21 +18,25 @@ export declare function createTradingOrder(client: TypusClient, tx: Transaction,
 }): Promise<Transaction>;
 export declare function zeroCoin(tx: Transaction, typeArgs: [string]): import("@mysten/sui/transactions").TransactionResult;
 export declare function cancelTradingOrder(client: TypusClient, tx: Transaction, input: {
+    perpIndex: string;
     order: typeof TradingOrder.$inferType;
     user: string;
 }): Promise<Transaction>;
 export declare function increaseCollateral(client: TypusClient, tx: Transaction, input: {
+    perpIndex: string;
     coins: string[];
     amount: string;
     position: typeof Position.$inferType;
     suiCoins?: string[];
 }): Promise<Transaction>;
 export declare function releaseCollateral(client: TypusClient, tx: Transaction, input: {
+    perpIndex: string;
     position: typeof Position.$inferType;
     amount: string;
     suiCoins?: string[];
 }): Promise<Transaction>;
 export declare function collectPositionFundingFee(client: TypusClient, tx: Transaction, input: {
+    perpIndex: string;
     position: typeof Position.$inferType;
     suiCoins?: string[];
 }): Promise<Transaction>;

package/dist/src/user/order.js

@@ -40,8 +40,8 @@ async function createTradingOrder(client, tx, input) {
             version: __1.PERP_VERSION,
             registry: __1.MARKET,
             poolRegistry: __1.LP_POOL,
-            marketIndex: BigInt(0),
-            poolIndex: BigInt(0),
+            marketIndex: BigInt(input.perpIndex),
+            poolIndex: BigInt(input.perpIndex),
             typusOracleCToken: constants_1.oracle[__1.NETWORK][TOKEN],
             typusOracleTradingSymbol: constants_1.oracle[__1.NETWORK][BASE_TOKEN],
             typusEcosystemVersion: client.config.version.typus,
@@ -75,7 +75,7 @@ async function cancelTradingOrder(client, tx, input) {
         arguments: {
             version: __1.PERP_VERSION,
             registry: __1.MARKET,
-            marketIndex: BigInt(0),
+            marketIndex: BigInt(input.perpIndex),
             orderId: BigInt(input.order.order_id),
             triggerPrice: BigInt(input.order.trigger_price),
             orderUser: null,
@@ -115,8 +115,8 @@ async function increaseCollateral(client, tx, input) {
             version: __1.PERP_VERSION,
             registry: __1.MARKET,
             poolRegistry: __1.LP_POOL,
-            marketIndex: BigInt(0),
-            poolIndex: BigInt(0),
+            marketIndex: BigInt(input.perpIndex),
+            poolIndex: BigInt(input.perpIndex),
             typusOracleCToken: constants_1.oracle[__1.NETWORK][TOKEN],
             typusOracleTradingSymbol: constants_1.oracle[__1.NETWORK][BASE_TOKEN],
             positionId: BigInt(input.position.position_id),
@@ -146,8 +146,8 @@ async function releaseCollateral(client, tx, input) {
             version: __1.PERP_VERSION,
             registry: __1.MARKET,
             poolRegistry: __1.LP_POOL,
-            marketIndex: BigInt(0),
-            poolIndex: BigInt(0),
+            marketIndex: BigInt(input.perpIndex),
+            poolIndex: BigInt(input.perpIndex),
             typusOracleCToken: constants_1.oracle[__1.NETWORK][TOKEN],
             typusOracleTradingSymbol: constants_1.oracle[__1.NETWORK][BASE_TOKEN],
             positionId: BigInt(input.position.position_id),
@@ -178,8 +178,8 @@ async function collectPositionFundingFee(client, tx, input) {
             version: __1.PERP_VERSION,
             registry: __1.MARKET,
             poolRegistry: __1.LP_POOL,
-            marketIndex: BigInt(0),
-            poolIndex: BigInt(0),
+            marketIndex: BigInt(input.perpIndex),
+            poolIndex: BigInt(input.perpIndex),
             typusOracleCToken: constants_1.oracle[__1.NETWORK][TOKEN],
             typusOracleTradingSymbol: constants_1.oracle[__1.NETWORK][BASE_TOKEN],
             positionId: BigInt(input.position.position_id),

package/dist/src/user/tlp.d.ts

@@ -4,8 +4,7 @@ import { StakePool } from "../../src/generated/typus_stake_pool/stake_pool";
 import { LiquidityPool } from "../../src/generated/typus_perp/lp_pool";
 import { TypusClient } from "../../src/client";
 export declare function snapshot(client: TypusClient, tx: Transaction, input: {
-    userShareId: string;
-    perpIndex?: number;
+    perpIndex: string;
 }): Promise<Transaction>;
 export declare function mintStakeLp(client: TypusClient, tx: Transaction, input: {
     lpPool: typeof LiquidityPool.$inferType;
@@ -18,7 +17,6 @@ export declare function mintStakeLp(client: TypusClient, tx: Transaction, input:
     user: string;
     stake: boolean;
     suiCoins?: string[];
-    perpIndex?: number;
 }): Promise<Transaction>;
 export declare function stakeLp(client: TypusClient, tx: Transaction, input: {
     stakePool: typeof StakePool.$inferType;
@@ -26,7 +24,6 @@ export declare function stakeLp(client: TypusClient, tx: Transaction, input: {
     amount: string;
     userShareId: string | null;
     user: string;
-    perpIndex?: number;
 }): Promise<Transaction>;
 export declare function unstake(client: TypusClient, tx: Transaction, input: {
     lpPool: typeof LiquidityPool.$inferType;
@@ -34,7 +31,6 @@ export declare function unstake(client: TypusClient, tx: Transaction, input: {
     userShareId: string;
     share: string | null;
     user: string;
-    perpIndex?: number;
 }): Promise<Transaction>;
 export declare function unstakeRedeem(client: TypusClient, tx: Transaction, input: {
     lpPool: typeof LiquidityPool.$inferType;
@@ -43,7 +39,6 @@ export declare function unstakeRedeem(client: TypusClient, tx: Transaction, inpu
     share: string | null;
     user: string;
     suiCoins?: string[];
-    perpIndex?: number;
 }): Promise<Transaction>;
 export declare function redeemTlp(client: TypusClient, tx: Transaction, input: {
     lpPool: typeof LiquidityPool.$inferType;
@@ -51,7 +46,6 @@ export declare function redeemTlp(client: TypusClient, tx: Transaction, input: {
     share: string | null;
     user: string;
     suiCoins?: string[];
-    perpIndex?: number;
 }): Promise<Transaction>;
 export declare function claim(client: TypusClient, tx: Transaction, input: {
     lpPool: typeof LiquidityPool.$inferType;
@@ -59,7 +53,6 @@ export declare function claim(client: TypusClient, tx: Transaction, input: {
     cTOKEN: TOKEN;
     user: string;
     suiCoins?: string[];
-    perpIndex?: number;
 }): Promise<Transaction>;
 export declare function swap(client: TypusClient, tx: Transaction, input: {
     coins: string[];
@@ -67,12 +60,11 @@ export declare function swap(client: TypusClient, tx: Transaction, input: {
     TO_TOKEN: TOKEN;
     amount: string;
     user: string;
+    perpIndex: number;
     suiCoins?: string[];
-    perpIndex?: number;
 }): Promise<Transaction>;
 export declare function harvestStakeReward(client: TypusClient, tx: Transaction, input: {
     stakePool: typeof StakePool.$inferType;
     userShareId: string;
     user: string;
-    perpIndex?: number;
 }): Promise<Transaction>;

package/dist/src/user/tlp.js

@@ -20,8 +20,7 @@ async function snapshot(client, tx, input) {
         arguments: {
             version: __1.STAKE_POOL_VERSION,
             registry: __1.STAKE_POOL,
-            index: BigInt(input.perpIndex ?? 0),
-            UserShareId: BigInt(input.userShareId),
+            index: BigInt(input.perpIndex),
             typusEcosystemVersion: client.config.version.typus,
             typusUserRegistry: client.config.registry.typus.user,
         },
@@ -54,7 +53,7 @@ async function mintStakeLp(client, tx, input) {
             arguments: {
                 version: __1.PERP_VERSION,
                 registry: __1.LP_POOL,
-                index: BigInt(input.perpIndex ?? 0),
+                index: BigInt(input.stakePool.pool_info.index),
                 oracle: constants_1.oracle[__1.NETWORK][token],
             },
             typeArguments: [constants_1.tokenType[__1.NETWORK][token]],
@@ -70,7 +69,7 @@ async function mintStakeLp(client, tx, input) {
             version: __1.PERP_VERSION,
             registry: __1.LP_POOL,
             treasuryCaps: __1.TLP_TREASURY_CAP,
-            index: BigInt(input.perpIndex ?? 0),
+            index: BigInt(input.stakePool.pool_info.index),
             oracle: constants_1.oracle[__1.NETWORK][input.cTOKEN],
             coin,
         },
@@ -81,9 +80,8 @@ async function mintStakeLp(client, tx, input) {
             arguments: {
                 version: __1.STAKE_POOL_VERSION,
                 registry: __1.STAKE_POOL,
-                index: BigInt(input.perpIndex ?? 0),
+                index: BigInt(input.stakePool.pool_info.index),
                 lpToken: lpCoin,
-                UserShareId: null,
             },
             typeArguments: [lpToken],
         }));
@@ -108,9 +106,8 @@ async function stakeLp(client, tx, input) {
         arguments: {
             version: __1.STAKE_POOL_VERSION,
             registry: __1.STAKE_POOL,
-            index: BigInt(input.perpIndex ?? 0),
+            index: BigInt(input.stakePool.pool_info.index),
             lpToken: lpCoin,
-            UserShareId: null,
         },
         typeArguments: [(0, utils_1.normalizeStructTag)(input.stakePool.pool_info.stake_token.name)],
     }));
@@ -123,9 +120,8 @@ async function unstake(client, tx, input) {
         arguments: {
             version: __1.STAKE_POOL_VERSION,
             registry: __1.STAKE_POOL,
-            index: BigInt(input.perpIndex ?? 0),
+            index: BigInt(input.stakePool.pool_info.index),
             unsubscribedShares: input.share ? BigInt(input.share) : null,
-            UserShareId: BigInt(input.userShareId),
         },
         typeArguments: [lpToken],
     }));
@@ -133,8 +129,7 @@ async function unstake(client, tx, input) {
         arguments: {
             version: __1.STAKE_POOL_VERSION,
             registry: __1.STAKE_POOL,
-            index: BigInt(input.perpIndex ?? 0),
-            UserShareId: BigInt(input.userShareId),
+            index: BigInt(input.stakePool.pool_info.index),
         },
         typeArguments: [lpToken],
     }));
@@ -152,7 +147,12 @@ async function unstakeRedeem(client, tx, input) {
     for (let token of tokens) {
         (0, utils_2.updateOracleWithPythUsd)(client.pythClient, tx, client.config.package.oracle, token);
         (0, lp_pool_1.updateLiquidityValue)({
-            arguments: { version: __1.PERP_VERSION, registry: __1.LP_POOL, index: BigInt(input.perpIndex ?? 0), oracle: constants_1.oracle[__1.NETWORK][token] },
+            arguments: {
+                version: __1.PERP_VERSION,
+                registry: __1.LP_POOL,
+                index: BigInt(input.stakePool.pool_info.index),
+                oracle: constants_1.oracle[__1.NETWORK][token],
+            },
             typeArguments: [constants_1.tokenType[__1.NETWORK][token]],
         })(tx);
     }
@@ -162,9 +162,8 @@ async function unstakeRedeem(client, tx, input) {
         arguments: {
             version: __1.STAKE_POOL_VERSION,
             registry: __1.STAKE_POOL,
-            index: BigInt(input.perpIndex ?? 0),
+            index: BigInt(input.stakePool.pool_info.index),
             unsubscribedShares: input.share ? BigInt(input.share) : null,
-            UserShareId: BigInt(input.userShareId),
         },
         typeArguments: [lpToken],
     }));
@@ -172,8 +171,7 @@ async function unstakeRedeem(client, tx, input) {
         arguments: {
             version: __1.STAKE_POOL_VERSION,
             registry: __1.STAKE_POOL,
-            index: BigInt(input.perpIndex ?? 0),
-            UserShareId: BigInt(input.userShareId),
+            index: BigInt(input.stakePool.pool_info.index),
         },
         typeArguments: [lpToken],
     }));
@@ -186,7 +184,7 @@ async function unstakeRedeem(client, tx, input) {
         arguments: {
             version: __1.PERP_VERSION,
             registry: __1.LP_POOL,
-            index: BigInt(input.perpIndex ?? 0),
+            index: BigInt(input.stakePool.pool_info.index),
             balance,
         },
         typeArguments: [input.lpPool.lp_token_type.name],
@@ -207,7 +205,7 @@ async function redeemTlp(client, tx, input) {
             arguments: {
                 version: __1.PERP_VERSION,
                 registry: __1.LP_POOL,
-                index: BigInt(input.perpIndex ?? 0),
+                index: BigInt(input.lpPool.index),
                 oracle: constants_1.oracle[__1.NETWORK][token],
             },
             typeArguments: [constants_1.tokenType[__1.NETWORK][token]],
@@ -235,7 +233,7 @@ async function redeemTlp(client, tx, input) {
         arguments: {
             version: __1.PERP_VERSION,
             registry: __1.LP_POOL,
-            index: BigInt(input.perpIndex ?? 0),
+            index: BigInt(input.lpPool.index),
             balance,
         },
         typeArguments: [lpToken],
@@ -253,7 +251,12 @@ async function claim(client, tx, input) {
     for (let token of tokens) {
         (0, utils_2.updateOracleWithPythUsd)(client.pythClient, tx, client.config.package.oracle, token);
         (0, lp_pool_1.updateLiquidityValue)({
-            arguments: { version: __1.PERP_VERSION, registry: __1.LP_POOL, index: BigInt(input.perpIndex ?? 0), oracle: constants_1.oracle[__1.NETWORK][token] },
+            arguments: {
+                version: __1.PERP_VERSION,
+                registry: __1.LP_POOL,
+                index: BigInt(input.stakePool.pool_info.index),
+                oracle: constants_1.oracle[__1.NETWORK][token],
+            },
             typeArguments: [constants_1.tokenType[__1.NETWORK][token]],
         })(tx);
     }
@@ -262,7 +265,7 @@ async function claim(client, tx, input) {
         arguments: {
             version: __1.PERP_VERSION,
             registry: __1.LP_POOL,
-            index: BigInt(input.perpIndex ?? 0),
+            index: BigInt(input.stakePool.pool_info.index),
             treasuryCaps: __1.TLP_TREASURY_CAP,
             oracle: constants_1.oracle[__1.NETWORK][input.cTOKEN],
         },
@@ -295,7 +298,7 @@ async function swap(client, tx, input) {
         arguments: {
             version: __1.PERP_VERSION,
             registry: __1.LP_POOL,
-            index: BigInt(input.perpIndex ?? 0),
+            index: BigInt(input.perpIndex),
             oracleFromToken: constants_1.oracle[__1.NETWORK][input.FROM_TOKEN],
             oracleToToken: constants_1.oracle[__1.NETWORK][input.TO_TOKEN],
             fromCoin: coin,
@@ -308,15 +311,14 @@ async function swap(client, tx, input) {
 }
 async function harvestStakeReward(client, tx, input) {
     let iTokens = input.stakePool.incentives.map((i) => i.token_type.name);
-    snapshot(client, tx, { userShareId: input.userShareId });
+    snapshot(client, tx, { perpIndex: input.stakePool.pool_info.index });
     for (let iToken of iTokens) {
         // console.log(iToken);
         let iCoin = tx.add((0, stake_pool_1.harvestPerUserShare)({
             arguments: {
                 version: __1.STAKE_POOL_VERSION,
                 registry: __1.STAKE_POOL,
-                index: BigInt(input.perpIndex ?? 0),
-                UserShareId: BigInt(input.userShareId),
+                index: BigInt(input.stakePool.pool_info.index),
             },
             typeArguments: [iToken],
         }));
@@ -326,9 +328,8 @@ async function harvestStakeReward(client, tx, input) {
                 arguments: {
                     version: __1.STAKE_POOL_VERSION,
                     registry: __1.STAKE_POOL,
-                    index: BigInt(input.perpIndex ?? 0),
+                    index: BigInt(input.stakePool.pool_info.index),
                     lpToken: iCoin,
-                    UserShareId: BigInt(input.userShareId),
                 },
                 typeArguments: [(0, utils_1.normalizeStructTag)(input.stakePool.pool_info.stake_token.name)],
             }));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@typus/typus-perp-sdk",
-    "version": "1.1.32-codegen-exp2",
+    "version": "1.1.32-codegen-exp3",
     "repository": "https://github.com/Typus-Lab/typus-perp-sdk.git",
     "author": "Typus",
     "description": "typus perp sdk",
@@ -8,7 +8,7 @@
     "dependencies": {
         "@mysten/bcs": "1.9.2",
         "@mysten/sui": "1.44.0",
-        "@typus/typus-sdk": "1.8.21"
+        "@typus/typus-sdk": "1.8.25"
     },
     "resolutions": {
         "@mysten/bcs": "1.9.2",