@typus/typus-sdk 1.4.20 → 1.4.22

package/dist/src/typus-perp/user/tlp.js

@@ -74,7 +74,7 @@ var functions_2 = require("../stake-pool/functions");
 var utils_1 = require("../../utils");
 var constants_2 = require("../../constants");
 var __1 = require("..");
-function mintStakeLp(config, input) {
+function mintStakeLp(config, tx, pythClient, input) {
     return __awaiter(this, void 0, void 0, function () {
         var tokens, cToken, tokens_1, tokens_1_1, token, coin, destination, lpCoin;
         var e_1, _a, _b, _c;
@@ -82,14 +82,14 @@ function mintStakeLp(config, input) {
             switch (_d.label) {
                 case 0:
                     tokens = input.lpPool.tokenPools.map(function (p) { return (0, constants_2.typeArgToAsset)("0x" + p.tokenType.name); });
-                    return [4 /*yield*/, (0, utils_1.updatePyth)(input.pythClient, input.tx, tokens)];
+                    return [4 /*yield*/, (0, utils_1.updatePyth)(pythClient, tx, tokens)];
                 case 1:
                     _d.sent();
                     cToken = constants_2.tokenType[__1.NETWORK][input.cTOKEN];
                     try {
                         for (tokens_1 = __values(tokens), tokens_1_1 = tokens_1.next(); !tokens_1_1.done; tokens_1_1 = tokens_1.next()) {
                             token = tokens_1_1.value;
-                            (0, functions_1.updateLiquidityValue)(input.tx, constants_2.tokenType[__1.NETWORK][token], {
+                            (0, functions_1.updateLiquidityValue)(tx, constants_2.tokenType[__1.NETWORK][token], {
                                 version: config.version.perp,
                                 registry: config.registry.perp.lpPool,
                                 index: BigInt(0),
@@ -107,16 +107,16 @@ function mintStakeLp(config, input) {
                         finally { if (e_1) throw e_1.error; }
                     }
                     if (input.cTOKEN == "SUI") {
-                        _b = __read(input.tx.splitCoins(input.tx.gas, [input.amount]), 1), coin = _b[0];
+                        _b = __read(tx.splitCoins(tx.gas, [input.amount]), 1), coin = _b[0];
                     }
                     else {
                         destination = input.coins.pop();
                         if (input.coins.length > 0) {
-                            input.tx.mergeCoins(destination, input.coins);
+                            tx.mergeCoins(destination, input.coins);
                         }
-                        _c = __read(input.tx.splitCoins(destination, [input.amount]), 1), coin = _c[0];
+                        _c = __read(tx.splitCoins(destination, [input.amount]), 1), coin = _c[0];
                     }
-                    lpCoin = (0, functions_1.mintLp)(input.tx, [cToken, config.token.tlp], {
+                    lpCoin = (0, functions_1.mintLp)(tx, [cToken, config.token.tlp], {
                         version: config.version.perp,
                         registry: config.registry.perp.lpPool,
                         treasuryCaps: config.object.tlpTreasuryCap,
@@ -126,7 +126,7 @@ function mintStakeLp(config, input) {
                         coin: coin,
                         clock: constants_1.CLOCK,
                     });
-                    (0, functions_2.stake)(input.tx, config.token.tlp, {
+                    (0, functions_2.stake)(tx, config.token.tlp, {
                         version: config.version.perp,
                         registry: config.registry.perp.stakePool,
                         index: BigInt(0),
@@ -134,12 +134,12 @@ function mintStakeLp(config, input) {
                         clock: constants_1.CLOCK,
                         userShareId: input.userShareId ? BigInt(input.userShareId) : null,
                     });
-                    return [2 /*return*/, input.tx];
+                    return [2 /*return*/, tx];
             }
         });
     });
 }
-function unstakeBurn(config, input) {
+function unstakeBurn(config, tx, pythClient, input) {
     return __awaiter(this, void 0, void 0, function () {
         var tokens, cToken, oracle, tokens_2, tokens_2_1, token, lpCoin, coin;
         var e_2, _a;
@@ -147,7 +147,7 @@ function unstakeBurn(config, input) {
             switch (_b.label) {
                 case 0:
                     tokens = input.lpPool.tokenPools.map(function (p) { return (0, constants_2.typeArgToAsset)("0x" + p.tokenType.name); });
-                    return [4 /*yield*/, (0, utils_1.updatePyth)(input.pythClient, input.tx, tokens)];
+                    return [4 /*yield*/, (0, utils_1.updatePyth)(pythClient, tx, tokens)];
                 case 1:
                     _b.sent();
                     cToken = constants_2.tokenType[__1.NETWORK][input.cTOKEN];
@@ -155,7 +155,7 @@ function unstakeBurn(config, input) {
                     try {
                         for (tokens_2 = __values(tokens), tokens_2_1 = tokens_2.next(); !tokens_2_1.done; tokens_2_1 = tokens_2.next()) {
                             token = tokens_2_1.value;
-                            (0, functions_1.updateLiquidityValue)(input.tx, constants_2.tokenType[__1.NETWORK][token], {
+                            (0, functions_1.updateLiquidityValue)(tx, constants_2.tokenType[__1.NETWORK][token], {
                                 version: config.version.perp,
                                 registry: config.registry.perp.lpPool,
                                 index: BigInt(0),
@@ -172,7 +172,7 @@ function unstakeBurn(config, input) {
                         }
                         finally { if (e_2) throw e_2.error; }
                     }
-                    lpCoin = (0, functions_2.unstake)(input.tx, config.token.tlp, {
+                    lpCoin = (0, functions_2.unstake)(tx, config.token.tlp, {
                         version: config.version.perp,
                         registry: config.registry.perp.stakePool,
                         index: BigInt(0),
@@ -180,7 +180,7 @@ function unstakeBurn(config, input) {
                         clock: constants_1.CLOCK,
                         unstakedShares: input.share ? BigInt(input.share) : null,
                     });
-                    coin = (0, functions_1.burnLp)(input.tx, [cToken, config.token.tlp], {
+                    coin = (0, functions_1.burnLp)(tx, [cToken, config.token.tlp], {
                         version: config.version.perp,
                         registry: config.registry.perp.lpPool,
                         treasuryCaps: config.object.tlpTreasuryCap,
@@ -190,34 +190,34 @@ function unstakeBurn(config, input) {
                         coin: lpCoin,
                         clock: constants_1.CLOCK,
                     });
-                    input.tx.transferObjects([coin], input.user);
-                    return [2 /*return*/, input.tx];
+                    tx.transferObjects([coin], input.user);
+                    return [2 /*return*/, tx];
             }
         });
     });
 }
-function swap(config, input) {
+function swap(config, tx, pythClient, input) {
     return __awaiter(this, void 0, void 0, function () {
         var fromToken, toToken, coin, destination, token;
         var _a, _b;
         return __generator(this, function (_c) {
             switch (_c.label) {
-                case 0: return [4 /*yield*/, (0, utils_1.updatePyth)(input.pythClient, input.tx, [input.FROM_TOKEN, input.TO_TOKEN])];
+                case 0: return [4 /*yield*/, (0, utils_1.updatePyth)(pythClient, tx, [input.FROM_TOKEN, input.TO_TOKEN])];
                 case 1:
                     _c.sent();
                     fromToken = constants_2.tokenType[__1.NETWORK][input.FROM_TOKEN];
                     toToken = constants_2.tokenType[__1.NETWORK][input.TO_TOKEN];
                     if (input.FROM_TOKEN == "SUI") {
-                        _a = __read(input.tx.splitCoins(input.tx.gas, [input.amount]), 1), coin = _a[0];
+                        _a = __read(tx.splitCoins(tx.gas, [input.amount]), 1), coin = _a[0];
                     }
                     else {
                         destination = input.coins.pop();
                         if (input.coins.length > 0) {
-                            input.tx.mergeCoins(destination, input.coins);
+                            tx.mergeCoins(destination, input.coins);
                         }
-                        _b = __read(input.tx.splitCoins(destination, [input.amount]), 1), coin = _b[0];
+                        _b = __read(tx.splitCoins(destination, [input.amount]), 1), coin = _b[0];
                     }
-                    token = (0, functions_1.swap)(input.tx, [fromToken, toToken], {
+                    token = (0, functions_1.swap)(tx, [fromToken, toToken], {
                         version: config.version.perp,
                         registry: config.registry.perp.lpPool,
                         pythState: utils_1.pythStateId[__1.NETWORK],
@@ -228,16 +228,16 @@ function swap(config, input) {
                         fromCoin: coin,
                         minToAmount: BigInt(0),
                     });
-                    input.tx.transferObjects([token], input.user);
-                    return [2 /*return*/, input.tx];
+                    tx.transferObjects([token], input.user);
+                    return [2 /*return*/, tx];
             }
         });
     });
 }
-function unsubscribe(config, input) {
+function unsubscribe(config, tx, input) {
     return __awaiter(this, void 0, void 0, function () {
         return __generator(this, function (_a) {
-            (0, functions_2.unsubscribe)(input.tx, config.token.tlp, {
+            (0, functions_2.unsubscribe)(tx, config.token.tlp, {
                 version: config.version.perp,
                 registry: config.registry.perp.stakePool,
                 index: BigInt(0),
@@ -245,21 +245,21 @@ function unsubscribe(config, input) {
                 clock: constants_1.CLOCK,
                 unsubscribedShares: input.share ? BigInt(input.share) : null,
             });
-            return [2 /*return*/, input.tx];
+            return [2 /*return*/, tx];
         });
     });
 }
-function harvest(config, input) {
+function harvest(config, tx, input) {
     return __awaiter(this, void 0, void 0, function () {
         return __generator(this, function (_a) {
-            (0, functions_2.harvestPerUserShare)(input.tx, "0x2::sui::SUI", {
+            (0, functions_2.harvestPerUserShare)(tx, "0x2::sui::SUI", {
                 version: config.version.perp,
                 registry: config.registry.perp.stakePool,
                 index: BigInt(0),
                 userShareId: BigInt(input.userShareId),
                 clock: constants_1.CLOCK,
             });
-            return [2 /*return*/, input.tx];
+            return [2 /*return*/, tx];
         });
     });
 }

package/dist/src/typus-safu/user-entry.d.ts

@@ -16,8 +16,7 @@ import { TypusConfig } from "src/utils";
         ctx: &mut TxContext,
     ) {
  */
-export declare function getRaiseFundTx(config: TypusConfig, input: {
-    tx: TransactionBlock;
+export declare function getRaiseFundTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     index: string;
     raiseCoins: string[];
@@ -42,8 +41,7 @@ export declare function getRaiseFundTx(config: TypusConfig, input: {
         ctx: &mut TxContext,
     ): Balance<D_TOKEN> {
  */
-export declare function getReduceFundTx(config: TypusConfig, input: {
-    tx: TransactionBlock;
+export declare function getReduceFundTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     index: string;
     reduceFromWarmup: string;
@@ -59,8 +57,7 @@ export declare function getReduceFundTx(config: TypusConfig, input: {
         ctx: &TxContext,
     ): Balance<R_TOKEN> {
  */
-export declare function getClaimRewardTx(config: TypusConfig, input: {
-    tx: TransactionBlock;
+export declare function getClaimRewardTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     index: string;
     user: string;
@@ -77,8 +74,7 @@ export declare function getClaimRewardTx(config: TypusConfig, input: {
         ctx: &mut TxContext,
     ) {
  */
-export declare function getSnapshotTx(config: TypusConfig, input: {
-    tx: TransactionBlock;
+export declare function getSnapshotTx(config: TypusConfig, tx: TransactionBlock, input: {
     typeArguments: string[];
     index: string;
 }): TransactionBlock;

package/dist/src/typus-safu/user-entry.js

@@ -21,52 +21,52 @@ var constants_1 = require("../constants");
         ctx: &mut TxContext,
     ) {
  */
-function getRaiseFundTx(config, input) {
+function getRaiseFundTx(config, tx, input) {
     var raiseBalance = input.typeArguments[0] == "0x2::sui::SUI" ||
         input.typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
-        ? input.tx.moveCall({
+        ? tx.moveCall({
             target: "".concat(config.package.framework, "::utils::delegate_extract_balance"),
             typeArguments: [input.typeArguments[0]],
             arguments: [
-                input.tx.pure(input.user),
-                input.tx.makeMoveVec({
+                tx.pure(input.user),
+                tx.makeMoveVec({
                     type: "0x2::coin::Coin<".concat(input.typeArguments[0], ">"),
-                    objects: [input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.raiseAmount)])],
+                    objects: [tx.splitCoins(tx.gas, [tx.pure(input.raiseAmount)])],
                 }),
-                input.tx.pure(input.raiseAmount),
+                tx.pure(input.raiseAmount),
             ],
         })
-        : input.tx.moveCall({
+        : tx.moveCall({
             target: "".concat(config.package.framework, "::utils::delegate_extract_balance"),
             typeArguments: [input.typeArguments[0]],
             arguments: [
-                input.tx.pure(input.user),
-                input.tx.makeMoveVec({
+                tx.pure(input.user),
+                tx.makeMoveVec({
                     type: "0x2::coin::Coin<".concat(input.typeArguments[0], ">"),
-                    objects: input.raiseCoins.map(function (coin) { return input.tx.object(coin); }),
+                    objects: input.raiseCoins.map(function (coin) { return tx.object(coin); }),
                 }),
-                input.tx.pure(input.raiseAmount),
+                tx.pure(input.raiseAmount),
             ],
         });
-    var result = input.tx.moveCall({
+    var result = tx.moveCall({
         target: "".concat(config.package.safu, "::safu::raise_fund"),
         typeArguments: input.typeArguments,
         arguments: [
-            input.tx.object(config.version.typus),
-            input.tx.object(config.registry.typus.leaderboard),
-            input.tx.object(config.registry.typus.user),
-            input.tx.object(config.version.safu),
-            input.tx.object(config.registry.safu.safu),
-            input.tx.pure(input.index),
-            input.tx.object(raiseBalance),
-            input.tx.pure(input.raiseFromDeactivating),
-            input.tx.pure(input.raiseFromInactive),
-            input.tx.pure(input.raiseFromReward),
-            input.tx.object(constants_1.CLOCK),
+            tx.object(config.version.typus),
+            tx.object(config.registry.typus.leaderboard),
+            tx.object(config.registry.typus.user),
+            tx.object(config.version.safu),
+            tx.object(config.registry.safu.safu),
+            tx.pure(input.index),
+            tx.object(raiseBalance),
+            tx.pure(input.raiseFromDeactivating),
+            tx.pure(input.raiseFromInactive),
+            tx.pure(input.raiseFromReward),
+            tx.object(constants_1.CLOCK),
         ],
     });
-    // input.tx.transferObjects([input.tx.object(result[0])], input.user);
-    return input.tx;
+    // tx.transferObjects([tx.object(result[0])], input.user);
+    return tx;
 }
 /**
     public fun reduce_fund<D_TOKEN>(
@@ -83,29 +83,29 @@ function getRaiseFundTx(config, input) {
         ctx: &mut TxContext,
     ): Balance<D_TOKEN> {
  */
-function getReduceFundTx(config, input) {
-    var result = input.tx.moveCall({
+function getReduceFundTx(config, tx, input) {
+    var result = tx.moveCall({
         target: "".concat(config.package.safu, "::safu::reduce_fund"),
         typeArguments: input.typeArguments,
         arguments: [
-            input.tx.object(config.version.typus),
-            input.tx.object(config.registry.typus.leaderboard),
-            input.tx.object(config.registry.typus.user),
-            input.tx.object(config.version.safu),
-            input.tx.object(config.registry.safu.safu),
-            input.tx.pure(input.index),
-            input.tx.pure(input.reduceFromWarmup),
-            input.tx.pure(input.reduceFromActive),
-            input.tx.pure(input.reduceFromInactive),
-            input.tx.object(constants_1.CLOCK),
+            tx.object(config.version.typus),
+            tx.object(config.registry.typus.leaderboard),
+            tx.object(config.registry.typus.user),
+            tx.object(config.version.safu),
+            tx.object(config.registry.safu.safu),
+            tx.pure(input.index),
+            tx.pure(input.reduceFromWarmup),
+            tx.pure(input.reduceFromActive),
+            tx.pure(input.reduceFromInactive),
+            tx.object(constants_1.CLOCK),
         ],
     });
-    input.tx.moveCall({
+    tx.moveCall({
         target: "".concat(config.package.framework, "::utils::transfer_balance"),
         typeArguments: [input.typeArguments[0]],
-        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+        arguments: [tx.object(result[0]), tx.pure(input.user)],
     });
-    return input.tx;
+    return tx;
 }
 /**
     public fun claim_reward<R_TOKEN>(
@@ -115,18 +115,18 @@ function getReduceFundTx(config, input) {
         ctx: &TxContext,
     ): Balance<R_TOKEN> {
  */
-function getClaimRewardTx(config, input) {
-    var result = input.tx.moveCall({
+function getClaimRewardTx(config, tx, input) {
+    var result = tx.moveCall({
         target: "".concat(config.package.safu, "::safu::claim_reward"),
         typeArguments: input.typeArguments,
-        arguments: [input.tx.object(config.version.safu), input.tx.object(config.registry.safu.safu), input.tx.pure(input.index)],
+        arguments: [tx.object(config.version.safu), tx.object(config.registry.safu.safu), tx.pure(input.index)],
     });
-    input.tx.moveCall({
+    tx.moveCall({
         target: "".concat(config.package.framework, "::utils::transfer_balance"),
         typeArguments: [input.typeArguments[0]],
-        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+        arguments: [tx.object(result[0]), tx.pure(input.user)],
     });
-    return input.tx;
+    return tx;
 }
 /**
     public fun snapshot(
@@ -140,19 +140,19 @@ function getClaimRewardTx(config, input) {
         ctx: &mut TxContext,
     ) {
  */
-function getSnapshotTx(config, input) {
-    var result = input.tx.moveCall({
+function getSnapshotTx(config, tx, input) {
+    var result = tx.moveCall({
         target: "".concat(config.package.safu, "::safu::snapshot"),
         typeArguments: input.typeArguments,
         arguments: [
-            input.tx.object(config.version.typus),
-            input.tx.object(config.registry.typus.leaderboard),
-            input.tx.object(config.registry.typus.user),
-            input.tx.object(config.version.safu),
-            input.tx.object(config.registry.safu.safu),
-            input.tx.pure(input.index),
-            input.tx.object(constants_1.CLOCK),
+            tx.object(config.version.typus),
+            tx.object(config.registry.typus.leaderboard),
+            tx.object(config.registry.typus.user),
+            tx.object(config.version.safu),
+            tx.object(config.registry.safu.safu),
+            tx.pure(input.index),
+            tx.object(constants_1.CLOCK),
         ],
     });
-    return input.tx;
+    return tx;
 }

package/dist/src/typus-safu/view-function.d.ts

@@ -1,4 +1,3 @@
-import { SuiClient } from "@mysten/sui.js/client";
 import { TypusConfig } from "../utils";
 export interface Vault {
     id: string;
@@ -41,7 +40,6 @@ export interface ShareSupply {
     reward_share: string[];
 }
 export declare function getVaultData(config: TypusConfig, input: {
-    provider: SuiClient;
     indexes: string[];
 }): Promise<{
     [key: string]: Vault;
@@ -53,7 +51,6 @@ export interface Share {
     bcsPadding: string[];
 }
 export declare function getShareData(config: TypusConfig, input: {
-    provider: SuiClient;
     user: string;
     indexes: string[];
 }): Promise<{

package/dist/src/typus-safu/view-function.js

@@ -39,22 +39,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVaultData = getVaultData;
 exports.getShareData = getShareData;
 var transactions_1 = require("@mysten/sui.js/transactions");
+var client_1 = require("@mysten/sui.js/client");
 var bcs_1 = require("@mysten/bcs");
 var utils_1 = require("../utils");
-var SENDER = "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+var constants_1 = require("src/constants");
 function getVaultData(config, input) {
     return __awaiter(this, void 0, void 0, function () {
-        var transactionBlock, results, bytes, reader, result;
+        var provider, transactionBlock, results, bytes, reader, result;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
                     transactionBlock = new transactions_1.TransactionBlock();
                     transactionBlock.moveCall({
                         target: "".concat(config.package.safu, "::view_function::get_vault_data_bcs"),
                         typeArguments: [],
                         arguments: [transactionBlock.pure(config.registry.safu.safu), transactionBlock.pure(input.indexes)],
                     });
-                    return [4 /*yield*/, input.provider.devInspectTransactionBlock({ sender: SENDER, transactionBlock: transactionBlock })];
+                    return [4 /*yield*/, provider.devInspectTransactionBlock({ sender: constants_1.SENDER, transactionBlock: transactionBlock })];
                 case 1:
                     results = (_a.sent()).results;
                     bytes = results[results.length - 1].returnValues[0][0];
@@ -110,7 +112,7 @@ function getVaultData(config, input) {
                             inactive_share: shareSupplyArray[2],
                             warmup_share: shareSupplyArray[3],
                             snapshot_share: shareSupplyArray[4],
-                            reward_share: shareSupplyArray.slice(5)
+                            reward_share: shareSupplyArray.slice(5),
                         };
                         var u64Padding = reader.readVec(function (reader) {
                             return reader.read64();
@@ -136,10 +138,11 @@ function getVaultData(config, input) {
 }
 function getShareData(config, input) {
     return __awaiter(this, void 0, void 0, function () {
-        var transactionBlock, results, bytes, reader, result;
+        var provider, transactionBlock, results, bytes, reader, result;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
+                    provider = new client_1.SuiClient({ url: config.rpcEndpoint });
                     transactionBlock = new transactions_1.TransactionBlock();
                     transactionBlock.moveCall({
                         target: "".concat(config.package.safu, "::view_function::get_share_data_bcs"),
@@ -150,7 +153,7 @@ function getShareData(config, input) {
                             transactionBlock.pure(input.indexes),
                         ],
                     });
-                    return [4 /*yield*/, input.provider.devInspectTransactionBlock({ sender: SENDER, transactionBlock: transactionBlock })];
+                    return [4 /*yield*/, provider.devInspectTransactionBlock({ sender: constants_1.SENDER, transactionBlock: transactionBlock })];
                 case 1:
                     results = (_a.sent()).results;
                     bytes = results[results.length - 1].returnValues[0][0];
@@ -169,7 +172,7 @@ function getShareData(config, input) {
                                 inactive_share: shareSupplyArray[2],
                                 warmup_share: shareSupplyArray[3],
                                 snapshot_share: shareSupplyArray[4],
-                                reward_share: shareSupplyArray.slice(5)
+                                reward_share: shareSupplyArray.slice(5),
                             };
                             return {
                                 user: user,

package/package.json

@@ -2,7 +2,7 @@
     "name": "@typus/typus-sdk",
     "author": "Typus",
     "description": "typus sdk",
-    "version": "1.4.20",
+    "version": "1.4.22",
     "dependencies": {
         "@mysten/bcs": "^0.11.1",
         "@mysten/kiosk": "0.8.10",