@typus/typus-sdk 1.4.3-d → 1.4.3-f

package/{dist/typus-perp/readVec.js → src/typus-perp/readVec.ts}

@@ -1,22 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readVecPosition = readVecPosition;
-exports.readVecOrder = readVecOrder;
-exports.readVecShares = readVecShares;
-var bcs_1 = require("@mysten/bcs");
-var tools_1 = require("src/utils/tools");
+import { BcsReader } from "@mysten/bcs";
+import { AddressFromBytes } from "src/utils/tools";
 // import { Position, TradingOrder } from "./position/structs";
-function readVecPosition(bytes) {
-    var reader = new bcs_1.BcsReader(bytes);
-    return reader.readVec(function (reader) {
+
+export function readVecPosition(bytes: Uint8Array) {
+    let reader = new BcsReader(bytes);
+    return reader.readVec((reader) => {
         reader.read16();
-        var position = {
-            id: (0, tools_1.AddressFromBytes)(reader.readBytes(32)),
+        let position = {
+            id: AddressFromBytes(reader.readBytes(32)),
             createTsMs: reader.read64(),
             positionId: reader.read64(),
-            linkedOrderIds: reader.readVec(function (reader) { return reader.read64(); }),
-            linkedOrderPrices: reader.readVec(function (reader) { return reader.read64(); }),
-            user: (0, tools_1.AddressFromBytes)(reader.readBytes(32)),
+            linkedOrderIds: reader.readVec((reader) => reader.read64()),
+            linkedOrderPrices: reader.readVec((reader) => reader.read64()),
+            user: AddressFromBytes(reader.readBytes(32)),
             isLong: reader.read8(),
             size: reader.read64(),
             sizeDecimal: reader.read64(),
@@ -38,32 +34,34 @@ function readVecPosition(bytes) {
             unrealizedBorrowFee: reader.read64(),
             unrealizedRebate: reader.read64(),
             optionCollateralInfo: reader
-                .readVec(function (reader) {
-                return {
-                    index: reader.read64(),
-                    bid_token: { name: String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.read8()))) },
-                };
-            })
+                .readVec((reader) => {
+                    return {
+                        index: reader.read64(),
+                        bid_token: { name: String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.read8()))) },
+                    };
+                })
                 .at(0),
-            u64Padding: reader.readVec(function (reader) { return reader.read64(); }),
+            u64Padding: reader.readVec((reader) => reader.read64()),
         };
+
         return position;
     });
 }
-function readVecOrder(bytes) {
-    var reader = new bcs_1.BcsReader(bytes);
-    return reader.readVec(function (reader) {
+
+export function readVecOrder(bytes: Uint8Array) {
+    let reader = new BcsReader(bytes);
+    return reader.readVec((reader) => {
         reader.read16();
-        var order = {
-            id: (0, tools_1.AddressFromBytes)(reader.readBytes(32)),
+        let order = {
+            id: AddressFromBytes(reader.readBytes(32)),
             createTsMs: reader.read64(),
             orderId: reader.read64(),
             linkedPositionId: reader
-                .readVec(function (reader) {
-                return reader.read64();
-            })
+                .readVec((reader) => {
+                    return reader.read64();
+                })
                 .at(0),
-            user: (0, tools_1.AddressFromBytes)(reader.readBytes(32)),
+            user: AddressFromBytes(reader.readBytes(32)),
             collateralToken: { name: String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.read8()))) },
             collateralTokenDecimal: reader.read64(),
             symbol: {
@@ -78,40 +76,43 @@ function readVecOrder(bytes) {
             sizeDecimal: reader.read64(),
             triggerPrice: reader.read64(),
             oraclePriceWhenPlacing: reader.read64(),
-            u64Padding: reader.readVec(function (reader) { return reader.read64(); }),
+            u64Padding: reader.readVec((reader) => reader.read64()),
         };
+
         return order;
     });
 }
-function readVecShares(bytes) {
-    var reader = new bcs_1.BcsReader(bytes);
-    return reader.readVec(function (reader) {
+
+export function readVecShares(bytes: Uint8Array) {
+    let reader = new BcsReader(bytes);
+    return reader.readVec((reader) => {
         reader.read16();
-        var share = {
-            user: (0, tools_1.AddressFromBytes)(reader.readBytes(32)),
+        let share = {
+            user: AddressFromBytes(reader.readBytes(32)),
             userShareId: reader.read64(),
             stakeTsMs: reader.read64(),
             totalShares: reader.read64(),
             activeShares: reader.read64(),
-            deactivatingShares: reader.readVec(function (reader) {
-                var deactivatingShares = {
+            deactivatingShares: reader.readVec((reader) => {
+                let deactivatingShares = {
                     shares: reader.read64(),
                     unsubscribedTsMs: reader.read64(),
                     unlockedTsMs: reader.read64(),
-                    unsubscribedIncentivePriceIndex: reader.readVec(function (reader) { return [
+                    unsubscribedIncentivePriceIndex: reader.readVec((reader) => [
                         { name: String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.read8()))) },
                         reader.read64(),
-                    ]; }),
-                    u64Padding: reader.readVec(function (reader) { return reader.read64(); }),
+                    ]),
+                    u64Padding: reader.readVec((reader) => reader.read64()),
                 };
                 return deactivatingShares;
             }),
-            lastIncentivePriceIndex: reader.readVec(function (reader) { return [
+            lastIncentivePriceIndex: reader.readVec((reader) => [
                 { name: String.fromCharCode.apply(null, Array.from(reader.readBytes(reader.read8()))) },
                 reader.read64(),
-            ]; }),
-            u64Padding: reader.readVec(function (reader) { return reader.read64(); }),
+            ]),
+            u64Padding: reader.readVec((reader) => reader.read64()),
         };
+
         return share;
     });
 }

package/src/typus-perp/stake-pool/functions.ts

@@ -0,0 +1,421 @@
+import { PUBLISHED_AT } from "..";
+import { ObjectArg, obj, pure, vector } from "../../_framework/util";
+import { TransactionArgument, TransactionBlock } from "@mysten/sui.js/transactions";
+
+export function init(txb: TransactionBlock) {
+    return txb.moveCall({ target: `${PUBLISHED_AT}::stake_pool::init`, arguments: [] });
+}
+
+export interface UnsubscribeArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+    userShareId: bigint | TransactionArgument;
+    unsubscribedShares: bigint | TransactionArgument | TransactionArgument | null;
+    clock: ObjectArg;
+}
+
+export function unsubscribe(txb: TransactionBlock, typeArg: string, args: UnsubscribeArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::unsubscribe`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(txb, args.version),
+            obj(txb, args.registry),
+            pure(txb, args.index, `u64`),
+            pure(txb, args.userShareId, `u64`),
+            pure(txb, args.unsubscribedShares, `0x1::option::Option<u64>`),
+            obj(txb, args.clock),
+        ],
+    });
+}
+
+export interface ActivateIncentiveTokenArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+}
+
+export function activateIncentiveToken(txb: TransactionBlock, typeArg: string, args: ActivateIncentiveTokenArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::activate_incentive_token`,
+        typeArguments: [typeArg],
+        arguments: [obj(txb, args.version), obj(txb, args.registry), pure(txb, args.index, `u64`)],
+    });
+}
+
+export interface AddIncentiveTokenArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+    periodIncentiveAmount: bigint | TransactionArgument;
+    incentiveIntervalTsMs: bigint | TransactionArgument;
+    clock: ObjectArg;
+}
+
+export function addIncentiveToken(txb: TransactionBlock, typeArg: string, args: AddIncentiveTokenArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::add_incentive_token`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(txb, args.version),
+            obj(txb, args.registry),
+            pure(txb, args.index, `u64`),
+            pure(txb, args.periodIncentiveAmount, `u64`),
+            pure(txb, args.incentiveIntervalTsMs, `u64`),
+            obj(txb, args.clock),
+        ],
+    });
+}
+
+export interface AllocateIncentiveArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+    clock: ObjectArg;
+}
+
+export function allocateIncentive(txb: TransactionBlock, args: AllocateIncentiveArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::allocate_incentive`,
+        arguments: [obj(txb, args.version), obj(txb, args.registry), pure(txb, args.index, `u64`), obj(txb, args.clock)],
+    });
+}
+
+export interface CalculateIncentiveArgs {
+    stakePool: ObjectArg;
+    incentiveToken: ObjectArg;
+    lpUserShare: ObjectArg;
+}
+
+export function calculateIncentive(txb: TransactionBlock, args: CalculateIncentiveArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::calculate_incentive`,
+        arguments: [obj(txb, args.stakePool), obj(txb, args.incentiveToken), obj(txb, args.lpUserShare)],
+    });
+}
+
+export interface CreateUserLastIncentiveTsMsArgs {
+    stakePool: ObjectArg;
+    currentTsMs: bigint | TransactionArgument;
+}
+
+export function createUserLastIncentiveTsMs(txb: TransactionBlock, args: CreateUserLastIncentiveTsMsArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::create_user_last_incentive_ts_ms`,
+        arguments: [obj(txb, args.stakePool), pure(txb, args.currentTsMs, `u64`)],
+    });
+}
+
+export interface DeactivateIncentiveTokenArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+}
+
+export function deactivateIncentiveToken(txb: TransactionBlock, typeArg: string, args: DeactivateIncentiveTokenArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::deactivate_incentive_token`,
+        typeArguments: [typeArg],
+        arguments: [obj(txb, args.version), obj(txb, args.registry), pure(txb, args.index, `u64`)],
+    });
+}
+
+export interface DepositIncentiveArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+    coin: ObjectArg;
+}
+
+export function depositIncentive(txb: TransactionBlock, typeArg: string, args: DepositIncentiveArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::deposit_incentive`,
+        typeArguments: [typeArg],
+        arguments: [obj(txb, args.version), obj(txb, args.registry), pure(txb, args.index, `u64`), obj(txb, args.coin)],
+    });
+}
+
+export interface GetIncentiveArgs {
+    stakePool: ObjectArg;
+    tokenType: ObjectArg;
+}
+
+export function getIncentive(txb: TransactionBlock, args: GetIncentiveArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::get_incentive`,
+        arguments: [obj(txb, args.stakePool), obj(txb, args.tokenType)],
+    });
+}
+
+export function getIncentiveTokens(txb: TransactionBlock, stakePool: ObjectArg) {
+    return txb.moveCall({ target: `${PUBLISHED_AT}::stake_pool::get_incentive_tokens`, arguments: [obj(txb, stakePool)] });
+}
+
+export function getLastIncentivePriceIndex(txb: TransactionBlock, stakePool: ObjectArg) {
+    return txb.moveCall({ target: `${PUBLISHED_AT}::stake_pool::get_last_incentive_price_index`, arguments: [obj(txb, stakePool)] });
+}
+
+export interface GetMutIncentiveArgs {
+    stakePool: ObjectArg;
+    tokenType: ObjectArg;
+}
+
+export function getMutIncentive(txb: TransactionBlock, args: GetMutIncentiveArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::get_mut_incentive`,
+        arguments: [obj(txb, args.stakePool), obj(txb, args.tokenType)],
+    });
+}
+
+export interface GetMutStakePoolArgs {
+    id: ObjectArg;
+    index: bigint | TransactionArgument;
+}
+
+export function getMutStakePool(txb: TransactionBlock, args: GetMutStakePoolArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::get_mut_stake_pool`,
+        arguments: [obj(txb, args.id), pure(txb, args.index, `u64`)],
+    });
+}
+
+export interface GetStakePoolArgs {
+    id: ObjectArg;
+    index: bigint | TransactionArgument;
+}
+
+export function getStakePool(txb: TransactionBlock, args: GetStakePoolArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::get_stake_pool`,
+        arguments: [obj(txb, args.id), pure(txb, args.index, `u64`)],
+    });
+}
+
+export interface GetUserShareIdsArgs {
+    stakePool: ObjectArg;
+    user: string | TransactionArgument;
+}
+
+export function getUserShareIds(txb: TransactionBlock, args: GetUserShareIdsArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::get_user_share_ids`,
+        arguments: [obj(txb, args.stakePool), pure(txb, args.user, `address`)],
+    });
+}
+
+export interface GetUserSharesArgs {
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+    user: string | TransactionArgument;
+}
+
+export function getUserShares(txb: TransactionBlock, args: GetUserSharesArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::get_user_shares`,
+        arguments: [obj(txb, args.registry), pure(txb, args.index, `u64`), pure(txb, args.user, `address`)],
+    });
+}
+
+export interface HarvestPerUserShareArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+    userShareId: bigint | TransactionArgument;
+    clock: ObjectArg;
+}
+
+export function harvestPerUserShare(txb: TransactionBlock, typeArg: string, args: HarvestPerUserShareArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::harvest_per_user_share`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(txb, args.version),
+            obj(txb, args.registry),
+            pure(txb, args.index, `u64`),
+            pure(txb, args.userShareId, `u64`),
+            obj(txb, args.clock),
+        ],
+    });
+}
+
+export interface NewStakePoolArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    unlockCountdownTsMs: bigint | TransactionArgument;
+}
+
+export function newStakePool(txb: TransactionBlock, typeArg: string, args: NewStakePoolArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::new_stake_pool`,
+        typeArguments: [typeArg],
+        arguments: [obj(txb, args.version), obj(txb, args.registry), pure(txb, args.unlockCountdownTsMs, `u64`)],
+    });
+}
+
+export interface RemoveIncentiveArgs {
+    stakePool: ObjectArg;
+    tokenType: ObjectArg;
+}
+
+export function removeIncentive(txb: TransactionBlock, args: RemoveIncentiveArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::remove_incentive`,
+        arguments: [obj(txb, args.stakePool), obj(txb, args.tokenType)],
+    });
+}
+
+export interface RemoveIncentiveTokenArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+}
+
+export function removeIncentiveToken(txb: TransactionBlock, typeArg: string, args: RemoveIncentiveTokenArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::remove_incentive_token`,
+        typeArguments: [typeArg],
+        arguments: [obj(txb, args.version), obj(txb, args.registry), pure(txb, args.index, `u64`)],
+    });
+}
+
+export interface RemoveUserShareByIdArgs {
+    id: ObjectArg;
+    user: string | TransactionArgument;
+    userShareId: bigint | TransactionArgument;
+}
+
+export function removeUserShareById(txb: TransactionBlock, args: RemoveUserShareByIdArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::remove_user_share_by_id`,
+        arguments: [obj(txb, args.id), pure(txb, args.user, `address`), pure(txb, args.userShareId, `u64`)],
+    });
+}
+
+export interface StakeArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+    lpToken: ObjectArg;
+    userShareId: bigint | TransactionArgument | TransactionArgument | null;
+    clock: ObjectArg;
+}
+
+export function stake(txb: TransactionBlock, typeArg: string, args: StakeArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::stake`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(txb, args.version),
+            obj(txb, args.registry),
+            pure(txb, args.index, `u64`),
+            obj(txb, args.lpToken),
+            pure(txb, args.userShareId, `0x1::option::Option<u64>`),
+            obj(txb, args.clock),
+        ],
+    });
+}
+
+export interface StoreUserSharesArgs {
+    id: ObjectArg;
+    user: string | TransactionArgument;
+    userShares: Array<ObjectArg> | TransactionArgument;
+}
+
+export function storeUserShares(txb: TransactionBlock, args: StoreUserSharesArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::store_user_shares`,
+        arguments: [
+            obj(txb, args.id),
+            pure(txb, args.user, `address`),
+            vector(txb, `0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::stake_pool::LpUserShare`, args.userShares),
+        ],
+    });
+}
+
+export interface UnstakeArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+    userShareId: bigint | TransactionArgument;
+    unstakedShares: bigint | TransactionArgument | TransactionArgument | null;
+    clock: ObjectArg;
+}
+
+export function unstake(txb: TransactionBlock, typeArg: string, args: UnstakeArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::unstake`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(txb, args.version),
+            obj(txb, args.registry),
+            pure(txb, args.index, `u64`),
+            pure(txb, args.userShareId, `u64`),
+            pure(txb, args.unstakedShares, `0x1::option::Option<u64>`),
+            obj(txb, args.clock),
+        ],
+    });
+}
+
+export interface UpdateIncentiveConfigArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+    periodIncentiveAmount: bigint | TransactionArgument | TransactionArgument | null;
+    incentiveIntervalTsMs: bigint | TransactionArgument | TransactionArgument | null;
+    u64Padding: Array<bigint | TransactionArgument> | TransactionArgument | TransactionArgument | null;
+}
+
+export function updateIncentiveConfig(txb: TransactionBlock, typeArg: string, args: UpdateIncentiveConfigArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::update_incentive_config`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(txb, args.version),
+            obj(txb, args.registry),
+            pure(txb, args.index, `u64`),
+            pure(txb, args.periodIncentiveAmount, `0x1::option::Option<u64>`),
+            pure(txb, args.incentiveIntervalTsMs, `0x1::option::Option<u64>`),
+            pure(txb, args.u64Padding, `0x1::option::Option<vector<u64>>`),
+        ],
+    });
+}
+
+export interface UpdateUnlockCountdownTsMsArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+    unlockCountdownTsMs: bigint | TransactionArgument;
+}
+
+export function updateUnlockCountdownTsMs(txb: TransactionBlock, args: UpdateUnlockCountdownTsMsArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::update_unlock_countdown_ts_ms`,
+        arguments: [
+            obj(txb, args.version),
+            obj(txb, args.registry),
+            pure(txb, args.index, `u64`),
+            pure(txb, args.unlockCountdownTsMs, `u64`),
+        ],
+    });
+}
+
+export interface WithdrawIncentiveArgs {
+    version: ObjectArg;
+    registry: ObjectArg;
+    index: bigint | TransactionArgument;
+    amount: bigint | TransactionArgument | TransactionArgument | null;
+}
+
+export function withdrawIncentive(txb: TransactionBlock, typeArg: string, args: WithdrawIncentiveArgs) {
+    return txb.moveCall({
+        target: `${PUBLISHED_AT}::stake_pool::withdraw_incentive`,
+        typeArguments: [typeArg],
+        arguments: [
+            obj(txb, args.version),
+            obj(txb, args.registry),
+            pure(txb, args.index, `u64`),
+            pure(txb, args.amount, `0x1::option::Option<u64>`),
+        ],
+    });
+}