@affluent-org/sdk 0.0.1

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

@@ -0,0 +1,1968 @@
+import { Address, Cell } from "@ton/core";
+import { AffluentContext } from "../../../context";
+import { Pool } from "../../../contracts/core/pool";
+import { StrategyVault } from "../../../contracts/vault/strategy-vault";
+import { AddressSender } from "../../../types/sender";
+import { SupplyToFactorialParams, BorrowFromFactorialParams, RepayToFactorialParams, WithdrawFromFactorialParams, LiquidateToFactorialParams, DepositToVaultParams, WithdrawFromVaultParams, DepositToVaultQueueParams, WithdrawFromVaultQueueParams, DepositToVaultQueueCancelParams, WithdrawFromVaultQueueCancelParams, CreateAmountRFQParams, CreateSlippageRFQParams, CancelRFQParams, UnwrapWTONParams, SendConfirmQueueParams, ExecuteDepositQueueParams, ExecuteWithdrawQueueParams } from "./types";
+export * from "./types";
+export declare function createSupplyToFactorialMsg(ctx: AffluentContext, sender: AddressSender, params: SupplyToFactorialParams, value?: bigint): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        poolAddress: Address;
+        assetAddress: Address;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createBorrowFromFactorialMsg(ctx: AffluentContext, sender: AddressSender, params: BorrowFromFactorialParams, value?: bigint): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        oraclePayload: Cell;
+        oracleCalculateGas: bigint;
+        poolAddress: Address;
+        assetAddress: Address;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createRepayToFactorialMsg(ctx: AffluentContext, sender: AddressSender, params: RepayToFactorialParams, value?: bigint): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        poolAddress: Address;
+        assetAddress: Address;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createWithdrawFromFactorialMsg(ctx: AffluentContext, sender: AddressSender, params: WithdrawFromFactorialParams, value?: bigint): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<StrategyVault>;
+        pool: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        poolData: import("../../..").PoolState;
+        poolOraclePayload: Cell;
+        poolAddress: Address;
+        assetAddress: Address;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createLiquidateToFactorialMsg(ctx: AffluentContext, sender: AddressSender, params: LiquidateToFactorialParams, value?: bigint): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        oraclePayload: Cell;
+        oracleCalculateGas: bigint;
+        poolAddress: Address;
+        borrowerAddress: Address;
+        repayAssetAddress: Address;
+        seizeAssetAddress: Address;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createDepositToVaultMsg(ctx: AffluentContext, sender: AddressSender, params: DepositToVaultParams): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        targetVaultType: import("../../../context").ShareVaultType | import("../../../context").StrategyVaultType;
+        oracleParams: Cell;
+        targetVaultOracleParams: Cell | undefined;
+        forwardTonAmount: bigint;
+        vaultStrategyGas: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createWithdrawFromVaultMsg(ctx: AffluentContext, sender: AddressSender, params: WithdrawFromVaultParams): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        targetVaultType: import("../../../context").ShareVaultType | import("../../../context").StrategyVaultType;
+        oracleParams: Cell;
+        targetVaultOracleParams: Cell | undefined;
+        forwardTonAmount: bigint;
+        vaultStrategyGas: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createDepositToVaultQueueMsg(ctx: AffluentContext, sender: AddressSender, params: DepositToVaultQueueParams): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        targetVault: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        oracleParams: Cell;
+        vaultStrategyGas: bigint;
+        forwardTonAmount: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createWithdrawFromVaultQueueMsg(ctx: AffluentContext, sender: AddressSender, params: WithdrawFromVaultQueueParams): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        targetVault: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        oracleParams: Cell;
+        vaultStrategyGas: bigint;
+        forwardTonAmount: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createDepositToVaultQueueCancelMsg(ctx: AffluentContext, sender: AddressSender, params: DepositToVaultQueueCancelParams): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createWithdrawFromVaultQueueCancelMsg(ctx: AffluentContext, sender: AddressSender, params: WithdrawFromVaultQueueCancelParams): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createAmountRFQMsg(ctx: AffluentContext, sender: AddressSender, params: CreateAmountRFQParams, value?: bigint): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        rfqIndex: bigint;
+        rfqAuctionAddress: Address;
+        sellAssetAddress: Address;
+        buyAssetAddress: Address;
+        sellAssetRFQWallet: Address;
+        buyAssetRFQWallet: Address;
+        oracleParams: Cell;
+        oracleCalculateGas: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createSlippageRFQMsg(ctx: AffluentContext, sender: AddressSender, params: CreateSlippageRFQParams, value?: bigint): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        rfqIndex: bigint;
+        rfqAuctionAddress: Address;
+        sellAssetAddress: Address;
+        buyAssetAddress: Address;
+        sellAssetRFQWallet: Address;
+        buyAssetRFQWallet: Address;
+        oracleParams: Cell;
+        oracleCalculateGas: bigint;
+        slippageBoundConfig: import("../../../contracts/vault/strategy-vault/computation").SlippageConfig;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createCancelRFQMsg(ctx: AffluentContext, sender: AddressSender, params: CancelRFQParams, value?: bigint): Promise<{
+    opts: {
+        strategyVault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function sendUnwrapWTON(ctx: AffluentContext, sender: AddressSender, params: UnwrapWTONParams, value?: bigint): Promise<void>;
+export declare function createConfirmQueueMsg(ctx: AffluentContext, sender: AddressSender, params: SendConfirmQueueParams): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<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: Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: Address;
+                    forwardGas: bigint;
+                    forwardPayload?: Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: Address;
+            manager: Address;
+            assets: Record<string, import("../../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: Cell;
+            totalSupply: bigint;
+            oracleConfig: 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<Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: Cell;
+            walletCode: Cell;
+            dataAggregatorCode: Cell;
+            protocolFeeManagerAddress: Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: Address | null;
+            guardianAddress: Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: Address, assetAddress: Address) => import("../../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: Address) => import("../../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: Address;
+            balance: bigint;
+            code: Cell;
+        };
+        to: Address;
+        value: bigint;
+        depositAssets: Address[];
+        withdrawAssets: Address[];
+        oracleParams: Cell;
+        queryId: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createExecuteDepositQueueMsg(ctx: AffluentContext, sender: AddressSender, params: ExecuteDepositQueueParams): Promise<{
+    opts: {
+        to: Address;
+        value: bigint;
+        asset: Address;
+        count: bigint;
+        queryId: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createExecuteWithdrawQueueMsg(ctx: AffluentContext, sender: AddressSender, params: ExecuteWithdrawQueueParams): Promise<{
+    opts: {
+        to: Address;
+        value: bigint;
+        asset: Address;
+        count: bigint;
+        queryId: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;