@affluent-org/sdk 0.0.1

package/dist/services/strategy-vault/index.d.ts

@@ -0,0 +1,2124 @@
+import { AffluentContext } from "../../context";
+import { AddressInput, AddressLike } from "../../contracts/common/type";
+import { AddressSender } from "../../types/sender";
+import { StrategyVaultState } from "../../contracts/vault/strategy-vault";
+import * as owner from "./owner";
+import * as manager from "./manager";
+import * as user from "./user";
+export { sendMsg } from "../../lib/send-msg";
+export { createQueryId } from "../../contracts/vault/strategy-vault/computation";
+export * from "./owner/types";
+export * from "./manager/types";
+export * from "./user/types";
+export { owner, manager, user };
+export declare class StrategyVaultV1 {
+    private ctx;
+    constructor(ctx?: AffluentContext);
+    getVault(strategyVaultAddress: AddressInput): import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    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: import("@ton/core").Address | null;
+        xchainConfig: Record<string, {
+            connected: boolean;
+            xchainAccountAddress: bigint;
+            oftConfig: Map<string, {
+                destinationAddress: import("@ton/core").Address;
+                forwardGas: bigint;
+                forwardPayload?: import("@ton/core").Cell | null;
+                lzTransferFeeRate?: bigint;
+            }> | null;
+            strategyConfig: Map<bigint, {
+                isExecutable: boolean;
+            }> | null;
+            afterStrategyConfig: Map<bigint, {
+                isExecutable: boolean;
+            }> | null;
+            lzGasFee: bigint;
+        }>;
+        xchainUpdateHash: bigint;
+        owner: import("@ton/core").Address;
+        manager: import("@ton/core").Address;
+        assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+        factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+        aggregatorIndex: bigint;
+        content: import("@ton/core").Cell;
+        totalSupply: bigint;
+        oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+        rfqConfig: {
+            priceDeviationTolerance: number;
+            rfqEventEmitterAddress: string | null;
+        } | null;
+        gasConfig: Record<string, bigint> | null;
+        isPrivateVault: boolean;
+        depositCloseTimestamp: number;
+        withdrawOpenTimestamp: number;
+        whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+        lastCollectTime: number;
+        managementFeeRatePerYear: number;
+        protocolFeeRatePerYear: number;
+        collectedManagementFee: bigint;
+        collectedProtocolFee: bigint;
+        rfqCode: import("@ton/core").Cell;
+        walletCode: import("@ton/core").Cell;
+        dataAggregatorCode: import("@ton/core").Cell;
+        protocolFeeManagerAddress: import("@ton/core").Address;
+        rfqIndex: bigint;
+        isExecutingStrategy: boolean;
+        maxLeverageRatio: number;
+        assetWalletDict: Record<string, string>;
+        walletAssetDict: Record<string, string>;
+        managementFeeRecipientAddress: import("@ton/core").Address | null;
+        guardianAddress: import("@ton/core").Address | null;
+        timelock: bigint;
+        pendingOwnerActionIndex: bigint;
+        pendingOwnerActionCount: bigint;
+        pendingOwnerAction: any;
+        getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+        getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+        version: string;
+        address: import("@ton/core").Address;
+        balance: bigint;
+        code: import("@ton/core").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: import("@ton/core").Address;
+        manager: import("@ton/core").Address;
+        assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+        factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+        aggregatorIndex: bigint;
+        content: import("@ton/core").Cell;
+        totalSupply: bigint;
+        oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+        rfqConfig: {
+            priceDeviationTolerance: number;
+            rfqEventEmitterAddress: string | null;
+        } | null;
+        gasConfig: Record<string, bigint> | null;
+        isPrivateVault: boolean;
+        depositCloseTimestamp: number;
+        withdrawOpenTimestamp: number;
+        whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+        lastCollectTime: number;
+        managementFeeRatePerYear: number;
+        protocolFeeRatePerYear: number;
+        collectedManagementFee: bigint;
+        collectedProtocolFee: bigint;
+        rfqCode: import("@ton/core").Cell;
+        walletCode: import("@ton/core").Cell;
+        dataAggregatorCode: import("@ton/core").Cell;
+        protocolFeeManagerAddress: import("@ton/core").Address;
+        rfqIndex: bigint;
+        isExecutingStrategy: boolean;
+        maxLeverageRatio: number;
+        assetWalletDict: Record<string, string>;
+        walletAssetDict: Record<string, string>;
+        managementFeeRecipientAddress: import("@ton/core").Address | null;
+        guardianAddress: import("@ton/core").Address | null;
+        timelock: bigint;
+        pendingOwnerActionIndex: bigint;
+        pendingOwnerActionCount: bigint;
+        pendingOwnerAction: any;
+        getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+        getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+        version: string;
+        address: import("@ton/core").Address;
+        balance: bigint;
+        code: import("@ton/core").Cell;
+    }>;
+    getVaultWallet(strategyVaultAddress: AddressInput, accountAddress: AddressLike): Promise<import("@ton/core").OpenedContract<import("../..").JettonWallet>>;
+    getRFQAuctionAddress(strategyVaultAddress: AddressInput, index: bigint): Promise<import("@ton/core").Address>;
+    getRFQAuction(strategyVaultAddress: AddressInput, index: bigint): Promise<import("@ton/core").OpenedContract<import("../..").RFQAuction>>;
+    isVaultAsset(address: AddressInput): Promise<boolean>;
+    splitPureAndVaultAsset(addresses: AddressInput[]): Promise<{
+        vaultAssetAddresses: string[];
+        pureAssetAddresses: string[];
+    }>;
+    getOracleParams(vaultAddress: AddressLike, vaultData?: StrategyVaultState, extraAssets?: {
+        assets: string[];
+        vaultAssets: string[];
+    }): Promise<import("@ton/core").Cell>;
+    private getCompositeOracle;
+    getVaultPrice(vaultAddress: AddressLike, vaultData?: StrategyVaultState): Promise<bigint>;
+    getAllAssetPrices(vaultAddress: AddressLike, vaultData?: StrategyVaultState): Promise<import("../composite-oracle").Prices>;
+    getTotalValue(vaultAddress: AddressLike, vaultData?: StrategyVaultState): Promise<bigint>;
+    sendSetOwner(sender: AddressSender, params: owner.SetOwnerParams): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetGuardianAddress(sender: AddressSender, params: owner.SetGuardianAddressParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetManager(sender: AddressSender, params: owner.SetManagerParams): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetPrivateVault(sender: AddressSender, params: owner.SetPrivateVaultParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetWhitelistedMinters(sender: AddressSender, params: owner.SetWhitelistedMintersParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        mintersDict: import("@ton/core").Dictionary<import("@ton/core").Address, any>;
+    }>;
+    sendSetMaxLeverageRatio(sender: AddressSender, params: owner.SetMaxLeverageRatioParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendExecuteOwnerAction(sender: AddressSender, params: owner.ExecuteOwnerActionParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendRevertOwnerAction(sender: AddressSender, params: owner.RevertOwnerActionParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetTimelock(sender: AddressSender, params: owner.SetTimelockParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetManagementFeeRecipientAddress(sender: AddressSender, params: owner.SetManagementFeeRecipientAddressParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetProtocolFeeRatePerYear(sender: AddressSender, params: owner.SetProtocolFeeRatePerYearParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetProtocolFeeManagerAddress(sender: AddressSender, params: owner.SetProtocolFeeManagerAddressParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetFactorialPoolConfig(sender: AddressSender, params: owner.SetFactorialPoolConfigParams): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        factorialPoolConfig: import("@ton/core").Cell;
+    }>;
+    sendSetAssetConfig(sender: AddressSender, params: owner.SetAssetConfigParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetRFQConfig(sender: AddressSender, params: owner.SetRFQConfigParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetManagementFeeRatePerYear(sender: AddressSender, params: owner.SetManagementFeeRatePerYearParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetDepositCloseTimestamp(sender: AddressSender, params: owner.SetDepositCloseTimestampParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetWithdrawOpenTimestamp(sender: AddressSender, params: owner.SetWithdrawOpenTimestampParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetGasConfig(sender: AddressSender, params: owner.SetGasConfigParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetOracleConfig(sender: AddressSender, params: owner.SetOracleConfigParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetWalletCode(sender: AddressSender, params: owner.SetWalletCodeParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetDataAggregatorCode(sender: AddressSender, params: owner.SetDataAggregatorCodeParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetRFQCode(sender: AddressSender, params: owner.SetRFQCodeParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSetContent(sender: AddressSender, params: owner.SetContentParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendUpgradeCode(sender: AddressSender, params: owner.UpgradeCodeParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendCollectProtocolFee(sender: AddressSender, params: owner.CollectProtocolFeeParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendClaimManagementFee(sender: AddressSender, params: owner.ClaimManagementFeeParams, value?: bigint): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendSupplyToFactorial(sender: AddressSender, params: manager.SupplyToFactorialParams, value?: bigint): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        vaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        poolAddress: import("@ton/core").Address;
+        assetAddress: import("@ton/core").Address;
+    }>;
+    sendBorrowFromFactorial(sender: AddressSender, params: manager.BorrowFromFactorialParams, value?: bigint): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        vaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        oraclePayload: import("@ton/core").Cell;
+        oracleCalculateGas: bigint;
+        poolAddress: import("@ton/core").Address;
+        assetAddress: import("@ton/core").Address;
+    }>;
+    sendRepayToFactorial(sender: AddressSender, params: manager.RepayToFactorialParams, value?: bigint): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        vaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        poolAddress: import("@ton/core").Address;
+        assetAddress: import("@ton/core").Address;
+    }>;
+    sendWithdrawFromFactorial(sender: AddressSender, params: manager.WithdrawFromFactorialParams, value?: bigint): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        pool: import("@ton/core").OpenedContract<import("../..").Pool>;
+        vaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        poolData: import("../..").PoolState;
+        poolOraclePayload: import("@ton/core").Cell;
+        poolAddress: import("@ton/core").Address;
+        assetAddress: import("@ton/core").Address;
+    }>;
+    sendLiquidateToFactorial(sender: AddressSender, params: manager.LiquidateToFactorialParams, value?: bigint): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        vaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        oraclePayload: import("@ton/core").Cell;
+        oracleCalculateGas: bigint;
+        poolAddress: import("@ton/core").Address;
+        borrowerAddress: import("@ton/core").Address;
+        repayAssetAddress: import("@ton/core").Address;
+        seizeAssetAddress: import("@ton/core").Address;
+    }>;
+    sendDepositToVault(sender: AddressSender, params: manager.DepositToVaultParams): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        strategyVaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        targetVaultType: import("../../context").ShareVaultType | import("../../context").StrategyVaultType;
+        oracleParams: import("@ton/core").Cell;
+        targetVaultOracleParams: import("@ton/core").Cell | undefined;
+        forwardTonAmount: bigint;
+        vaultStrategyGas: bigint;
+    }>;
+    sendWithdrawFromVault(sender: AddressSender, params: manager.WithdrawFromVaultParams): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        strategyVaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        targetVaultType: import("../../context").ShareVaultType | import("../../context").StrategyVaultType;
+        oracleParams: import("@ton/core").Cell;
+        targetVaultOracleParams: import("@ton/core").Cell | undefined;
+        forwardTonAmount: bigint;
+        vaultStrategyGas: bigint;
+    }>;
+    sendDepositToVaultQueue(sender: AddressSender, params: manager.DepositToVaultQueueParams): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        strategyVaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        targetVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        targetVaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        oracleParams: import("@ton/core").Cell;
+        vaultStrategyGas: bigint;
+        forwardTonAmount: bigint;
+    }>;
+    sendWithdrawFromVaultQueue(sender: AddressSender, params: manager.WithdrawFromVaultQueueParams): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        strategyVaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        targetVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        targetVaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        oracleParams: import("@ton/core").Cell;
+        vaultStrategyGas: bigint;
+        forwardTonAmount: bigint;
+    }>;
+    sendDepositToVaultQueueCancel(sender: AddressSender, params: manager.DepositToVaultQueueCancelParams): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendWithdrawFromVaultQueueCancel(sender: AddressSender, params: manager.WithdrawFromVaultQueueCancelParams): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendCreateAmountRFQ(sender: AddressSender, params: manager.CreateAmountRFQParams, value?: bigint): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        vaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        rfqIndex: bigint;
+        rfqAuctionAddress: import("@ton/core").Address;
+        sellAssetAddress: import("@ton/core").Address;
+        buyAssetAddress: import("@ton/core").Address;
+        sellAssetRFQWallet: import("@ton/core").Address;
+        buyAssetRFQWallet: import("@ton/core").Address;
+        oracleParams: import("@ton/core").Cell;
+        oracleCalculateGas: bigint;
+    }>;
+    sendCreateSlippageRFQ(sender: AddressSender, params: manager.CreateSlippageRFQParams, value?: bigint): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        vaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        rfqIndex: bigint;
+        rfqAuctionAddress: import("@ton/core").Address;
+        sellAssetAddress: import("@ton/core").Address;
+        buyAssetAddress: import("@ton/core").Address;
+        sellAssetRFQWallet: import("@ton/core").Address;
+        buyAssetRFQWallet: import("@ton/core").Address;
+        oracleParams: import("@ton/core").Cell;
+        oracleCalculateGas: bigint;
+        slippageBoundConfig: import("../../contracts/vault/strategy-vault/computation").SlippageConfig;
+    }>;
+    sendCancelRFQ(sender: AddressSender, params: manager.CancelRFQParams, value?: bigint): Promise<{
+        strategyVault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+    }>;
+    sendUnwrapWTON(sender: AddressSender, params: manager.UnwrapWTONParams, value?: bigint): Promise<void>;
+    sendConfirmQueue(sender: AddressSender, params: manager.SendConfirmQueueParams): Promise<{
+        vault: import("@ton/core").OpenedContract<import("../../contracts/vault/strategy-vault").StrategyVault>;
+        vaultData: {
+            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: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").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: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        to: import("@ton/core").Address;
+        value: bigint;
+        depositAssets: import("@ton/core").Address[];
+        withdrawAssets: import("@ton/core").Address[];
+        oracleParams: import("@ton/core").Cell;
+        queryId: bigint;
+    }>;
+    sendExecuteDepositQueue(sender: AddressSender, params: manager.ExecuteDepositQueueParams): Promise<{
+        to: import("@ton/core").Address;
+        value: bigint;
+        asset: import("@ton/core").Address;
+        count: bigint;
+        queryId: bigint;
+    }>;
+    sendExecuteWithdrawQueue(sender: AddressSender, params: manager.ExecuteWithdrawQueueParams): Promise<{
+        to: import("@ton/core").Address;
+        value: bigint;
+        asset: import("@ton/core").Address;
+        count: bigint;
+        queryId: bigint;
+    }>;
+    sendDepositAsset(sender: AddressSender, params: user.DepositAssetParams, value?: bigint): Promise<{
+        recipient: import("@ton/core").Address;
+        amount: bigint;
+        response: import("@ton/core").Address;
+        forwardTonAmount: bigint;
+        forwardPayload: import("@ton/core").Cell;
+        queryId: bigint;
+    }>;
+    sendBurnVaultAsset(sender: AddressSender, params: user.BurnVaultAssetParams, value?: bigint): Promise<{
+        amount: bigint;
+        response: import("@ton/core").Address;
+        forwardPayload: import("@ton/core").Cell;
+        queryId: bigint;
+    }>;
+    sendDepositQueue(sender: AddressSender, params: user.CreateDepositQueueParams): Promise<{
+        recipient: import("@ton/core").Address;
+        amount: bigint;
+        response: import("@ton/core").Address;
+        forwardTonAmount: bigint;
+        forwardPayload: import("@ton/core").Cell;
+        queryId: bigint;
+    }>;
+    sendWithdrawQueue(sender: AddressSender, params: user.CreateWithdrawQueueParams): Promise<{
+        amount: bigint;
+        response: import("@ton/core").Address;
+        forwardPayload: import("@ton/core").Cell;
+        queryId: bigint;
+    }>;
+    sendCancelDepositQueue(sender: AddressSender, params: user.CancelQueueParams): Promise<{
+        to: import("@ton/core").Address;
+        value: bigint;
+        assetAddress: import("@ton/core").Address;
+        userAddress: import("@ton/core").Address;
+        queryId: bigint;
+    }>;
+    sendCancelWithdrawQueue(sender: AddressSender, params: user.CancelQueueParams): Promise<{
+        to: import("@ton/core").Address;
+        value: bigint;
+        assetAddress: import("@ton/core").Address;
+        userAddress: import("@ton/core").Address;
+        queryId: bigint;
+    }>;
+}