@affluent-org/sdk 0.0.4 → 0.0.6

package/dist/strategy_vault/base.d.ts

@@ -1,11 +1,12 @@
-import { Address, Sender, OpenedContract, Cell } from "@ton/core";
+import { Address, Dictionary, OpenedContract, Cell } from "@ton/core";
 import { ServiceBaseV1 } from "../common/service";
 import { AddressInput, AddressLike } from "../contracts/common/type";
-import { StrategyVault } from "../contracts/vault/strategy-vault";
+import { StrategyVault, VaultResponseOptions } from "../contracts/vault/strategy-vault";
 import { JettonWallet } from "../contracts/jetton/jetton-wallet";
 import { RFQAuction } from "../contracts/rfq/rfq_auction";
 import { AssetPriceInfo, OnchainDataInfo } from "../contracts/oracle/redstone-onchain-oracle/type";
 import { PoolState, StrategyVaultState } from "..";
+import { AddressSender } from "../types/sender";
 export declare function createQueryId(data: any, timestamp?: number): bigint;
 type SlippageBound = {
     min: number;
@@ -14,23 +15,48 @@ type SlippageBound = {
 type SippageBoundInput = number | SlippageBound;
 export declare class StrategyVaultBase extends ServiceBaseV1 {
     getVaultData(strategyVaultAddress: AddressLike): Promise<{
+        globalDepositValueCap: bigint;
+        withdrawFeeRate: number;
+        queueWithdrawFeeRate: number;
+        depositQueueManager: import("../contracts/vault/strategy-vault").QueueManager;
+        withdrawQueueManager: import("../contracts/vault/strategy-vault").QueueManager;
+        interactiveVaultDict: Record<string, import("../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+        xchainConnectorAddress: Address | null;
+        xchainConfig: Record<string, {
+            connected: boolean;
+            xchainAccountAddress: bigint;
+            oftConfig: Map<string, {
+                destinationAddress: Address;
+                forwardGas: bigint;
+                forwardPayload?: Cell | null;
+                lzTransferFeeRate?: bigint;
+            }> | null;
+            strategyConfig: Map<bigint, {
+                isExecutable: boolean;
+            }> | null;
+            afterStrategyConfig: Map<bigint, {
+                isExecutable: boolean;
+            }> | null;
+            lzGasFee: bigint;
+        }>;
+        xchainUpdateHash: bigint;
         owner: Address;
         manager: Address;
-        assets: Record<string, import("../contracts/vault/strategy-vault").Asset>;
+        assets: Record<string, import("../contracts/vault/strategy-vault").AssetV2>;
         factorialPools: Record<string, import("../contracts/vault/strategy-vault").FactorialPool>;
         aggregatorIndex: bigint;
         content: Cell;
         totalSupply: bigint;
-        oracleConfig: import("../contracts/oracle/redstone-oracle/type").RedstonOracleConfig | Cell | import("../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | null;
+        oracleConfig: import("../contracts/oracle/redstone-oracle/type").RedstonOracleConfig | Cell | import("../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig;
         rfqConfig: {
-            priceDerivationTolerance: number;
+            priceDeviationTolerance: number;
             rfqEventEmitterAddress: string | null;
         } | null;
         gasConfig: Record<string, bigint> | null;
         isPrivateVault: boolean;
         depositCloseTimestamp: number;
         withdrawOpenTimestamp: number;
-        whitelistedMinters: Address[];
+        whitelistedMinters: Dictionary<Address, Boolean>;
         lastCollectTime: number;
         managementFeeRatePerYear: number;
         protocolFeeRatePerYear: number;
@@ -50,73 +76,131 @@ export declare class StrategyVaultBase extends ServiceBaseV1 {
         timelock: bigint;
         pendingOwnerActionIndex: bigint;
         pendingOwnerActionCount: bigint;
-        pendingOwnerAction: Record<string, import("../contracts/vault/strategy-vault").PendingOwnerAction>;
+        pendingOwnerAction: any;
+        getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../contracts/vault/strategy-vault").FactorialPoolShare;
+        getAsset: (assetAddress: Address) => import("../contracts/vault/strategy-vault").AssetV2;
+        version: string;
         address: Address;
+        balance: bigint;
+        code: Cell;
+    } | {
+        globalDepositValueCap: bigint;
+        withdrawFeeRate: number;
+        queueWithdrawFeeRate: number;
+        depositQueueManager: import("../contracts/vault/strategy-vault").QueueManager;
+        withdrawQueueManager: import("../contracts/vault/strategy-vault").QueueManager;
+        interactiveVaultDict: Record<string, import("../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+        xchainConnectorAddress: null;
+        xchainConfig: null;
+        xchainUpdateHash: bigint;
+        owner: Address;
+        manager: Address;
+        assets: Record<string, import("../contracts/vault/strategy-vault").AssetV2>;
+        factorialPools: Record<string, import("../contracts/vault/strategy-vault").FactorialPool>;
+        aggregatorIndex: bigint;
+        content: Cell;
+        totalSupply: bigint;
+        oracleConfig: import("../contracts/oracle/redstone-oracle/type").RedstonOracleConfig | Cell | import("../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig;
+        rfqConfig: {
+            priceDeviationTolerance: number;
+            rfqEventEmitterAddress: string | null;
+        } | null;
+        gasConfig: Record<string, bigint> | null;
+        isPrivateVault: boolean;
+        depositCloseTimestamp: number;
+        withdrawOpenTimestamp: number;
+        whitelistedMinters: Dictionary<Address, Boolean>;
+        lastCollectTime: number;
+        managementFeeRatePerYear: number;
+        protocolFeeRatePerYear: number;
+        collectedManagementFee: bigint;
+        collectedProtocolFee: bigint;
+        rfqCode: Cell;
+        walletCode: Cell;
+        dataAggregatorCode: Cell;
+        protocolFeeManagerAddress: Address;
+        rfqIndex: bigint;
+        isExecutingStrategy: boolean;
+        maxLeverageRatio: number;
+        assetWalletDict: Record<string, string>;
+        walletAssetDict: Record<string, string>;
+        managementFeeRecipientAddress: Address | null;
+        guardianAddress: Address | null;
+        timelock: bigint;
+        pendingOwnerActionIndex: bigint;
+        pendingOwnerActionCount: bigint;
+        pendingOwnerAction: any;
+        getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../contracts/vault/strategy-vault").FactorialPoolShare;
+        getAsset: (assetAddress: Address) => import("../contracts/vault/strategy-vault").AssetV2;
+        version: string;
+        address: Address;
+        balance: bigint;
+        code: Cell;
     }>;
-    getVault(strategyVaultAddress: AddressLike): OpenedContract<StrategyVault>;
-    getVaultWallet(strategyVaultAddress: AddressLike, accountAddress: AddressLike): Promise<OpenedContract<JettonWallet>>;
-    sendSetOwner(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    getVault(strategyVaultAddress: AddressInput): OpenedContract<StrategyVault>;
+    getVaultWallet(strategyVaultAddress: AddressInput, accountAddress: AddressLike): Promise<OpenedContract<JettonWallet>>;
+    sendSetOwner(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         owner: AddressLike;
         queryId?: number;
     }): Promise<void>;
-    sendSetGuardianAddress(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetGuardianAddress(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         guardianAddress: AddressLike;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetManager(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetManager(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         manager: AddressLike;
         queryId?: number;
     }): Promise<void>;
-    sendSetPrivateVault(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetPrivateVault(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         isPrivateVault: boolean;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetWhitelistedMinters(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetWhitelistedMinters(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         whitelistedMinters: AddressLike[];
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetMaxLeverageRatio(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetMaxLeverageRatio(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         maxLeverageRatio: number;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendExecuteOwnerAction(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendExecuteOwnerAction(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         updateIndex: bigint;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendRevertOwnerAction(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendRevertOwnerAction(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         updateIndex: bigint;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetTimelock(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetTimelock(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         timelock: bigint;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetManagementFeeRecipientAddress(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetManagementFeeRecipientAddress(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         managementFeeRecipientAddress: AddressLike;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetProtocolFeeRatePerYear(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetProtocolFeeRatePerYear(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         protocolFeeRatePerYear: number;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetProtocolFeeManagerAddress(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetProtocolFeeManagerAddress(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         protocolFeeManagerAddress: AddressLike;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetFactorialPoolConfig(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetFactorialPoolConfig(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         configs: {
             poolAddress: AddressLike;
             assetAddress: AddressLike;
@@ -124,8 +208,8 @@ export declare class StrategyVaultBase extends ServiceBaseV1 {
             isBorrowable: boolean;
         }[];
     }): Promise<void>;
-    sendSetAssetConfig(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetAssetConfig(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         assetAddress: AddressLike;
         isWhitelisted: boolean;
         isDepositable: boolean;
@@ -133,8 +217,8 @@ export declare class StrategyVaultBase extends ServiceBaseV1 {
         exposureCap: number;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetRFQConfig(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetRFQConfig(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         priceDeviationTolerance: bigint;
         rfqEmitterAddress: AddressLike;
         queryId?: number;
@@ -144,8 +228,8 @@ export declare class StrategyVaultBase extends ServiceBaseV1 {
         vaultAssets: string[];
     }): Promise<Cell>;
     getOracleParams(vaultAddress: AddressLike, additionalAssets?: AddressLike[], allFactorialVaults?: AddressLike[], vaultData?: StrategyVaultState): Promise<Cell>;
-    sendDepositAsset(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendDepositAsset(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         assetAddress: AddressLike;
         amount: bigint;
         queryId?: bigint;
@@ -157,8 +241,62 @@ export declare class StrategyVaultBase extends ServiceBaseV1 {
         forwardPayload: Cell;
         queryId: bigint;
     }>;
-    sendBurnVaultAsset(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    createInternalDepositAsset(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        amount: bigint;
+        queryId?: bigint;
+    }, value?: bigint): Promise<import("../types/messages").InternalMessageInput>;
+    _createInternalDepositAsset(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        amount: bigint;
+        queryId?: bigint;
+    }, value?: bigint): Promise<{
+        opts: {
+            recipient: Address;
+            amount: bigint;
+            response: Address;
+            forwardTonAmount: bigint;
+            forwardPayload: Cell;
+            queryId: bigint;
+        };
+        input: import("../types/messages").InternalMessageInput;
+    }>;
+    _createInternalDepositAssetV1(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        amount: bigint;
+        queryId?: bigint;
+    }, value?: bigint): Promise<{
+        opts: {
+            recipient: Address;
+            amount: bigint;
+            response: Address;
+            forwardTonAmount: bigint;
+            forwardPayload: Cell;
+            queryId: bigint;
+        };
+        input: import("../types/messages").InternalMessageInput;
+    }>;
+    _createInternalDepositAssetV2(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        amount: bigint;
+        queryId?: bigint;
+    }, value?: bigint): Promise<{
+        opts: {
+            recipient: Address;
+            amount: bigint;
+            response: Address;
+            forwardTonAmount: bigint;
+            forwardPayload: Cell;
+            queryId: bigint;
+        };
+        input: import("../types/messages").InternalMessageInput;
+    }>;
+    sendBurnVaultAsset(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         withdrawAssetAddress: AddressLike;
         vaultShareAmountForBurn: bigint;
         queryID?: bigint;
@@ -168,36 +306,314 @@ export declare class StrategyVaultBase extends ServiceBaseV1 {
         forwardPayload: Cell;
         queryId: bigint;
     }>;
-    createInternalDepositAsset(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
-        assetAddress: AddressLike;
-        amount: bigint;
-        queryId?: bigint;
-    }, value?: bigint): Promise<{
-        to: Address | string;
-        value: bigint | string;
-        extracurrency?: import("@ton/core/dist/utils/maybe").Maybe<import("@ton/core").ExtraCurrency>;
-        bounce?: import("@ton/core/dist/utils/maybe").Maybe<boolean>;
-        init?: import("@ton/core/dist/utils/maybe").Maybe<import("@ton/core").StateInit>;
-        body?: import("@ton/core/dist/utils/maybe").Maybe<Cell | string>;
-    }>;
-    createInternalBurnVaultAsset(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    createInternalBurnVaultAsset(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        withdrawAssetAddress: AddressLike;
+        vaultShareAmountForBurn: bigint;
+        queryID?: bigint;
+    }, value?: bigint): Promise<import("../types/messages").InternalMessageInput>;
+    _createInternalBurnVaultAsset(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         withdrawAssetAddress: AddressLike;
         vaultShareAmountForBurn: bigint;
         queryID?: bigint;
     }, value?: bigint): Promise<{
-        to: Address | string;
-        value: bigint | string;
-        extracurrency?: import("@ton/core/dist/utils/maybe").Maybe<import("@ton/core").ExtraCurrency>;
-        bounce?: import("@ton/core/dist/utils/maybe").Maybe<boolean>;
-        init?: import("@ton/core/dist/utils/maybe").Maybe<import("@ton/core").StateInit>;
-        body?: import("@ton/core/dist/utils/maybe").Maybe<Cell | string>;
+        opts: {
+            amount: bigint;
+            response: Address;
+            forwardPayload: Cell;
+            queryId: bigint;
+        };
+        input: import("../types/messages").InternalMessageInput;
+    }>;
+    createInternalDepositQueue(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        amount: bigint;
+        responseAddress?: Address;
+        jettonForwardParams?: {
+            forwardTonAmount?: bigint;
+            forwardPayload?: Cell;
+        };
+        queueItemParams?: VaultResponseOptions;
+        queryId?: bigint;
+        value?: bigint;
+    }): Promise<{
+        opts: {
+            recipient: Address;
+            amount: bigint;
+            response: Address;
+            forwardTonAmount: bigint;
+            forwardPayload: Cell;
+            queryId: bigint;
+        };
+        input: import("../types/messages").InternalMessageInput;
+    }>;
+    sendDepositQueue(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        amount: bigint;
+        forwardParams?: {
+            forwardTonAmount?: bigint;
+            forwardPayload?: Cell;
+        };
+        queueItemParams?: {
+            actionForwardTonAmount?: bigint;
+            forwardTonAmount?: bigint;
+            forwardPayload?: Cell;
+        };
+        queryId?: bigint;
+        value?: bigint;
+    }): Promise<{
+        recipient: Address;
+        amount: bigint;
+        response: Address;
+        forwardTonAmount: bigint;
+        forwardPayload: Cell;
+        queryId: bigint;
+    }>;
+    createInternalWithdrawQueue(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        shareAmount: bigint;
+        assetAddress: AddressLike;
+        responseAddress?: Address;
+        jettonForwardParams?: {
+            forwardTonAmount?: bigint;
+            forwardPayload?: Cell;
+        };
+        queueItemParams?: VaultResponseOptions;
+        queryId?: bigint;
+        value?: bigint;
+    }): Promise<{
+        opts: {
+            amount: bigint;
+            response: Address;
+            forwardPayload: Cell;
+            queryId: bigint;
+        };
+        input: import("../types/messages").InternalMessageInput;
+    }>;
+    sendWithdrawQueue(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        shareAmount: bigint;
+        assetAddress: AddressLike;
+        forwardParams?: {
+            forwardTonAmount?: bigint;
+            forwardPayload?: Cell;
+        };
+        queueItemParams?: {
+            actionForwardTonAmount?: bigint;
+            forwardTonAmount?: bigint;
+            forwardPayload?: Cell;
+        };
+        queryId?: bigint;
+        value?: bigint;
+    }): Promise<{
+        amount: bigint;
+        response: Address;
+        forwardPayload: Cell;
+        queryId: bigint;
+    }>;
+    createInternalCancelDepositQueue(params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        userAddress: AddressLike;
+        queryId?: bigint;
+        value?: bigint;
+    }): Promise<{
+        opts: {
+            to: Address;
+            value: bigint;
+            assetAddress: Address;
+            userAddress: Address;
+            queryId: bigint;
+        };
+        input: {
+            to: Address;
+            value: bigint;
+            body: Cell;
+        };
+    }>;
+    sendCancelDepositQueue(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        userAddress: AddressLike;
+        queryId?: bigint;
+        value?: bigint;
+    }): Promise<{
+        to: Address;
+        value: bigint;
+        assetAddress: Address;
+        userAddress: Address;
+        queryId: bigint;
+    }>;
+    createInternalCancelWithdrawQueue(params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        userAddress: AddressLike;
+        queryId?: bigint;
+        value?: bigint;
+    }): Promise<{
+        opts: {
+            to: Address;
+            value: bigint;
+            assetAddress: Address;
+            userAddress: Address;
+            queryId: bigint;
+        };
+        input: {
+            to: Address;
+            value: bigint;
+            body: Cell;
+        };
+    }>;
+    sendCancelWithdrawQueue(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        userAddress: AddressLike;
+        queryId?: bigint;
+        value?: bigint;
+    }): Promise<{
+        to: Address;
+        value: bigint;
+        assetAddress: Address;
+        userAddress: Address;
+        queryId: bigint;
     }>;
+    createInternalConfirmQueue(params: {
+        strategyVaultAddress: AddressInput;
+        depositAssets: Address[];
+        withdrawAssets: Address[];
+        oracleParams: Cell;
+        value: bigint;
+        queryId?: bigint;
+    }): Promise<{
+        opts: {
+            to: Address;
+            value: bigint;
+            depositAssets: Address[];
+            withdrawAssets: Address[];
+            oracleParams: Cell;
+            queryId: bigint;
+        };
+        input: {
+            to: Address;
+            value: bigint;
+            body: Cell;
+        };
+    }>;
+    sendConfirmQueue(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        depositAssets?: Address[];
+        withdrawAssets?: Address[];
+        oracleParams?: Cell;
+        value?: bigint;
+        queryId?: bigint;
+    }): Promise<void>;
+    createInternalExecuteDepositQueue(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        count?: bigint;
+        value?: bigint;
+        queryId?: bigint;
+    }): Promise<{
+        opts: {
+            to: Address;
+            value: bigint;
+            asset: Address;
+            count: bigint;
+            queryId: bigint;
+        };
+        input: {
+            to: Address;
+            value: bigint;
+            body: Cell;
+        };
+    }>;
+    sendExecuteDepositQueue(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        count?: bigint;
+        value?: bigint;
+        queryId?: bigint;
+    }): Promise<void>;
+    createInternalExecuteWithdrawQueue(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        count?: bigint;
+        value?: bigint;
+        queryId?: bigint;
+    }): Promise<{
+        opts: {
+            to: Address;
+            value: bigint;
+            asset: Address;
+            count: bigint;
+            queryId: bigint;
+        };
+        input: {
+            to: Address;
+            value: bigint;
+            body: Cell;
+        };
+    }>;
+    sendExecuteWithdrawQueue(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        assetAddress: AddressLike;
+        count?: bigint;
+        value?: bigint;
+        queryId?: bigint;
+    }): Promise<void>;
+    sendDepositToVault(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        depositToVault: AddressInput;
+        assetAddress: AddressInput;
+        amount: bigint;
+        value?: bigint;
+        queryId?: bigint;
+    }): Promise<void>;
+    sendWithdrawFromVault(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        withdrawFromVault: AddressInput;
+        withdrawAmount: bigint;
+        assetAddress: AddressInput;
+        value?: bigint;
+        queryId?: bigint;
+    }): Promise<void>;
+    sendDepositToVaultQueue(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        depositToVaultQueue: AddressInput;
+        assetAddress: AddressInput;
+        amount: bigint;
+        value?: bigint;
+        queryId?: bigint;
+    }): Promise<void>;
+    sendWithdrawFromVaultQueue(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        withdrawFromVaultQueue: AddressInput;
+        assetAddress: AddressInput;
+        amount: bigint;
+        value?: bigint;
+        queryId?: bigint;
+    }): Promise<void>;
+    sendDepositToVaultQueueCancel(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        depositToVaultQueue: AddressInput;
+        assetAddress: AddressInput;
+        value?: bigint;
+        queryId?: bigint;
+    }): Promise<void>;
+    sendWithdrawFromVaultQueueCancel(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
+        withdrawFromVaultQueue: AddressInput;
+        assetAddress: AddressInput;
+        value?: bigint;
+        queryId?: bigint;
+    }): Promise<void>;
     getRFQAuctionAddress(strategyVaultAddress: AddressInput, index: bigint): Promise<Address>;
     getRFQAuction(strategyVaultAddress: AddressInput, index: bigint): Promise<OpenedContract<RFQAuction>>;
-    sendCreateAmountRFQ(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendCreateAmountRFQ(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         sellAssetAddress: AddressLike;
         buyAssetAddress: AddressLike;
         sellAssetAmount: bigint;
@@ -208,14 +624,14 @@ export declare class StrategyVaultBase extends ServiceBaseV1 {
         allowBidderCancel: boolean;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendUnwrapWTON(sender: Sender, params: {
+    sendUnwrapWTON(sender: AddressSender, params: {
         senderAddress: AddressLike;
         wtonAddress: AddressLike;
         amount: bigint;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendCreateSlippageRFQ(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendCreateSlippageRFQ(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         sellAssetAddress: AddressLike;
         buyAssetAddress: AddressLike;
         sellAssetAmount: bigint;
@@ -225,43 +641,43 @@ export declare class StrategyVaultBase extends ServiceBaseV1 {
         allowBidderCancel: boolean;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendCancelRFQ(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendCancelRFQ(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         rfqIndex: bigint;
         queryID?: number;
     }, value?: bigint): Promise<void>;
-    sendSupplyToFactorial(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSupplyToFactorial(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         poolAddress: AddressLike;
         assetAddress: AddressLike;
         assetAmount: bigint;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendBorrowFromFactorial(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendBorrowFromFactorial(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         poolAddress: AddressLike;
         assetAddress: AddressLike;
         assetAmount: bigint;
         isShare: boolean;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendRepayToFactorial(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendRepayToFactorial(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         poolAddress: AddressLike;
         assetAddress: AddressLike;
         assetAmount: bigint;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendWithdrawFromFactorial(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendWithdrawFromFactorial(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         poolAddress: AddressLike;
         assetAddress: AddressLike;
         assetAmount: bigint;
         isShare: boolean;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendLiquidateToFactorial(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendLiquidateToFactorial(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         poolAddress: AddressLike;
         borrowerAddress: AddressLike;
         repayAssetAddress: AddressLike;
@@ -326,63 +742,63 @@ export declare class StrategyVaultBase extends ServiceBaseV1 {
         assets: string[];
         vaultAssets: string[];
     }>;
-    sendCollectProtocolFee(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendCollectProtocolFee(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         assetAddress: AddressLike;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendClaimManagementFee(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendClaimManagementFee(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         receiverAddress: AddressLike;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetManagementFeeRatePerYear(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetManagementFeeRatePerYear(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         managementFeeRatePerYear: number;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetDepositCloseTimestamp(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetDepositCloseTimestamp(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         depositCloseTimestamp: bigint;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetWithdrawOpenTimestamp(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetWithdrawOpenTimestamp(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         withdrawOpenTimestamp: bigint;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetGasConfig(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetGasConfig(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         gasConfig: Cell | null;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetOracleConfig(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetOracleConfig(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         oracleConfig: Cell | null;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetWalletCode(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetWalletCode(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         walletCode: Cell;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetDataAggregatorCode(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetDataAggregatorCode(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         dataAggregatorCode: Cell;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetRFQCode(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetRFQCode(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         rfqCode: Cell;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendSetContent(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendSetContent(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         content: Cell;
         queryId?: number;
     }, value?: bigint): Promise<void>;
-    sendUpgradeCode(sender: Sender, params: {
-        strategyVaultAddress: AddressLike;
+    sendUpgradeCode(sender: AddressSender, params: {
+        strategyVaultAddress: AddressInput;
         newCode: Cell;
         queryId?: number;
     }, value?: bigint): Promise<void>;