@ember-finance/sdk 0.0.1

package/dist/src/vaults/on-chain-calls/tx-builder.js

@@ -0,0 +1,805 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxBuilder = void 0;
+const utils_1 = require("../utils");
+const library_sui_1 = require("@firefly-exchange/library-sui");
+const utils_2 = require("@mysten/sui/utils");
+class TxBuilder {
+    constructor(_deployment) {
+        this.parser = new utils_1.DeploymentParser(_deployment);
+    }
+    /**
+     * Pauses or unpauses the non-admin operations
+     * @param pause True if the non-admin operations should be paused, false otherwise
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    pauseNonAdminOperations(pause, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(this.parser.getAdminCap()),
+                txb.pure.bool(pause)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::pause_non_admin_operations`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Increases the version of the protocol supported. Only admin can invoke this
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    increaseProtocolVersion(options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(this.parser.getAdminCap())
+            ],
+            target: `${this.parser.getPackageId()}::gateway::increase_supported_package_version`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates the platform fee recipient
+     * @param recipient Address of the platform fee recipient
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updatePlatformFeeRecipient(recipient, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(this.parser.getAdminCap()),
+                txb.pure.address(recipient)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::update_platform_fee_recipient`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates the min rate
+     * @param minRate Minimum rate for the protocol
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updateMinRate(minRate, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(this.parser.getAdminCap()),
+                txb.pure.u64(minRate)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::update_min_rate`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates the max rate
+     * @param maxRate Maximum rate for the protocol
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updateMaxRate(maxRate, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(this.parser.getAdminCap()),
+                txb.pure.u64(maxRate)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::update_max_rate`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates the max rate interval
+     * @param maxRateInterval Maximum rate interval for the protocol
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updateMaxRateInterval(maxRateInterval, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(this.parser.getAdminCap()),
+                txb.pure.u64(maxRateInterval)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::update_max_rate_interval`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates the default rate
+     * @param defaultRate Default rate for the protocol
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updateDefaultRate(defaultRate, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(this.parser.getAdminCap()),
+                txb.pure.u64(defaultRate)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::update_default_rate`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates the max fee percentage
+     * @param maxFeePercentage Max fee percentage for the protocol
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updateMaxFeePercentage(maxFeePercentage, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(this.parser.getAdminCap()),
+                txb.pure.u64(maxFeePercentage)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::update_max_fee_percentage`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Creates a new vault
+     * @param depositCoinType Type of the deposit coin
+     * @param receiptCoinType Type of the receipt coin
+     * @param name Name of the vault
+     * @param admin Admin of the vault
+     * @param operator Operator of the vault
+     * @param maxRateChangePerUpdate Max rate change per update
+     * @param feePercentage Fee percentage
+     * @param minWithdrawalShares Min withdrawal shares
+     * @param rateUpdateInterval Rate update interval
+     * @param maxTVL Max TVL
+     * @param subAccounts Sub accounts
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    createVault(depositCoinType, receiptCoinType, name, admin, operator, maxRateChangePerUpdate, feePercentage, minWithdrawalShares, rateUpdateInterval, maxTVL, subAccounts, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        const receiptTokenTreasuryCap = this.parser.getReceiptCoinTreasuryCap(receiptCoinType);
+        txb.moveCall({
+            arguments: [
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(receiptTokenTreasuryCap),
+                txb.object(this.parser.getAdminCap()),
+                txb.pure.string(name),
+                txb.pure.address(admin),
+                txb.pure.address(operator),
+                txb.pure.u64(maxRateChangePerUpdate),
+                txb.pure.u64(feePercentage),
+                txb.pure.u64(minWithdrawalShares),
+                txb.pure.u64(rateUpdateInterval),
+                txb.pure.u64(maxTVL),
+                txb.pure.vector("address", subAccounts)
+            ],
+            typeArguments: [depositCoinType, receiptCoinType],
+            target: `${this.parser.getPackageId()}::gateway::create_vault`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates vault admin
+     * @param vaultId Id of the vault
+     * @param admin Admin of the vault
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updateVaultAdmin(vaultId, admin, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(this.parser.getAdminCap()),
+                txb.pure.address(admin)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::change_vault_admin`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates the paused status of the vault
+     * @param vaultId Id of the vault
+     * @param paused Paused status of the vault
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updateVaultPausedStatus(vaultId, paused, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.bool(paused)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::set_vault_paused_status`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates the operator of the vault
+     * @param vaultId Id of the vault
+     * @param operator Operator of the vault
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updateVaultOperator(vaultId, operator, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.address(operator)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::change_vault_operator`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates the min withdrawal shares of the vault
+     * @param vaultId Id of the vault
+     * @param minWithdrawalShares Min withdrawal shares
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updateVaultMinWithdrawalShares(vaultId, minWithdrawalShares, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.u64(minWithdrawalShares)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::update_vault_min_withdrawal_shares`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Sets a sub account
+     * @param vaultId Id of the vault
+     * @param subAccount Sub account of the vault
+     * @param isActive Is active
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    setSubAccount(vaultId, subAccount, isActive, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.address(subAccount),
+                txb.pure.bool(isActive)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::set_sub_account`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates vault max TVL
+     * @param vaultId Id of the vault
+     * @param maxTVL Max TVL of the vault
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updateVaultMaxTVL(vaultId, maxTVL, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.u64(maxTVL)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::update_vault_max_tvl`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates the rate update interval of the vault
+     * @param vaultId Id of the vault
+     * @param rateUpdateInterval Rate update interval in ms
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updateVaultRateUpdateInterval(vaultId, rateUpdateInterval, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.u64(rateUpdateInterval)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::change_vault_rate_update_interval`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates the fee percentage of the vault
+     * @param vaultId Id of the vault
+     * @param feePercentage Fee percentage
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updateVaultFeePercentage(vaultId, feePercentage, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.u64(feePercentage)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::update_vault_fee_percentage`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Set min withdrawal shares
+     * @param vaultId Id of the vault
+     * @param minWithdrawalShares Min withdrawal shares
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    setMinWithdrawalShares(vaultId, minWithdrawalShares, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.u64(minWithdrawalShares)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::set_min_withdrawal_shares`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Sets a blacklisted account
+     * @param vaultId Id of the vault
+     * @param account Address of the account
+     * @param isBlacklisted Is blacklisted
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    setBlacklistedAccount(vaultId, account, isBlacklisted, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.address(account),
+                txb.pure.bool(isBlacklisted)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::set_blacklisted_account`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Updates the rate of the vault
+     * @param vaultId Id of the vault
+     * @param rate Rate of the vault
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    updateVaultRate(vaultId, rate, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.u64(rate),
+                txb.object(utils_2.SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::update_vault_rate`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Deposit to vault without minting shares
+     * @param vaultId Id of the vault
+     * @param subAccount Sub account of the vault
+     * @param coinId Id of the coin
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    depositToVaultWithoutMintingShares(vaultId, subAccount, coinId, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.address(subAccount),
+                txb.object(coinId)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::deposit_to_vault_without_minting_shares`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Withdraw from vault without redeeming shares
+     * @param vaultId Id of the vault
+     * @param subAccount Sub account of the vault
+     * @param amount Amount to withdraw
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    withdrawFromVaultWithoutRedeemingShares(vaultId, subAccount, amount, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.address(subAccount),
+                txb.pure.u64(amount)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::withdraw_from_vault_without_redeeming_shares`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Process withdrawal requests
+     * @param vaultId Id of the vault
+     * @param requestCount Max number of requests to process
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    processWithdrawalRequests(vaultId, requestCount, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.u64(requestCount),
+                txb.object(utils_2.SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::process_withdrawal_requests`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Process withdrawal requests up to timestamp
+     * @param vaultId Id of the vault
+     * @param timestamp Timestamp
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    processWithdrawalRequestsUpToTimestamp(vaultId, timestamp, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.u64(timestamp),
+                txb.object(utils_2.SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::process_withdrawal_requests_up_to_timestamp`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Charge platform fee
+     * @param vaultId Id of the vault
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    chargePlatformFee(vaultId, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(utils_2.SUI_CLOCK_OBJECT_ID)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::charge_platform_fee`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Collect platform fee
+     * @param vaultId Id of the vault
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    collectPlatformFee(vaultId, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [txb.object(vaultId), txb.object(this.parser.getProtocolConfig())],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::collect_platform_fee`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Deposit asset
+     * @param vaultId Id of the vault
+     * @param coinId Id of the coin
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    depositAsset(vaultId, coinId, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(coinId)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::deposit_asset`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Mint shares
+     * @param vaultId Id of the vault
+     * @param coinId Id of the coin
+     * @param shares Amount of shares
+     * @param receiver Address of the receiver
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    mintShares(vaultId, coinId, shares, receiver, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(coinId),
+                txb.pure.u64(shares),
+                txb.pure.vector("address", [receiver])
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::mint_shares`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Redeems shares
+     * @param vaultId Id of the vault
+     * @param sharesCoinId Id of the shares coin
+     * @param receiver Address of the receiver
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    redeemShares(vaultId, sharesCoinId, receiver, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(utils_2.SUI_CLOCK_OBJECT_ID),
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.object(sharesCoinId),
+                txb.pure.vector("address", [receiver])
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::redeem_shares`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+    /**
+     * Cancel pending withdrawal request
+     * @param vaultId Id of the vault
+     * @param sequenceNumber Sequence number of the withdrawal request
+     * @param options Optional tx building params
+     * @returns TransactionBlock
+     */
+    cancelPendingWithdrawalRequest(vaultId, sequenceNumber, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        txb.moveCall({
+            arguments: [
+                txb.object(vaultId),
+                txb.object(this.parser.getProtocolConfig()),
+                txb.pure.u128(sequenceNumber)
+            ],
+            typeArguments: [
+                this.parser.getDepositCoinType(vaultId),
+                this.parser.getReceiptCoinType(vaultId)
+            ],
+            target: `${this.parser.getPackageId()}::gateway::cancel_pending_withdrawal_request`
+        });
+        if (options?.gasBudget)
+            txb.setGasBudget(options.gasBudget);
+        if (options?.sender)
+            txb.setSenderIfNotSet(options.sender);
+        return txb;
+    }
+}
+exports.TxBuilder = TxBuilder;