@typus/typus-sdk 1.4.18 → 1.4.19

package/dist/src/typus-dov-single-v2/user-entry.js

@@ -27,7 +27,7 @@ exports.getMultiTransferBidReceiptTx = getMultiTransferBidReceiptTx;
 exports.getRebateTx = getRebateTx;
 exports.getCompoundWithRedeemTx = getCompoundWithRedeemTx;
 var transactions_1 = require("@mysten/sui.js/transactions");
-var constants_1 = require("../constants");
+var constants_1 = require("src/constants");
 /**
     public fun public_raise_fund<D_TOKEN, B_TOKEN>(
         typus_ecosystem_version: &TypusEcosystemVersion,
@@ -43,54 +43,54 @@ var constants_1 = require("../constants");
         ctx: &mut TxContext,
     ): (TypusDepositReceipt, vector<u64>) {
  */
-function getRaiseFundTx(input) {
+function getRaiseFundTx(config, tx, input) {
     var raiseBalance = input.typeArguments[0] == "0x2::sui::SUI" ||
         input.typeArguments[0] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
-        ? input.tx.moveCall({
-            target: "".concat(input.typusFrameworkPackageId, "::utils::delegate_extract_balance"),
+        ? 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({
-            target: "".concat(input.typusFrameworkPackageId, "::utils::delegate_extract_balance"),
+        : 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({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_raise_fund"),
+    var result = tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::tds_user_entry::public_raise_fund"),
         typeArguments: input.typeArguments,
         arguments: [
-            input.tx.object(input.typusEcosystemVersion),
-            input.tx.object(input.typusUserRegistry),
-            input.tx.object(input.typusLeaderboardRegistry),
-            input.tx.object(input.typusDovSingleRegistry),
-            input.tx.pure(input.index),
-            input.tx.makeMoveVec({
-                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+            tx.object(config.version.typus),
+            tx.object(config.registry.typus.user),
+            tx.object(config.registry.typus.leaderboard),
+            tx.object(config.registry.dov.dovSingle),
+            tx.pure(input.index),
+            tx.makeMoveVec({
+                type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
-            input.tx.object(raiseBalance),
-            input.tx.pure(input.raiseFromPremium),
-            input.tx.pure(input.raiseFromInactive),
-            input.tx.object(constants_1.CLOCK),
+            tx.object(raiseBalance),
+            tx.pure(input.raiseFromPremium),
+            tx.pure(input.raiseFromInactive),
+            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 public_reduce_fund<D_TOKEN, B_TOKEN, I_TOKEN>(
@@ -109,48 +109,48 @@ function getRaiseFundTx(input) {
         ctx: &mut TxContext,
     ): (Option<TypusDepositReceipt>, Balance<D_TOKEN>, Balance<B_TOKEN>, Balance<I_TOKEN>, vector<u64>) {
  */
-function getReduceFundTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_reduce_fund"),
+function getReduceFundTx(config, tx, input) {
+    var result = tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::tds_user_entry::public_reduce_fund"),
         typeArguments: input.typeArguments,
         arguments: [
-            input.tx.object(input.typusEcosystemVersion),
-            input.tx.object(input.typusUserRegistry),
-            input.tx.object(input.typusLeaderboardRegistry),
-            input.tx.object(input.typusDovSingleRegistry),
-            input.tx.pure(input.index),
-            input.tx.makeMoveVec({
-                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+            tx.object(config.version.typus),
+            tx.object(config.registry.typus.user),
+            tx.object(config.registry.typus.leaderboard),
+            tx.object(config.registry.dov.dovSingle),
+            tx.pure(input.index),
+            tx.makeMoveVec({
+                type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
-            input.tx.pure(input.reduceFromWarmup),
-            input.tx.pure(input.reduceFromActive),
-            input.tx.pure(input.reduceFromPremium),
-            input.tx.pure(input.reduceFromInactive),
-            input.tx.pure(input.reduceFromIncentive),
-            input.tx.object(constants_1.CLOCK),
+            tx.pure(input.reduceFromWarmup),
+            tx.pure(input.reduceFromActive),
+            tx.pure(input.reduceFromPremium),
+            tx.pure(input.reduceFromInactive),
+            tx.pure(input.reduceFromIncentive),
+            tx.object(constants_1.CLOCK),
         ],
     });
-    input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::vault::transfer_deposit_receipt"),
-        arguments: [input.tx.object(result[0]), input.tx.pure(input.user)],
+    tx.moveCall({
+        target: "".concat(config.package.framework, "::vault::transfer_deposit_receipt"),
+        arguments: [tx.object(result[0]), tx.pure(input.user)],
     });
-    input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+    tx.moveCall({
+        target: "".concat(config.package.framework, "::utils::transfer_balance"),
         typeArguments: [input.typeArguments[0]],
-        arguments: [input.tx.object(result[1]), input.tx.pure(input.user)],
+        arguments: [tx.object(result[1]), tx.pure(input.user)],
     });
-    input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+    tx.moveCall({
+        target: "".concat(config.package.framework, "::utils::transfer_balance"),
         typeArguments: [input.typeArguments[1]],
-        arguments: [input.tx.object(result[2]), input.tx.pure(input.user)],
+        arguments: [tx.object(result[2]), tx.pure(input.user)],
     });
-    input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+    tx.moveCall({
+        target: "".concat(config.package.framework, "::utils::transfer_balance"),
         typeArguments: [input.typeArguments[2]],
-        arguments: [input.tx.object(result[3]), input.tx.pure(input.user)],
+        arguments: [tx.object(result[3]), tx.pure(input.user)],
     });
-    return input.tx;
+    return tx;
 }
 /**
     public fun public_refresh_deposit_snapshot<D_TOKEN, B_TOKEN>(
@@ -164,25 +164,25 @@ function getReduceFundTx(input) {
         ctx: &mut TxContext,
     ): (TypusDepositReceipt, vector<u64>) {
  */
-function getRefreshDepositSnapshotTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_refresh_deposit_snapshot"),
+function getRefreshDepositSnapshotTx(config, tx, input) {
+    var result = tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::tds_user_entry::public_refresh_deposit_snapshot"),
         typeArguments: input.typeArguments,
         arguments: [
-            input.tx.object(input.typusEcosystemVersion),
-            input.tx.object(input.typusUserRegistry),
-            input.tx.object(input.typusLeaderboardRegistry),
-            input.tx.object(input.typusDovSingleRegistry),
-            input.tx.pure(input.index),
-            input.tx.makeMoveVec({
-                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+            tx.object(config.version.typus),
+            tx.object(config.registry.typus.user),
+            tx.object(config.registry.typus.leaderboard),
+            tx.object(config.registry.dov.dovSingle),
+            tx.pure(input.index),
+            tx.makeMoveVec({
+                type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
-            input.tx.object(constants_1.CLOCK),
+            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(friend) entry fun new_bid<D_TOKEN, B_TOKEN>(
@@ -194,70 +194,67 @@ function getRefreshDepositSnapshotTx(input) {
         ctx: &mut TxContext,
     )
 */
-function getNewBidTx(input) {
+function getNewBidTx(config, tx, input) {
     if (!input.usingSponsoredGasCoin &&
         (input.typeArguments[1] == "0x2::sui::SUI" ||
             input.typeArguments[1] == "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI")) {
-        var _a = __read(input.tx.splitCoins(input.tx.gas, [input.tx.pure(input.premium_required)]), 1), coin = _a[0];
-        var result = input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_bid"),
+        var _a = __read(tx.splitCoins(tx.gas, [tx.pure(input.premium_required)]), 1), coin = _a[0];
+        var result = tx.moveCall({
+            target: "".concat(config.package.dovSingle, "::tds_user_entry::public_bid"),
             typeArguments: input.typeArguments,
             arguments: [
-                input.tx.object(input.typusEcosystemVersion),
-                input.tx.object(input.typusUserRegistry),
-                input.tx.object(input.tgldRegistry),
-                input.tx.object(input.typusLeaderboardRegistry),
-                input.tx.object(input.typusDovSingleRegistry),
-                input.tx.pure(input.index),
-                input.tx.makeMoveVec({ objects: [coin] }),
-                input.tx.pure(input.size),
-                input.tx.object(constants_1.CLOCK),
+                tx.object(config.version.typus),
+                tx.object(config.registry.typus.user),
+                tx.object(input.tgldRegistry),
+                tx.object(config.registry.typus.leaderboard),
+                tx.object(config.registry.dov.dovSingle),
+                tx.pure(input.index),
+                tx.makeMoveVec({ objects: [coin] }),
+                tx.pure(input.size),
+                tx.object(constants_1.CLOCK),
             ],
         });
-        input.tx.transferObjects([input.tx.object(result[0])], input.user);
-        input.tx.moveCall({
-            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_coins"),
+        tx.transferObjects([tx.object(result[0])], input.user);
+        tx.moveCall({
+            target: "".concat(config.package.framework, "::utils::transfer_coins"),
             typeArguments: [input.typeArguments[1]],
-            arguments: [input.tx.makeMoveVec({ objects: [input.tx.object(result[1])] }), input.tx.pure(input.user)],
+            arguments: [tx.makeMoveVec({ objects: [tx.object(result[1])] }), tx.pure(input.user)],
         });
     }
     else {
-        var balance = input.tx.moveCall({
-            target: "".concat(input.typusFrameworkPackageId, "::utils::extract_balance"),
+        var balance = tx.moveCall({
+            target: "".concat(config.package.framework, "::utils::extract_balance"),
             typeArguments: [input.typeArguments[1]],
-            arguments: [
-                input.tx.makeMoveVec({ objects: input.coins.map(function (coin) { return input.tx.object(coin); }) }),
-                input.tx.pure(input.premium_required),
-            ],
+            arguments: [tx.makeMoveVec({ objects: input.coins.map(function (coin) { return tx.object(coin); }) }), tx.pure(input.premium_required)],
         });
-        var coin = input.tx.moveCall({
+        var coin = tx.moveCall({
             target: "0x2::coin::from_balance",
             typeArguments: [input.typeArguments[1]],
-            arguments: [input.tx.object(balance)],
+            arguments: [tx.object(balance)],
         });
-        var result = input.tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_bid"),
+        var result = tx.moveCall({
+            target: "".concat(config.package.dovSingle, "::tds_user_entry::public_bid"),
             typeArguments: input.typeArguments,
             arguments: [
-                input.tx.object(input.typusEcosystemVersion),
-                input.tx.object(input.typusUserRegistry),
-                input.tx.object(input.tgldRegistry),
-                input.tx.object(input.typusLeaderboardRegistry),
-                input.tx.object(input.typusDovSingleRegistry),
-                input.tx.pure(input.index),
-                input.tx.makeMoveVec({ objects: [coin] }),
-                input.tx.pure(input.size),
-                input.tx.pure("0x6"),
+                tx.object(config.version.typus),
+                tx.object(config.registry.typus.user),
+                tx.object(input.tgldRegistry),
+                tx.object(config.registry.typus.leaderboard),
+                tx.object(config.registry.dov.dovSingle),
+                tx.pure(input.index),
+                tx.makeMoveVec({ objects: [coin] }),
+                tx.pure(input.size),
+                tx.pure("0x6"),
             ],
         });
-        input.tx.transferObjects([input.tx.object(result[0])], input.user);
-        input.tx.moveCall({
-            target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_coins"),
+        tx.transferObjects([tx.object(result[0])], input.user);
+        tx.moveCall({
+            target: "".concat(config.package.framework, "::utils::transfer_coins"),
             typeArguments: [input.typeArguments[1]],
-            arguments: [input.tx.makeMoveVec({ objects: [input.tx.object(result[1])] }), input.tx.pure(input.user)],
+            arguments: [tx.makeMoveVec({ objects: [tx.object(result[1])] }), tx.pure(input.user)],
         });
     }
-    return input.tx;
+    return tx;
 }
 /**
     public(friend) entry fun exercise<D_TOKEN, B_TOKEN>(
@@ -267,25 +264,25 @@ function getNewBidTx(input) {
         ctx: &mut TxContext,
     )
 */
-function getExerciseTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::exercise"),
+function getExerciseTx(config, tx, input) {
+    var result = tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::tds_user_entry::exercise"),
         typeArguments: input.typeArguments,
         arguments: [
-            input.tx.object(input.typusDovSingleRegistry),
-            input.tx.pure(input.index),
-            input.tx.makeMoveVec({
-                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusBidReceipt"),
-                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+            tx.object(config.registry.dov.dovSingle),
+            tx.pure(input.index),
+            tx.makeMoveVec({
+                type: "".concat(config.packageOrigin.framework, "::vault::TypusBidReceipt"),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
         ],
     });
-    input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+    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(friend) entry fun transfer_bid_receipt<D_TOKEN, B_TOKEN>(
@@ -297,55 +294,55 @@ function getExerciseTx(input) {
         ctx: &mut TxContext,
     ) {
 */
-function getTransferBidReceiptTx(input) {
-    input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::transfer_bid_receipt"),
+function getTransferBidReceiptTx(config, tx, input) {
+    tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::tds_user_entry::transfer_bid_receipt"),
         typeArguments: input.typeArguments,
         arguments: [
-            input.tx.object(input.typusDovSingleRegistry),
-            input.tx.pure(input.index),
-            input.tx.makeMoveVec({
-                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusBidReceipt"),
-                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+            tx.object(config.registry.dov.dovSingle),
+            tx.pure(input.index),
+            tx.makeMoveVec({
+                type: "".concat(config.packageOrigin.framework, "::vault::TypusBidReceipt"),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
-            input.tx.pure(input.share ? [input.share] : []),
-            input.tx.pure(input.recipient),
+            tx.pure(input.share ? [input.share] : []),
+            tx.pure(input.recipient),
         ],
     });
-    return input.tx;
+    return tx;
 }
-function getSplitBidReceiptTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::simple_split_bid_receipt"),
+function getSplitBidReceiptTx(config, tx, input) {
+    var result = tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::tds_user_entry::simple_split_bid_receipt"),
         typeArguments: [],
         arguments: [
-            input.tx.object(input.typusDovSingleRegistry),
-            input.tx.pure(input.index),
-            input.tx.makeMoveVec({
-                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusBidReceipt"),
-                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+            tx.object(config.registry.dov.dovSingle),
+            tx.pure(input.index),
+            tx.makeMoveVec({
+                type: "".concat(config.packageOrigin.framework, "::vault::TypusBidReceipt"),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
-            input.tx.pure([input.share]),
+            tx.pure([input.share]),
         ],
     });
-    var unwrap0 = input.tx.moveCall({
+    var unwrap0 = tx.moveCall({
         target: "0x1::option::destroy_some",
-        typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusBidReceipt")],
-        arguments: [input.tx.object(result[0])],
+        typeArguments: ["".concat(config.packageOrigin.framework, "::vault::TypusBidReceipt")],
+        arguments: [tx.object(result[0])],
     });
-    var unwrap1 = input.tx.moveCall({
+    var unwrap1 = tx.moveCall({
         target: "0x1::option::destroy_some",
-        typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusBidReceipt")],
-        arguments: [input.tx.object(result[1])],
+        typeArguments: ["".concat(config.packageOrigin.framework, "::vault::TypusBidReceipt")],
+        arguments: [tx.object(result[1])],
     });
-    input.tx.transferObjects([unwrap1], input.recipient);
+    tx.transferObjects([unwrap1], input.recipient);
     return unwrap0;
 }
-function getMultiTransferBidReceiptTx(input) {
+function getMultiTransferBidReceiptTx(config, input) {
     var tx = new transactions_1.TransactionBlock();
     console.assert(input.shares.length == input.recipients.length, "shares.length != recipients.length");
     var receipts = {
-        // type: `${input.typusFrameworkOriginPackageId}::vault::TypusBidReceipt`,
+        // type: `${config.packageOrigin.framework}::vault::TypusBidReceipt`,
         objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
     };
     var i = 0;
@@ -353,10 +350,10 @@ function getMultiTransferBidReceiptTx(input) {
         var share = input.shares[i];
         var recipient = input.recipients[i];
         var result = tx.moveCall({
-            target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_transfer_bid_receipt"),
+            target: "".concat(config.package.dovSingle, "::tds_user_entry::public_transfer_bid_receipt"),
             typeArguments: input.typeArguments,
             arguments: [
-                tx.object(input.typusDovSingleRegistry),
+                tx.object(config.registry.dov.dovSingle),
                 tx.pure(input.index),
                 tx.makeMoveVec(receipts),
                 tx.pure([share]),
@@ -365,7 +362,7 @@ function getMultiTransferBidReceiptTx(input) {
         });
         var unwrap = tx.moveCall({
             target: "0x1::option::destroy_some",
-            typeArguments: ["".concat(input.typusFrameworkOriginPackageId, "::vault::TypusBidReceipt")],
+            typeArguments: ["".concat(config.packageOrigin.framework, "::vault::TypusBidReceipt")],
             arguments: [tx.object(result[0])],
         });
         receipts = { objects: [unwrap] };
@@ -383,58 +380,50 @@ function getMultiTransferBidReceiptTx(input) {
         ctx: &mut TxContext,
     )
 */
-function getRebateTx(input) {
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::rebate"),
+function getRebateTx(config, tx, input) {
+    var result = tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::tds_user_entry::rebate"),
         typeArguments: [input.typeArgument],
-        arguments: [input.tx.object(input.typusDovSingleRegistry)],
+        arguments: [tx.object(config.registry.dov.dovSingle)],
     });
-    var balance = input.tx.moveCall({
+    var balance = tx.moveCall({
         target: "0x1::option::destroy_some",
         typeArguments: ["0x2::balance::Balance<".concat(input.typeArgument, ">")],
-        arguments: [input.tx.object(result[0])],
+        arguments: [tx.object(result[0])],
     });
-    input.tx.moveCall({
-        target: "".concat(input.typusFrameworkPackageId, "::utils::transfer_balance"),
+    tx.moveCall({
+        target: "".concat(config.package.framework, "::utils::transfer_balance"),
         typeArguments: [input.typeArgument],
-        arguments: [input.tx.object(balance), input.tx.pure(input.user)],
+        arguments: [tx.object(balance), tx.pure(input.user)],
     });
-    return input.tx;
+    return tx;
 }
-function getCompoundWithRedeemTx(input) {
-    var raiseBalance = input.tx.moveCall({
+function getCompoundWithRedeemTx(config, tx, input) {
+    var raiseBalance = tx.moveCall({
         target: "0x2::balance::zero",
         typeArguments: [input.typeArguments[0]],
         arguments: [],
     });
-    var result = input.tx.moveCall({
-        target: "".concat(input.typusDovSinglePackageId, "::tds_user_entry::public_raise_fund"),
+    var result = tx.moveCall({
+        target: "".concat(config.package.dovSingle, "::tds_user_entry::public_raise_fund"),
         typeArguments: [input.typeArguments[0], input.typeArguments[1]],
         arguments: [
-            input.tx.object(input.typusEcosystemVersion),
-            input.tx.object(input.typusUserRegistry),
-            input.tx.object(input.typusLeaderboardRegistry),
-            input.tx.object(input.typusDovSingleRegistry),
-            input.tx.pure(input.index),
-            input.tx.makeMoveVec({
-                type: "".concat(input.typusFrameworkOriginPackageId, "::vault::TypusDepositReceipt"),
-                objects: input.receipts.map(function (receipt) { return input.tx.object(receipt); }),
+            tx.object(config.version.typus),
+            tx.object(config.registry.typus.user),
+            tx.object(config.registry.typus.leaderboard),
+            tx.object(config.registry.dov.dovSingle),
+            tx.pure(input.index),
+            tx.makeMoveVec({
+                type: "".concat(config.packageOrigin.framework, "::vault::TypusDepositReceipt"),
+                objects: input.receipts.map(function (receipt) { return tx.object(receipt); }),
             }),
-            input.tx.object(raiseBalance),
-            input.tx.pure(true),
-            input.tx.pure(false),
-            input.tx.object(constants_1.CLOCK),
+            tx.object(raiseBalance),
+            tx.pure(true),
+            tx.pure(false),
+            tx.object(constants_1.CLOCK),
         ],
     });
-    return getReduceFundTx({
-        tx: input.tx,
-        typusEcosystemVersion: input.typusEcosystemVersion,
-        typusUserRegistry: input.typusUserRegistry,
-        typusLeaderboardRegistry: input.typusLeaderboardRegistry,
-        typusFrameworkOriginPackageId: input.typusFrameworkOriginPackageId,
-        typusFrameworkPackageId: input.typusFrameworkPackageId,
-        typusDovSinglePackageId: input.typusDovSinglePackageId,
-        typusDovSingleRegistry: input.typusDovSingleRegistry,
+    return getReduceFundTx(config, tx, {
         typeArguments: input.typeArguments,
         index: input.index,
         receipts: [result[0]],

package/dist/src/typus-dov-single-v2/view-function.d.ts

@@ -1,4 +1,5 @@
 import { SuiClient } from "@mysten/sui.js/client";
+import { TypusConfig } from "src/utils";
 export interface Vault {
     id: string;
     info: Info;
@@ -128,7 +129,9 @@ export interface DepositVault {
     u64Padding: string[];
     bcsPadding: string[];
 }
-export declare function getVaults(provider: SuiClient, packageId: string, registry: string, indexes: string[], sender?: string): Promise<{
+export declare function getVaults(config: TypusConfig, provider: SuiClient, input: {
+    indexes: string[];
+}): Promise<{
     [key: string]: Vault;
 }>;
 export interface Auction {
@@ -149,7 +152,9 @@ export interface Auction {
     ableToRemoveBid: boolean;
     bidIndex: string;
 }
-export declare function getAuctions(provider: SuiClient, packageId: string, registry: string, indexes: string[], sender?: string): Promise<{
+export declare function getAuctions(config: TypusConfig, provider: SuiClient, input: {
+    indexes: string[];
+}): Promise<{
     [key: string]: Auction;
 }>;
 export interface AuctionBid {
@@ -162,7 +167,9 @@ export interface AuctionBid {
     feeDiscount: string;
     tsMs: string;
 }
-export declare function getAuctionBids(provider: SuiClient, packageId: string, registry: string, index: string, sender?: string): Promise<AuctionBid[]>;
+export declare function getAuctionBids(config: TypusConfig, provider: SuiClient, input: {
+    index: string;
+}): Promise<AuctionBid[]>;
 export interface DepositSnapshot {
     snapshots: string[];
     totalDeposit: string;
@@ -183,7 +190,10 @@ export interface RRR {
     };
     b: DepositSnapshot;
 }
-export declare function getDepositShares(provider: SuiClient, typusFrameworkPackageId: string, packageId: string, registry: string, receipts: string[], user: string, sender?: string): Promise<{
+export declare function getDepositShares(config: TypusConfig, provider: SuiClient, input: {
+    receipts: string[];
+    user: string;
+}): Promise<{
     depositShare: {
         [key: string]: DepositShare;
     };
@@ -204,9 +214,13 @@ export interface BidShare {
     bidVault: BidVault;
     share: string;
 }
-export declare function getMyBids(provider: SuiClient, typusFrameworkPackageId: string, packageId: string, registry: string, receipts: string[], sender?: string): Promise<{
+export declare function getMyBids(config: TypusConfig, provider: SuiClient, input: {
+    receipts: string[];
+}): Promise<{
     [key: string]: BidShare;
 }>;
-export declare function getRefundShares(provider: SuiClient, packageId: string, registry: string, typeArguments: string[], sender?: string): Promise<{
+export declare function getRefundShares(config: TypusConfig, provider: SuiClient, input: {
+    typeArguments: string[];
+}): Promise<{
     [key: string]: string;
 }>;