@typus/typus-sdk 1.4.18 → 1.4.20

package/dist/src/typus/tails-staking/user-entry.js

@@ -61,7 +61,6 @@ exports.getLevelUpTx = getLevelUpTx;
 exports.getExpUpTx = getExpUpTx;
 exports.getExpUpWithoutStakingTx = getExpUpWithoutStakingTx;
 exports.getCreateKioskAndLockNftTx = getCreateKioskAndLockNftTx;
-var transactions_1 = require("@mysten/sui.js/transactions");
 var constants_1 = require("../../constants");
 var kiosk_1 = require("@mysten/kiosk");
 /**
@@ -75,48 +74,48 @@ var kiosk_1 = require("@mysten/kiosk");
         ctx: &mut TxContext,
     ) {
 */
-function getStakeTailsTx(input) {
+function getStakeTailsTx(config, tx, input) {
     return __awaiter(this, void 0, void 0, function () {
         var _a, coin, _b, personalKioskCap, borrow;
         return __generator(this, function (_c) {
-            _a = __read(input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.fee)]), 1), coin = _a[0];
+            _a = __read(tx.splitCoins(tx.gas, [tx.pure(input.fee)]), 1), coin = _a[0];
             if (input.personalKioskPackageId) {
-                _b = __read(input.tx.moveCall({
+                _b = __read(tx.moveCall({
                     target: "".concat(input.personalKioskPackageId, "::personal_kiosk::borrow_val"),
-                    arguments: [input.tx.object(input.kioskCap)],
+                    arguments: [tx.object(input.kioskCap)],
                 }), 2), personalKioskCap = _b[0], borrow = _b[1];
-                input.tx.moveCall({
-                    target: "".concat(input.typusPackageId, "::tails_staking::stake_tails"),
+                tx.moveCall({
+                    target: "".concat(config.package.typus, "::tails_staking::stake_tails"),
                     typeArguments: [],
                     arguments: [
-                        input.tx.object(input.typusEcosystemVersion),
-                        input.tx.object(input.typusTailsStakingRegistry),
-                        input.tx.object(input.kiosk),
+                        tx.object(config.version.typus),
+                        tx.object(config.registry.typus.tailsStaking),
+                        tx.object(input.kiosk),
                         personalKioskCap,
-                        input.tx.pure(input.tails),
+                        tx.pure(input.tails),
                         coin,
                     ],
                 });
-                input.tx.moveCall({
+                tx.moveCall({
                     target: "".concat(input.personalKioskPackageId, "::personal_kiosk::return_val"),
-                    arguments: [input.tx.object(input.kioskCap), personalKioskCap, borrow],
+                    arguments: [tx.object(input.kioskCap), personalKioskCap, borrow],
                 });
             }
             else {
-                input.tx.moveCall({
-                    target: "".concat(input.typusPackageId, "::tails_staking::stake_tails"),
+                tx.moveCall({
+                    target: "".concat(config.package.typus, "::tails_staking::stake_tails"),
                     typeArguments: [],
                     arguments: [
-                        input.tx.object(input.typusEcosystemVersion),
-                        input.tx.object(input.typusTailsStakingRegistry),
-                        input.tx.object(input.kiosk),
-                        input.tx.object(input.kioskCap),
-                        input.tx.pure(input.tails),
+                        tx.object(config.version.typus),
+                        tx.object(config.registry.typus.tailsStaking),
+                        tx.object(input.kiosk),
+                        tx.object(input.kioskCap),
+                        tx.pure(input.tails),
                         coin,
                     ],
                 });
             }
-            return [2 /*return*/, input.tx];
+            return [2 /*return*/, tx];
         });
     });
 }
@@ -130,45 +129,45 @@ function getStakeTailsTx(input) {
         ctx: &TxContext,
     ) {
 */
-function getUnstakeTailsTx(input) {
+function getUnstakeTailsTx(config, tx, input) {
     return __awaiter(this, void 0, void 0, function () {
         var _a, personalKioskCap, borrow;
         return __generator(this, function (_b) {
             if (input.personalKioskPackageId) {
-                _a = __read(input.tx.moveCall({
+                _a = __read(tx.moveCall({
                     target: "".concat(input.personalKioskPackageId, "::personal_kiosk::borrow_val"),
-                    arguments: [input.tx.object(input.kioskCap)],
+                    arguments: [tx.object(input.kioskCap)],
                 }), 2), personalKioskCap = _a[0], borrow = _a[1];
-                input.tx.moveCall({
-                    target: "".concat(input.typusPackageId, "::tails_staking::unstake_tails"),
+                tx.moveCall({
+                    target: "".concat(config.package.typus, "::tails_staking::unstake_tails"),
                     typeArguments: [],
                     arguments: [
-                        input.tx.object(input.typusEcosystemVersion),
-                        input.tx.object(input.typusTailsStakingRegistry),
-                        input.tx.object(input.kiosk),
+                        tx.object(config.version.typus),
+                        tx.object(config.registry.typus.tailsStaking),
+                        tx.object(input.kiosk),
                         personalKioskCap,
-                        input.tx.pure(input.tails),
+                        tx.pure(input.tails),
                     ],
                 });
-                input.tx.moveCall({
+                tx.moveCall({
                     target: "".concat(input.personalKioskPackageId, "::personal_kiosk::return_val"),
-                    arguments: [input.tx.object(input.kioskCap), personalKioskCap, borrow],
+                    arguments: [tx.object(input.kioskCap), personalKioskCap, borrow],
                 });
             }
             else {
-                input.tx.moveCall({
-                    target: "".concat(input.typusPackageId, "::tails_staking::unstake_tails"),
+                tx.moveCall({
+                    target: "".concat(config.package.typus, "::tails_staking::unstake_tails"),
                     typeArguments: [],
                     arguments: [
-                        input.tx.object(input.typusEcosystemVersion),
-                        input.tx.object(input.typusTailsStakingRegistry),
-                        input.tx.object(input.kiosk),
-                        input.tx.object(input.kioskCap),
-                        input.tx.pure(input.tails),
+                        tx.object(config.version.typus),
+                        tx.object(config.registry.typus.tailsStaking),
+                        tx.object(input.kiosk),
+                        tx.object(input.kioskCap),
+                        tx.pure(input.tails),
                     ],
                 });
             }
-            return [2 /*return*/, input.tx];
+            return [2 /*return*/, tx];
         });
     });
 }
@@ -184,50 +183,50 @@ function getUnstakeTailsTx(input) {
         ctx: &mut TxContext,
     ) {
 */
-function getTransferTailsTx(input) {
+function getTransferTailsTx(config, tx, input) {
     return __awaiter(this, void 0, void 0, function () {
         var _a, coin, _b, personalKioskCap, borrow;
         return __generator(this, function (_c) {
-            _a = __read(input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.fee)]), 1), coin = _a[0];
+            _a = __read(tx.splitCoins(tx.gas, [tx.pure(input.fee)]), 1), coin = _a[0];
             if (input.personalKioskPackageId) {
-                _b = __read(input.tx.moveCall({
+                _b = __read(tx.moveCall({
                     target: "".concat(input.personalKioskPackageId, "::personal_kiosk::borrow_val"),
-                    arguments: [input.tx.object(input.kioskCap)],
+                    arguments: [tx.object(input.kioskCap)],
                 }), 2), personalKioskCap = _b[0], borrow = _b[1];
-                input.tx.moveCall({
-                    target: "".concat(input.typusPackageId, "::tails_staking::transfer_tails"),
+                tx.moveCall({
+                    target: "".concat(config.package.typus, "::tails_staking::transfer_tails"),
                     typeArguments: [],
                     arguments: [
-                        input.tx.object(input.typusEcosystemVersion),
-                        input.tx.object(input.typusTailsStakingRegistry),
-                        input.tx.object(input.kiosk),
+                        tx.object(config.version.typus),
+                        tx.object(config.registry.typus.tailsStaking),
+                        tx.object(input.kiosk),
                         personalKioskCap,
-                        input.tx.pure(input.tails),
+                        tx.pure(input.tails),
                         coin,
-                        input.tx.pure(input.recipient),
+                        tx.pure(input.recipient),
                     ],
                 });
-                input.tx.moveCall({
+                tx.moveCall({
                     target: "".concat(input.personalKioskPackageId, "::personal_kiosk::return_val"),
-                    arguments: [input.tx.object(input.kioskCap), personalKioskCap, borrow],
+                    arguments: [tx.object(input.kioskCap), personalKioskCap, borrow],
                 });
             }
             else {
-                input.tx.moveCall({
-                    target: "".concat(input.typusPackageId, "::tails_staking::transfer_tails"),
+                tx.moveCall({
+                    target: "".concat(config.package.typus, "::tails_staking::transfer_tails"),
                     typeArguments: [],
                     arguments: [
-                        input.tx.object(input.typusEcosystemVersion),
-                        input.tx.object(input.typusTailsStakingRegistry),
-                        input.tx.object(input.kiosk),
-                        input.tx.object(input.kioskCap),
-                        input.tx.pure(input.tails),
+                        tx.object(config.version.typus),
+                        tx.object(config.registry.typus.tailsStaking),
+                        tx.object(input.kiosk),
+                        tx.object(input.kioskCap),
+                        tx.pure(input.tails),
                         coin,
-                        input.tx.pure(input.recipient),
+                        tx.pure(input.recipient),
                     ],
                 });
             }
-            return [2 /*return*/, input.tx];
+            return [2 /*return*/, tx];
         });
     });
 }
@@ -239,16 +238,15 @@ function getTransferTailsTx(input) {
         ctx: &TxContext,
     ) {
 */
-function getDailySignUpTx(input) {
+function getDailySignUpTx(config, tx) {
     return __awaiter(this, void 0, void 0, function () {
-        var result;
         return __generator(this, function (_a) {
-            result = input.tx.moveCall({
-                target: "".concat(input.typusPackageId, "::tails_staking::daily_sign_up"),
+            tx.moveCall({
+                target: "".concat(config.package.typus, "::tails_staking::daily_sign_up"),
                 typeArguments: [],
-                arguments: [input.tx.object(input.typusEcosystemVersion), input.tx.object(input.typusTailsStakingRegistry), input.tx.pure(constants_1.CLOCK)],
+                arguments: [tx.object(config.version.typus), tx.object(config.registry.typus.tailsStaking), tx.pure(constants_1.CLOCK)],
             });
-            return [2 /*return*/, input.tx];
+            return [2 /*return*/, tx];
         });
     });
 }
@@ -259,21 +257,21 @@ function getDailySignUpTx(input) {
         ctx: &mut TxContext,
     ): Balance<TOKEN>
 */
-function getClaimProfitSharingTx(input) {
+function getClaimProfitSharingTx(config, tx, input) {
     return __awaiter(this, void 0, void 0, function () {
         var result;
         return __generator(this, function (_a) {
-            result = input.tx.moveCall({
-                target: "".concat(input.typusPackageId, "::tails_staking::claim_profit_sharing"),
+            result = tx.moveCall({
+                target: "".concat(config.package.typus, "::tails_staking::claim_profit_sharing"),
                 typeArguments: input.typeArguments,
-                arguments: [input.tx.object(input.typusEcosystemVersion), input.tx.object(input.typusTailsStakingRegistry)],
+                arguments: [tx.object(config.version.typus), tx.object(config.registry.typus.tailsStaking)],
             });
-            input.tx.moveCall({
-                target: "".concat(input.typusPackageId, "::utility::transfer_balance"),
+            tx.moveCall({
+                target: "".concat(config.package.typus, "::utility::transfer_balance"),
                 typeArguments: input.typeArguments,
-                arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+                arguments: [tx.object(result[0]), tx.pure(input.user)],
             });
-            return [2 /*return*/, input.tx];
+            return [2 /*return*/, tx];
         });
     });
 }
@@ -285,20 +283,20 @@ function getClaimProfitSharingTx(input) {
         raw: bool,
     ) {
 */
-function getLevelUpTx(input) {
+function getLevelUpTx(config, tx, input) {
     return __awaiter(this, void 0, void 0, function () {
         return __generator(this, function (_a) {
-            input.tx.moveCall({
-                target: "".concat(input.typusPackageId, "::tails_staking::level_up"),
+            tx.moveCall({
+                target: "".concat(config.package.typus, "::tails_staking::level_up"),
                 typeArguments: [],
                 arguments: [
-                    input.tx.object(input.typusEcosystemVersion),
-                    input.tx.object(input.typusTailsStakingRegistry),
-                    input.tx.pure(input.tails),
-                    input.tx.pure(input.raw),
+                    tx.object(config.version.typus),
+                    tx.object(config.registry.typus.tailsStaking),
+                    tx.pure(input.tails),
+                    tx.pure(input.raw),
                 ],
             });
-            return [2 /*return*/, input.tx];
+            return [2 /*return*/, tx];
         });
     });
 }
@@ -312,21 +310,21 @@ function getLevelUpTx(input) {
         ctx: &TxContext,
     ) {
 */
-function getExpUpTx(input) {
+function getExpUpTx(config, tx, input) {
     return __awaiter(this, void 0, void 0, function () {
         return __generator(this, function (_a) {
-            input.tx.moveCall({
-                target: "".concat(input.typusPackageId, "::tails_staking::exp_up"),
+            tx.moveCall({
+                target: "".concat(config.package.typus, "::tails_staking::exp_up"),
                 typeArguments: [],
                 arguments: [
-                    input.tx.object(input.typusEcosystemVersion),
-                    input.tx.object(input.typusTailsStakingRegistry),
-                    input.tx.object(input.typusUserRegistry),
-                    input.tx.pure(input.tails),
-                    input.tx.pure(input.amount),
+                    tx.object(config.version.typus),
+                    tx.object(config.registry.typus.tailsStaking),
+                    tx.object(config.registry.typus.user),
+                    tx.pure(input.tails),
+                    tx.pure(input.amount),
                 ],
             });
-            return [2 /*return*/, input.tx];
+            return [2 /*return*/, tx];
         });
     });
 }
@@ -342,61 +340,64 @@ function getExpUpTx(input) {
         ctx: &TxContext,
     ) {
 */
-function getExpUpWithoutStakingTx(input) {
+function getExpUpWithoutStakingTx(config, tx, input) {
     return __awaiter(this, void 0, void 0, function () {
         var _a, personalKioskCap, borrow;
         return __generator(this, function (_b) {
             if (input.personalKioskPackageId) {
-                _a = __read(input.tx.moveCall({
+                _a = __read(tx.moveCall({
                     target: "".concat(input.personalKioskPackageId, "::personal_kiosk::borrow_val"),
-                    arguments: [input.tx.object(input.kioskCap)],
+                    arguments: [tx.object(input.kioskCap)],
                 }), 2), personalKioskCap = _a[0], borrow = _a[1];
-                input.tx.moveCall({
-                    target: "".concat(input.typusPackageId, "::tails_staking::exp_up_without_staking"),
+                tx.moveCall({
+                    target: "".concat(config.package.typus, "::tails_staking::exp_up_without_staking"),
                     typeArguments: [],
                     arguments: [
-                        input.tx.object(input.typusEcosystemVersion),
-                        input.tx.object(input.typusTailsStakingRegistry),
-                        input.tx.object(input.typusUserRegistry),
-                        input.tx.object(input.kiosk),
+                        tx.object(config.version.typus),
+                        tx.object(config.registry.typus.tailsStaking),
+                        tx.object(config.registry.typus.user),
+                        tx.object(input.kiosk),
                         personalKioskCap,
-                        input.tx.pure(input.tails),
-                        input.tx.pure(input.amount),
+                        tx.pure(input.tails),
+                        tx.pure(input.amount),
                     ],
                 });
-                input.tx.moveCall({
+                tx.moveCall({
                     target: "".concat(input.personalKioskPackageId, "::personal_kiosk::return_val"),
-                    arguments: [input.tx.object(input.kioskCap), personalKioskCap, borrow],
+                    arguments: [tx.object(input.kioskCap), personalKioskCap, borrow],
                 });
             }
             else {
-                input.tx.moveCall({
-                    target: "".concat(input.typusPackageId, "::tails_staking::exp_up_without_staking"),
+                tx.moveCall({
+                    target: "".concat(config.package.typus, "::tails_staking::exp_up_without_staking"),
                     typeArguments: [],
                     arguments: [
-                        input.tx.object(input.typusEcosystemVersion),
-                        input.tx.object(input.typusTailsStakingRegistry),
-                        input.tx.object(input.typusUserRegistry),
-                        input.tx.object(input.kiosk),
-                        input.tx.object(input.kioskCap),
-                        input.tx.pure(input.tails),
-                        input.tx.pure(input.amount),
+                        tx.object(config.version.typus),
+                        tx.object(config.registry.typus.tailsStaking),
+                        tx.object(config.registry.typus.user),
+                        tx.object(input.kiosk),
+                        tx.object(input.kioskCap),
+                        tx.pure(input.tails),
+                        tx.pure(input.amount),
                     ],
                 });
             }
-            return [2 /*return*/, input.tx];
+            return [2 /*return*/, tx];
         });
     });
 }
-function getCreateKioskAndLockNftTx(kioskClient, gasBudget, nftPackageId, policy, nft_id, singer) {
+function getCreateKioskAndLockNftTx(config, tx, kioskClient, input) {
     return __awaiter(this, void 0, void 0, function () {
-        var tx, kioskTx, kiosk, kioskCap;
+        var kioskTx, kiosk, kioskCap;
         return __generator(this, function (_a) {
-            tx = new transactions_1.TransactionBlock();
             kioskTx = new kiosk_1.KioskTransaction({ transactionBlock: tx, kioskClient: kioskClient });
             kioskTx.create();
-            // @ts-ignore
-            kioskTx.lock({ itemType: "".concat(nftPackageId, "::typus_nft::Tails"), itemId: nft_id, policy: policy, item: nft_id });
+            kioskTx.lock({
+                itemType: "".concat(config.package.nft, "::typus_nft::Tails"),
+                itemId: input.nft_id,
+                policy: input.nft_policy,
+                item: input.nft_id,
+            });
             kiosk = kioskTx.kiosk, kioskCap = kioskTx.kioskCap;
             if (kiosk && kioskCap) {
                 tx.moveCall({
@@ -404,8 +405,7 @@ function getCreateKioskAndLockNftTx(kioskClient, gasBudget, nftPackageId, policy
                     typeArguments: [kiosk_1.KIOSK_TYPE],
                     arguments: [kiosk],
                 });
-                tx.transferObjects([kioskCap], tx.pure(singer));
-                tx.setGasBudget(gasBudget);
+                tx.transferObjects([kioskCap], tx.pure(input.user));
             }
             else {
                 console.error("Fail to Create Kiosk Tx!!");

package/dist/src/typus/tails-staking/view-function.d.ts

@@ -1,20 +1,12 @@
 import { SuiClient } from "@mysten/sui.js/client";
+import { TypusConfig } from "src/utils";
 export interface StakingInfo {
     user: string;
     tails: string[];
     profits: string[];
     u64Padding: string[];
 }
-export declare function getStakingInfo(input: {
-    provider: SuiClient;
-    typusPackageId: string;
-    typusEcosystemVersion: string;
-    typusTailsStakingRegistry: string;
+export declare function getStakingInfo(config: TypusConfig, provider: SuiClient, input: {
     user: string;
 }): Promise<StakingInfo>;
-export declare function getLevelCounts(input: {
-    provider: SuiClient;
-    typusPackageId: string;
-    typusEcosystemVersion: string;
-    typusTailsStakingRegistry: string;
-}): Promise<number[]>;
+export declare function getLevelCounts(config: TypusConfig, provider: SuiClient): Promise<number[]>;

package/dist/src/typus/tails-staking/view-function.js

@@ -40,8 +40,8 @@ exports.getStakingInfo = getStakingInfo;
 exports.getLevelCounts = getLevelCounts;
 var transactions_1 = require("@mysten/sui.js/transactions");
 var bcs_1 = require("@mysten/bcs");
-var utils_1 = require("../../utils");
-function getStakingInfo(input) {
+var utils_1 = require("src/utils");
+function getStakingInfo(config, provider, input) {
     return __awaiter(this, void 0, void 0, function () {
         var transactionBlock, results, bytes, reader, length;
         return __generator(this, function (_a) {
@@ -49,15 +49,15 @@ function getStakingInfo(input) {
                 case 0:
                     transactionBlock = new transactions_1.TransactionBlock();
                     transactionBlock.moveCall({
-                        target: "".concat(input.typusPackageId, "::tails_staking::get_staking_info"),
+                        target: "".concat(config.package.typus, "::tails_staking::get_staking_info"),
                         typeArguments: [],
                         arguments: [
-                            transactionBlock.pure(input.typusEcosystemVersion),
-                            transactionBlock.pure(input.typusTailsStakingRegistry),
+                            transactionBlock.pure(config.version.typus),
+                            transactionBlock.pure(config.registry.typus.tailsStaking),
                             transactionBlock.pure(input.user),
                         ],
                     });
-                    return [4 /*yield*/, input.provider.devInspectTransactionBlock({
+                    return [4 /*yield*/, provider.devInspectTransactionBlock({
                             sender: "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
                             transactionBlock: transactionBlock,
                         })];
@@ -93,7 +93,7 @@ function getStakingInfo(input) {
         });
     });
 }
-function getLevelCounts(input) {
+function getLevelCounts(config, provider) {
     return __awaiter(this, void 0, void 0, function () {
         var transactionBlock, results, bytes, reader;
         return __generator(this, function (_a) {
@@ -101,11 +101,11 @@ function getLevelCounts(input) {
                 case 0:
                     transactionBlock = new transactions_1.TransactionBlock();
                     transactionBlock.moveCall({
-                        target: "".concat(input.typusPackageId, "::tails_staking::get_level_counts"),
+                        target: "".concat(config.package.typus, "::tails_staking::get_level_counts"),
                         typeArguments: [],
-                        arguments: [transactionBlock.pure(input.typusEcosystemVersion), transactionBlock.pure(input.typusTailsStakingRegistry)],
+                        arguments: [transactionBlock.pure(config.version.typus), transactionBlock.pure(config.registry.typus.tailsStaking)],
                     });
-                    return [4 /*yield*/, input.provider.devInspectTransactionBlock({
+                    return [4 /*yield*/, provider.devInspectTransactionBlock({
                             sender: "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
                             transactionBlock: transactionBlock,
                         })];

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

@@ -1,8 +1,5 @@
 import { SuiClient } from "@mysten/sui.js/client";
-export declare function getUserMetadata(input: {
-    provider: SuiClient;
-    typusPackageId: string;
-    typusEcosystemVersion: string;
-    typusUserRegistry: string;
+import { TypusConfig } from "src/utils";
+export declare function getUserMetadata(config: TypusConfig, provider: SuiClient, input: {
     user: string;
 }): Promise<string[]>;

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

@@ -40,7 +40,7 @@ exports.getUserMetadata = getUserMetadata;
 var transactions_1 = require("@mysten/sui.js/transactions");
 var bcs_1 = require("@mysten/bcs");
 var SENDER = "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
-function getUserMetadata(input) {
+function getUserMetadata(config, provider, input) {
     return __awaiter(this, void 0, void 0, function () {
         var transactionBlock, results, bytes, reader;
         return __generator(this, function (_a) {
@@ -48,15 +48,15 @@ function getUserMetadata(input) {
                 case 0:
                     transactionBlock = new transactions_1.TransactionBlock();
                     transactionBlock.moveCall({
-                        target: "".concat(input.typusPackageId, "::user::get_user_metadata"),
+                        target: "".concat(config.package.typus, "::user::get_user_metadata"),
                         typeArguments: [],
                         arguments: [
-                            transactionBlock.pure(input.typusEcosystemVersion),
-                            transactionBlock.pure(input.typusUserRegistry),
+                            transactionBlock.pure(config.version.typus),
+                            transactionBlock.pure(config.registry.typus.user),
                             transactionBlock.pure(input.user),
                         ],
                     });
-                    return [4 /*yield*/, input.provider.devInspectTransactionBlock({ sender: SENDER, transactionBlock: transactionBlock })];
+                    return [4 /*yield*/, provider.devInspectTransactionBlock({ sender: SENDER, transactionBlock: transactionBlock })];
                 case 1:
                     results = (_a.sent()).results;
                     bytes = results[results.length - 1].returnValues[0][0];

package/dist/src/typus-dov-single-v2/authority-entry.d.ts

@@ -1,21 +1,5 @@
 import { TransactionBlock } from "@mysten/sui.js/transactions";
-/**
-    public(friend) entry fun otc<D_TOKEN, B_TOKEN>(
-        registry: &mut Registry,
-        index: u64,
-        coins: vector<Coin<B_TOKEN>>,
-        delivery_price: u64,
-        delivery_size: u64,
-        bidder_bid_value: u64,
-        bidder_fee_balance_value: u64,
-        incentive_bid_value: u64,
-        incentive_fee_balance_value: u64,
-        depositor_incentive_value: u64,
-        clock: &Clock,
-        ctx: &mut TxContext,
-    )
-*/
-export declare function getOtcTx(gasBudget: number, packageId: string, typeArguments: string[], registry: string, index: string, coins: string[], deliveryPrice: string, deliverySize: string, bidderBidValue: string, bidderFeeBalanceValue: string, incentiveBidValue: string, incentiveFeeBalanceValue: string, depositorIncentiveValue: string, usingSponsoredGasCoin?: boolean): Promise<TransactionBlock>;
+import { TypusConfig } from "src/utils";
 /**
     public(friend) entry fun update_config(
         registry: &mut Registry,
@@ -67,4 +51,28 @@ export interface UpdateConfigRequests {
         depositIncentiveBpDivisorDecimal?: string;
     };
 }
-export declare function getUpdateConfigTx(gasBudget: number, packageId: string, registry: string, requests: UpdateConfigRequests[]): Promise<TransactionBlock>;
+export declare function getUpdateConfigTx(config: TypusConfig, tx: TransactionBlock, requests: {
+    index: string;
+    input: {
+        oracleId?: string;
+        depositLotSize?: string;
+        bidLotSize?: string;
+        minDepositSize?: string;
+        minBidSize?: string;
+        maxDepositEntry?: string;
+        maxBidEntry?: string;
+        depositFeeBp?: string;
+        depositFeeShareBp?: string;
+        depositSharedFeePool?: string;
+        bidFeeBp?: string;
+        depositIncentiveBp?: string;
+        bidIncentiveBp?: string;
+        auctionDelayTsMs?: string;
+        auctionDurationTsMs?: string;
+        recoupDelayTsMs?: string;
+        capacity?: string;
+        leverage?: string;
+        riskLevel?: string;
+        depositIncentiveBpDivisorDecimal?: string;
+    };
+}[]): Promise<TransactionBlock>;