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

package/dist/src/client.d.ts

@@ -10,7 +10,7 @@ export declare class TypusClient {
     graphQLClient: SuiGraphQLClient;
     pythClient: PythClient;
     config: TypusConfig;
-    constructor(config: TypusConfig, mvr?: Experimental_SuiClientTypes.MvrOptions);
+    constructor(config: TypusConfig);
     getCoins(params: GetCoinsParams): Promise<import("@mysten/sui/client").PaginatedCoins>;
     getObject(params: GetObjectParams): Promise<import("@mysten/sui/client").SuiObjectResponse>;
     getOwnedObjects(params: GetOwnedObjectsParams): Promise<import("@mysten/sui/client").PaginatedObjectsResponse>;
@@ -24,4 +24,5 @@ export declare class TypusClient {
     batchGetObjectsBcs(objectIds: string[]): Promise<(Uint8Array<ArrayBufferLike> | undefined)[]>;
     getDynamicFieldsBcs(parent: string): Promise<Uint8Array<ArrayBufferLike>[]>;
     getDynamicObjectFieldsBcs(parent: string): Promise<Uint8Array<ArrayBufferLike>[]>;
+    simulateTransaction(transactionBcs: Uint8Array<ArrayBufferLike>): Promise<Experimental_SuiClientTypes.DryRunTransactionResponse>;
 }

package/dist/src/client.js

@@ -8,31 +8,35 @@ const utils_1 = require("@typus/typus-sdk/dist/src/utils");
 const src_1 = require("../src");
 class TypusClient {
     // user: string;
-    constructor(config, mvr) {
+    // mvr?: Experimental_SuiClientTypes.MvrOptions
+    constructor(config) {
         this.config = config;
         const network = config.network.toLowerCase();
+        const mvr = {
+            overrides: {
+                packages: {
+                    "@typus/perp": src_1.PERP_PUBLISHED_AT,
+                    "@typus/stake-pool": src_1.STAKE_PUBLISHED_AT,
+                },
+                // types: {
+                //     "@typus/perp": PERP_PACKAGE_ID,
+                //     "@typus/stake-pool": STAKE_PACKAGE_ID,
+                // },
+            },
+        };
         this.jsonRpcClient = new client_1.SuiClient({
             network: network,
             url: config.rpcEndpoint,
-            mvr: {
-                overrides: {
-                    packages: {
-                        "@typus/perp": src_1.PERP_PUBLISHED_AT,
-                        "@typus/stake-pool": src_1.STAKE_PUBLISHED_AT,
-                    },
-                    // types: {
-                    //     "@typus/perp": PERP_PACKAGE_ID,
-                    //     "@typus/stake-pool": STAKE_PACKAGE_ID,
-                    // },
-                },
-            },
+            mvr,
         });
         this.gRpcClient = new grpc_1.SuiGrpcClient({
             network: network,
             baseUrl: `https://fullnode.${network}.sui.io:443`,
         });
         this.graphQLClient = new graphql_1.SuiGraphQLClient({
+            network: network,
             url: `https://graphql.${network}.sui.io/graphql`,
+            mvr,
         });
         this.pythClient = (0, utils_1.createPythClient)(this.jsonRpcClient, this.config.network);
     }
@@ -52,9 +56,25 @@ class TypusClient {
         return this.jsonRpcClient.multiGetObjects(params);
     }
     devInspectTransactionBlock(params) {
+        // this.gRpcClient.transactionExecutionService.simulateTransaction({ transaction: { bcs: { value: params.transactionBlock } } });
         return this.jsonRpcClient.devInspectTransactionBlock(params);
     }
     executeTransactionBlock(params) {
+        // this.gRpcClient.transactionExecutionService.executeTransaction({
+        //     transaction: { bcs: { value: params.transactionBlock } },
+        //     signatures,
+        // });
+        // this.gRpcClient.transactionExecutionService.executeTransaction({
+        //     transaction: {
+        //         bcs: {
+        //             value: transactionBytes,
+        //         },
+        //     },
+        //     signatures: signatures.map((sig) => ({
+        //         bcs: { value: fromBase64(sig) },
+        //         signature: { oneofKind: undefined },
+        //     })),
+        // });
         return this.jsonRpcClient.executeTransactionBlock(params);
     }
     signAndExecuteTransaction(params) {
@@ -104,5 +124,12 @@ class TypusClient {
             return x_1.childObject?.contents?.value;
         });
     }
+    simulateTransaction(transactionBcs) {
+        return this.gRpcClient.core.dryRunTransaction({ transaction: transactionBcs });
+        // return this.gRpcClient.transactionExecutionService.simulateTransaction({
+        //     transaction: { bcs: { value: transactionBcs } },
+        //     // checks: 1,
+        // });
+    }
 }
 exports.TypusClient = TypusClient;

package/dist/src/fetch.d.ts

@@ -1,5 +1,5 @@
 import { TOKEN } from "@typus/typus-sdk/dist/src/constants";
-import { Position } from "./generated/typus_perp/position";
+import { TradingOrder, Position } from "./generated/typus_perp/position";
 import { TypusClient } from "../src/client";
 export declare function getLpPools(client: TypusClient): Promise<{
     id: {
@@ -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: {
@@ -335,10 +341,14 @@ export declare function getMarkets(client: TypusClient, input: {
         u64_padding: string[];
     };
 }[]][]>;
+export type TradingOrder = (typeof TradingOrder.$inferType);
+export type TradingOrderWithMarketIndex = TradingOrder & {
+    marketIndex: number;
+};
 export declare function getUserOrders(client: TypusClient, input: {
     user: string;
     indexes: string[];
-}): Promise<void>;
+}): Promise<TradingOrderWithMarketIndex[]>;
 export declare function getUserPositions(client: TypusClient, input: {
     user: string;
     indexes: string[];
@@ -402,7 +412,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

@@ -90,6 +90,10 @@ async function getStakePool(client, objectId) {
 async function getMarkets(client, input) {
     let tx = new transactions_1.Transaction();
     tx.add((0, trading_1.getMarketsBcs)({ arguments: { registry: _1.MARKET, indexes: input.indexes.map((x) => BigInt(x)) } }));
+    // tx.setSender(SENDER);
+    // let bcs = await tx.build({ client: client.jsonRpcClient, onlyTransactionKind: true });
+    // // console.log("bcs", bcs);
+    // let res = await client.simulateTransaction(bcs);
     let devInspectTransactionBlockResult = await client.devInspectTransactionBlock({ sender: constants_1.SENDER, transactionBlock: tx });
     // @ts-ignore
     let bytes = devInspectTransactionBlockResult.results[0].returnValues[0][0];
@@ -127,31 +131,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, marketIndex: x });
         });
-    });
-    // 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();
@@ -204,13 +197,15 @@ function parseOptionBidReceipts(positions) {
 async function getUserStake(client, input) {
     let tx = new transactions_1.Transaction();
     for (let i of input.indexes) {
-        tx.add((0, stake_pool_1.allocateIncentive)({
-            arguments: {
-                version: _1.STAKE_POOL_VERSION,
-                registry: _1.STAKE_POOL,
-                index: BigInt(i),
-            },
-        }));
+        // tx.add(
+        //     allocateIncentive({
+        //         arguments: {
+        //             version: STAKE_POOL_VERSION,
+        //             registry: STAKE_POOL,
+        //             index: BigInt(i),
+        //         },
+        //     })
+        // );
         tx.add((0, stake_pool_1.getUserShares)({
             arguments: {
                 registry: _1.STAKE_POOL,
@@ -225,13 +220,13 @@ async function getUserStake(client, input) {
         let results = [];
         for (var x = 0; x < input.indexes.length; x++) {
             // @ts-ignore
-            var returnValues = res.results[1].returnValues[0][0];
+            var returnValues = res.results[x].returnValues[0][0];
             // console.log(returnValues);
             var reader = new bcs_1.BcsReader(new Uint8Array(returnValues));
             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,
+    });
+}