@affluent-org/sdk 0.0.1

package/dist/contracts/vault/strategy-vault/index.js

@@ -0,0 +1,406 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategyVault = exports.strategyVaultConfigToCell = void 0;
+const core_1 = require("@ton/core");
+const constants_1 = require("./constants");
+const codec_1 = require("./codec");
+Object.defineProperty(exports, "strategyVaultConfigToCell", { enumerable: true, get: function () { return codec_1.strategyVaultConfigToCell; } });
+class StrategyVault {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    // --- Backward-compatible static re-exports ---
+    static Constants = constants_1.Constants;
+    static Op = constants_1.Op;
+    static Error = constants_1.ErrorCodes;
+    static GasKey = constants_1.GasKey;
+    static InteractiveVaultTypes = constants_1.InteractiveVaultTypes;
+    static Dictionary = { Values: codec_1.DictionaryValues };
+    // --- Config serializers ---
+    static strategyVaultConfigToCell = codec_1.strategyVaultConfigToCell;
+    static strategyVaultConfigToCellV1 = codec_1.strategyVaultConfigToCellV1;
+    static strategyVaultConfigToCellV2 = codec_1.strategyVaultConfigToCellV2;
+    // --- Utility ---
+    static createRFQConfig = codec_1.createRFQConfig;
+    static getOpName = codec_1.getOpName;
+    static getErrorName = codec_1.getErrorName;
+    static createInteractiveVaultDict = codec_1.createInteractiveVaultDict;
+    // --- Payload creators ---
+    static createDepositPayloadV1 = codec_1.createDepositPayloadV1;
+    static createDepositPayload = codec_1.createDepositPayload;
+    static createWithdrawPayload = codec_1.createWithdrawPayload;
+    static createDepositQueuePayload = codec_1.createDepositQueuePayload;
+    static createWithdrawQueuePayload = codec_1.createWithdrawQueuePayload;
+    static createExecuteXChainStrategyPayload = codec_1.createExecuteXChainStrategyPayload;
+    // --- Message body creators ---
+    static createInitializeMsgBody = codec_1.createInitializeMsgBody;
+    static createExecuteStrategyMsgBody = codec_1.createExecuteStrategyMsgBody;
+    static createLiquidateToFactorialMsgBody = codec_1.createLiquidateToFactorialMsgBody;
+    static createSupplyToFactorialMsgBody = codec_1.createSupplyToFactorialMsgBody;
+    static createWithdrawFromFactorialMsgBody = codec_1.createWithdrawFromFactorialMsgBody;
+    static createBorrowFromFactorialMsgBody = codec_1.createBorrowFromFactorialMsgBody;
+    static createRepayToFactorialMsgBody = codec_1.createRepayToFactorialMsgBody;
+    static createCreateRFQMsgBody = codec_1.createCreateRFQMsgBody;
+    static createCancelRFQMsgBody = codec_1.createCancelRFQMsgBody;
+    static createDepositToVaultMsgBody = codec_1.createDepositToVaultMsgBody;
+    static createSetAssetConfigMsgBody = codec_1.createSetAssetConfigMsgBody;
+    static createSetFactorialPoolConfigMsgBody = codec_1.createSetFactorialPoolConfigMsgBody;
+    static createClaimManagementFeeMsgBody = codec_1.createClaimManagementFeeMsgBody;
+    static createClaimProtocolFeeMsgBody = codec_1.createClaimProtocolFeeMsgBody;
+    static createSetOwnerAddressMsgBody = codec_1.createSetOwnerAddressMsgBody;
+    static createSetManagementFeeRatePerYearMsgBody = codec_1.createSetManagementFeeRatePerYearMsgBody;
+    static createSetMaxLeverageRatioMsgBody = codec_1.createSetMaxLeverageRatioMsgBody;
+    static createSetRFQConfigMsgBody = codec_1.createSetRFQConfigMsgBody;
+    static createSetOracleConfigMsgBody = codec_1.createSetOracleConfigMsgBody;
+    static createSetWalletCodeMsgBody = codec_1.createSetWalletCodeMsgBody;
+    static createSetDataAggregatorCodeMsgBody = codec_1.createSetDataAggregatorCodeMsgBody;
+    static createSetRFQCodeMsgBody = codec_1.createSetRFQCodeMsgBody;
+    static createSetContentMsgBody = codec_1.createSetContentMsgBody;
+    static createUpgradeCodeMsgBody = codec_1.createUpgradeCodeMsgBody;
+    static createSetManagerAddressMsgBody = codec_1.createSetManagerAddressMsgBody;
+    static createSetPrivateVaultMsgBody = codec_1.createSetPrivateVaultMsgBody;
+    static createSetDepositCloseTimestampMsgBody = codec_1.createSetDepositCloseTimestampMsgBody;
+    static createSetWithdrawOpenTimestampMsgBody = codec_1.createSetWithdrawOpenTimestampMsgBody;
+    static createSetWhitelistedMintersMsgBody = codec_1.createSetWhitelistedMintersMsgBody;
+    static createSetGasConfigMsgBody = codec_1.createSetGasConfigMsgBody;
+    static createExecuteOwnerActionMsgBody = codec_1.createExecuteOwnerActionMsgBody;
+    static createRevertOwnerActionMsgBody = codec_1.createRevertOwnerActionMsgBody;
+    static createSetGuardianAddressMsgBody = codec_1.createSetGuardianAddressMsgBody;
+    static createSetTimelockMsgBody = codec_1.createSetTimelockMsgBody;
+    static createSetManagementFeeRecipientAddressMsgBody = codec_1.createSetManagementFeeRecipientAddressMsgBody;
+    static createSetProtocolFeeRatePerYearMsgBody = codec_1.createSetProtocolFeeRatePerYearMsgBody;
+    static createSetProtocolFeeManagerAddressMsgBody = codec_1.createSetProtocolFeeManagerAddressMsgBody;
+    static createSetXChainConnectorAddressMsgBody = codec_1.createSetXChainConnectorAddressMsgBody;
+    static createSetXChainConfigMsgBody = codec_1.createSetXChainConfigMsgBody;
+    static createRequestEidConnectionMsgBody = codec_1.createRequestEidConnectionMsgBody;
+    // --- Message body parsers ---
+    static parseInitializeMsgBody = codec_1.parseInitializeMsgBody;
+    static parseExecuteStrategyMsgBody = codec_1.parseExecuteStrategyMsgBody;
+    static parseLiquidateToFactorialMsgBody = codec_1.parseLiquidateToFactorialMsgBody;
+    static parseSupplyToFactorialMsgBody = codec_1.parseSupplyToFactorialMsgBody;
+    static parseWithdrawFromFactorialMsgBody = codec_1.parseWithdrawFromFactorialMsgBody;
+    static parseBorrowFromFactorialMsgBody = codec_1.parseBorrowFromFactorialMsgBody;
+    static parseRepayToFactorialMsgBody = codec_1.parseRepayToFactorialMsgBody;
+    static parseCreateRFQMsgBody = codec_1.parseCreateRFQMsgBody;
+    static parseCancelRFQMsgBody = codec_1.parseCancelRFQMsgBody;
+    static parseSetAssetConfigMsgBody = codec_1.parseSetAssetConfigMsgBody;
+    static parseSetFactorialPoolConfigMsgBody = codec_1.parseSetFactorialPoolConfigMsgBody;
+    static parseClaimManagementFeeMsgBody = codec_1.parseClaimManagementFeeMsgBody;
+    static parseClaimProtocolFeeMsgBody = codec_1.parseClaimProtocolFeeMsgBody;
+    static parseSetOwnerAddressMsgBody = codec_1.parseSetOwnerAddressMsgBody;
+    static parseSetManagementFeeRatePerYearMsgBody = codec_1.parseSetManagementFeeRatePerYearMsgBody;
+    static parseSetMaxLeverageRatioMsgBody = codec_1.parseSetMaxLeverageRatioMsgBody;
+    static parseSetRFQConfigMsgBody = codec_1.parseSetRFQConfigMsgBody;
+    static parseSetOracleConfigMsgBody = codec_1.parseSetOracleConfigMsgBody;
+    static parseSetWalletCodeMsgBody = codec_1.parseSetWalletCodeMsgBody;
+    static parseSetDataAggregatorCodeMsgBody = codec_1.parseSetDataAggregatorCodeMsgBody;
+    static parseSetRFQCodeMsgBody = codec_1.parseSetRFQCodeMsgBody;
+    static parseSetContentMsgBody = codec_1.parseSetContentMsgBody;
+    static parseUpgradeCodeMsgBody = codec_1.parseUpgradeCodeMsgBody;
+    static parseSetManagerAddressMsgBody = codec_1.parseSetManagerAddressMsgBody;
+    static parseSetPrivateVaultMsgBody = codec_1.parseSetPrivateVaultMsgBody;
+    static parseSetDepositCloseTimestampMsgBody = codec_1.parseSetDepositCloseTimestampMsgBody;
+    static parseSetWithdrawOpenTimestampMsgBody = codec_1.parseSetWithdrawOpenTimestampMsgBody;
+    static parseSetWhitelistedMintersMsgBody = codec_1.parseSetWhitelistedMintersMsgBody;
+    static parseSetGasConfigMsgBody = codec_1.parseSetGasConfigMsgBody;
+    static parseExecuteOwnerActionMsgBody = codec_1.parseExecuteOwnerActionMsgBody;
+    static parseRevertOwnerActionMsgBody = codec_1.parseRevertOwnerActionMsgBody;
+    static parseSetGuardianAddressMsgBody = codec_1.parseSetGuardianAddressMsgBody;
+    static parseSetTimelockMsgBody = codec_1.parseSetTimelockMsgBody;
+    static parseSetManagementFeeRecipientAddressMsgBody = codec_1.parseSetManagementFeeRecipientAddressMsgBody;
+    static parseSetProtocolFeeRatePerYearMsgBody = codec_1.parseSetProtocolFeeRatePerYearMsgBody;
+    static parseSetProtocolFeeManagerAddressMsgBody = codec_1.parseSetProtocolFeeManagerAddressMsgBody;
+    static parseDepositQueueMsgBody = codec_1.parseDepositQueueMsgBody;
+    static parseCancelDepositQueueMsgBody = codec_1.parseCancelDepositQueueMsgBody;
+    static parseExecuteDepositQueueMsgBody = codec_1.parseExecuteDepositQueueMsgBody;
+    static parseWithdrawQueueMsgBody = codec_1.parseWithdrawQueueMsgBody;
+    static parseCancelWithdrawQueueMsgBody = codec_1.parseCancelWithdrawQueueMsgBody;
+    static parseExecuteWithdrawQueueMsgBody = codec_1.parseExecuteWithdrawQueueMsgBody;
+    static parseUserQueueLog = codec_1.parseUserQueueLog;
+    static parseConfirmQueueLog = codec_1.parseConfirmQueueLog;
+    static parseQueueBatchExecuteLog = codec_1.parseQueueBatchExecuteLog;
+    // --- Vault data parsers ---
+    static parseVaultData = codec_1.parseVaultData;
+    static parseVaultDataV1 = codec_1.parseVaultDataV1;
+    static parseVaultDataV2 = codec_1.parseVaultDataV2;
+    static parseRFQConfig = codec_1.parseRFQConfig;
+    static parseGasConfig = codec_1.parseGasConfig;
+    static parseXChainOftConfig = codec_1.parseXChainOftConfig;
+    static parseXChainStrategyConfig = codec_1.parseXChainStrategyConfig;
+    // --- Static factory methods ---
+    static emptyGasDictionary() {
+        const GAS_KEY_LENGTH = 8;
+        return core_1.Dictionary.empty(core_1.Dictionary.Keys.Uint(GAS_KEY_LENGTH), core_1.Dictionary.Values.BigVarUint(4));
+    }
+    static createFromAddress(address) {
+        return new StrategyVault(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = (0, codec_1.strategyVaultConfigToCell)(config);
+        const init = { code, data };
+        return new StrategyVault((0, core_1.contractAddress)(workchain, init), init);
+    }
+    static createFactorialPoolConfig(params) {
+        const poolDictionary = core_1.Dictionary.empty(core_1.Dictionary.Keys.Address(), codec_1.DictionaryValues.FactorialPool());
+        for (let param of params) {
+            const [poolAddress, assetAddress, isSupplyable, isBorrowable] = param;
+            poolDictionary.set(poolAddress, {
+                ...poolDictionary.get(poolAddress),
+                [assetAddress.toString()]: {
+                    supply: 0n,
+                    borrow: 0n,
+                    isSupplyable: isSupplyable,
+                    isBorrowable: isBorrowable,
+                },
+            });
+        }
+        return poolDictionary;
+    }
+    static createFactorialPoolUpdateConfig(params) {
+        const poolDictionary = core_1.Dictionary.empty(core_1.Dictionary.Keys.Address(), codec_1.DictionaryValues.UpdateFactorialPool());
+        for (let param of params) {
+            const [poolAddress, assetAddress, isSupplyable, isBorrowable] = param;
+            poolDictionary.set(poolAddress, {
+                ...poolDictionary.get(poolAddress),
+                [assetAddress.toString()]: {
+                    isSupplyable: isSupplyable,
+                    isBorrowable: isBorrowable,
+                },
+            });
+        }
+        return poolDictionary;
+    }
+    static createXChainOftConfig(assets) {
+        const dict = core_1.Dictionary.empty(core_1.Dictionary.Keys.Address(), codec_1.DictionaryValues.XChainOftConfig());
+        for (const [address, config] of assets) {
+            dict.set(address, config);
+        }
+        return (0, core_1.beginCell)().storeDictDirect(dict).endCell();
+    }
+    static createXChainStrategyConfig(actions) {
+        const dict = core_1.Dictionary.empty(core_1.Dictionary.Keys.BigUint(256), codec_1.DictionaryValues.XChainStrategyConfig());
+        for (const [command, config] of actions) {
+            dict.set(command, config);
+        }
+        return (0, core_1.beginCell)().storeDictDirect(dict).endCell();
+    }
+    static createAssetConfig(params) {
+        const assetDictionary = core_1.Dictionary.empty(core_1.Dictionary.Keys.Address(), codec_1.DictionaryValues.AssetV2());
+        for (let param of params) {
+            const [assetAddress, isWhitelisted, isDepositable, isWithdrawable, exposureCap, isDepositQueueActivated, isWithdrawQueueActivated,] = param;
+            assetDictionary.set(assetAddress, {
+                isWhitelisted: isWhitelisted,
+                isDepositable: isDepositable,
+                isWithdrawable: isWithdrawable,
+                isDepositQueueActivated: isDepositQueueActivated ?? isDepositable,
+                isWithdrawQueueActivated: isWithdrawQueueActivated ?? isWithdrawable,
+                exposureCap: exposureCap,
+                cash: 0n,
+                balance: 0n,
+            });
+        }
+        return assetDictionary;
+    }
+    static calcQueueResistGas(vaultData, response, isFirst = true) {
+        const { actionForwardTonAmount = 0n, jettonForwardTonAmount = 0n } = response ?? {};
+        const addQueueItemGas = vaultData.gasConfig[constants_1.GasKey.AddQueueItem];
+        const executeQueueItemGas = isFirst ? vaultData.gasConfig[constants_1.GasKey.ExecuteQueueItem] : 0n;
+        const jettonTransferGas = vaultData.gasConfig[constants_1.GasKey.JettonTransfer];
+        const forwardTonAmount = // TODO function
+         addQueueItemGas + 2n * actionForwardTonAmount + executeQueueItemGas + jettonTransferGas + jettonForwardTonAmount;
+        return forwardTonAmount;
+    }
+    // --- Message body creators ---
+    static createCancelDepositQueueBody(opts) {
+        return (0, core_1.beginCell)()
+            .storeUint(constants_1.Op.CancelDepositQueue, 32)
+            .storeUint(opts.queryId, 64)
+            .storeAddress(opts.assetAddress)
+            .storeAddress(opts.userAddress)
+            .endCell();
+    }
+    static createExecuteDepositQueueBody(opts) {
+        if (opts.count > 50n) {
+            throw new Error("count cannot be greater than 50");
+        }
+        return (0, core_1.beginCell)()
+            .storeUint(constants_1.Op.ExecuteDepositQueue, 32)
+            .storeUint(opts.queryId, 64)
+            .storeAddress(opts.asset)
+            .storeCoins(opts.count)
+            .endCell();
+    }
+    static createCancelWithdrawQueueBody(opts) {
+        return (0, core_1.beginCell)()
+            .storeUint(constants_1.Op.CancelWithdrawQueue, 32)
+            .storeUint(opts.queryId ?? 0, 64)
+            .storeAddress(opts.assetAddress)
+            .storeAddress(opts.userAddress)
+            .endCell();
+    }
+    static createExecuteWithdrawQueueBody(opts) {
+        if (opts.count > 50n) {
+            throw new Error("count cannot be greater than 50");
+        }
+        return (0, core_1.beginCell)()
+            .storeUint(constants_1.Op.ExecuteWithdrawQueue, 32)
+            .storeUint(opts.queryId, 64)
+            .storeAddress(opts.asset)
+            .storeCoins(opts.count)
+            .endCell();
+    }
+    static createConfirmQueueBody(opts) {
+        const depositDict = opts.depositAssets.reduce((acc, asset) => acc.set(asset, null), core_1.Dictionary.empty(core_1.Dictionary.Keys.Address(), codec_1.DictionaryValues.Empty()));
+        const withdrawDict = opts.withdrawAssets.reduce((acc, asset) => acc.set(asset, null), core_1.Dictionary.empty(core_1.Dictionary.Keys.Address(), codec_1.DictionaryValues.Empty()));
+        return (0, core_1.beginCell)()
+            .storeUint(constants_1.Op.ConfirmQueue, 32)
+            .storeUint(opts.queryId, 64)
+            .storeDict(depositDict)
+            .storeDict(withdrawDict)
+            .storeRef(opts.oracleParams)
+            .endCell();
+    }
+    // --- Getter methods ---
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getWalletAddress(provider, address) {
+        const params1 = {
+            type: "slice",
+            cell: (0, core_1.beginCell)().storeAddress(address).endCell(),
+        };
+        const result = await provider.get("get_wallet_address", [params1]);
+        return result.stack.readAddress();
+    }
+    async getRFQAddress(provider, index) {
+        const params1 = { type: "int", value: index };
+        const result = await provider.get("get_rfq_address", [params1]);
+        return result.stack.readAddress();
+    }
+    async getVaultData(provider) {
+        const state = await provider.getState();
+        if (state.state.type !== "active")
+            throw Error("not active");
+        if (!state.state.data)
+            throw Error("not active");
+        const data = core_1.Cell.fromBoc(state.state.data)[0];
+        const code = core_1.Cell.fromBoc(state.state.code)[0];
+        return {
+            address: this.address,
+            balance: state.balance,
+            code,
+            ...StrategyVault.parseVaultData(data),
+        };
+    }
+    async getStorage(provider) {
+        const { stack } = await provider.get("get_storage", []);
+        const storage = stack.readTuple();
+        const ownerAddress = storage.readAddress();
+        const assets = storage.readCellOpt();
+        const positions = storage.readCellOpt();
+        const dataAggregatorIndex = storage.readBigNumber();
+        const rfqIndex = storage.readBigNumber();
+        const totalSupply = storage.readBigNumber();
+        const collectedManagementFee = storage.readBigNumber();
+        const collectedProtocolFee = storage.readBigNumber();
+        const isExecutingStrategy = storage.readBoolean();
+        const configCell = storage.readCell().hash().toString("hex");
+        const additionalCell = storage.readCell().hash().toString("hex");
+        const protocolFeeManagerAddress = storage.readAddress();
+        const managerAddress = storage.readAddress();
+        const isPrivateVault = storage.readBoolean();
+        const depositCloseTimestamp = storage.readBigNumber();
+        const withdrawOpenTimestamp = storage.readBigNumber();
+        const whitelistedMinters = storage.readCellOpt();
+        const lastCollectTimestamp = storage.readBigNumber();
+        const managementFeeRatePerYear = storage.readBigNumber();
+        const protocolFeeRatePerYear = storage.readBigNumber();
+        const maxLeverageRatio = storage.readBigNumber();
+        const assetWalletDict = storage.readCellOpt();
+        const walletAssetDict = storage.readCellOpt();
+        const rfqConfig = storage.readCellOpt()?.hash().toString("hex");
+        const gasConfig = storage.readCellOpt()?.hash().toString("hex");
+        const oracleConfig = storage.readCellOpt()?.hash().toString("hex");
+        const managementFeeRecipientAddress = storage.readAddressOpt();
+        const guardianAddress = storage.readAddressOpt();
+        const timelock = storage.readBigNumber();
+        const ownerActionIndex = storage.readBigNumber();
+        const pendingOwnerActionCount = storage.readBigNumber();
+        const pendingOwnerAction = storage.readCellOpt();
+        const walletCode = storage.readCell().hash().toString("hex");
+        const dataAggregatorCode = storage.readCell().hash().toString("hex");
+        const rfqCode = storage.readCell().hash().toString("hex");
+        const content = storage.readCell();
+        const xchainConnectorAddress = storage.readAddressOpt();
+        const __xchainConfig = storage.readCellOpt();
+        let xchainConfig = null;
+        if (__xchainConfig) {
+            const xchainConfigCs = __xchainConfig.beginParse();
+            const xchainConfigDict = xchainConfigCs.loadDictDirect(core_1.Dictionary.Keys.Uint(32), codec_1.DictionaryValues.XChainConfig());
+            xchainConfig = {};
+            for (const eid of xchainConfigDict.keys()) {
+                const _xchainConfig = xchainConfigDict.get(eid);
+                if (_xchainConfig) {
+                    const { connected, xchainAccountAddress, oftConfig, strategyConfig, afterStrategyConfig, lzGasFee } = _xchainConfig;
+                    const _oftConfig = oftConfig ? StrategyVault.parseXChainOftConfig(oftConfig) : null;
+                    const _strategyConfig = strategyConfig ? StrategyVault.parseXChainStrategyConfig(strategyConfig) : null;
+                    const _afterStrategyConfig = afterStrategyConfig
+                        ? StrategyVault.parseXChainStrategyConfig(afterStrategyConfig)
+                        : null;
+                    xchainConfig[eid.toString()] = {
+                        connected,
+                        xchainAccountAddress,
+                        oftConfig: _oftConfig,
+                        strategyConfig: _strategyConfig,
+                        afterStrategyConfig: _afterStrategyConfig,
+                        lzGasFee,
+                    };
+                }
+            }
+        }
+        return {
+            ownerAddress,
+            assets,
+            positions,
+            dataAggregatorIndex,
+            rfqIndex,
+            totalSupply,
+            collectedManagementFee,
+            collectedProtocolFee,
+            isExecutingStrategy,
+            configCell,
+            additionalCell,
+            protocolFeeManagerAddress,
+            managerAddress,
+            isPrivateVault,
+            depositCloseTimestamp,
+            withdrawOpenTimestamp,
+            whitelistedMinters,
+            lastCollectTimestamp,
+            managementFeeRatePerYear,
+            protocolFeeRatePerYear,
+            maxLeverageRatio,
+            assetWalletDict,
+            walletAssetDict,
+            rfqConfig,
+            gasConfig,
+            oracleConfig,
+            managementFeeRecipientAddress,
+            guardianAddress,
+            timelock,
+            ownerActionIndex,
+            pendingOwnerActionCount,
+            pendingOwnerAction,
+            walletCode,
+            dataAggregatorCode,
+            rfqCode,
+            content,
+            xchainConnectorAddress,
+            xchainConfig,
+        };
+    }
+}
+exports.StrategyVault = StrategyVault;

package/dist/contracts/vault/strategy-vault/type.d.ts

@@ -0,0 +1,115 @@
+import { Address, Cell } from "@ton/core";
+export type StrategyVaultConfig = {
+    ownerAddress: Address;
+    assets: Cell | null;
+    positions: Cell | null;
+    aggregatorIndex: bigint;
+    rfqIndex: bigint;
+    totalSupply: bigint;
+    collectedManagementFee: bigint;
+    collectedProtocolFee: bigint;
+    isExecutingStrategy: boolean;
+    config: {
+        protocolFeeManagerAddress: Address;
+        managerAddress: Address;
+        isPrivateVault: boolean;
+        globalDepositValueCap: bigint;
+        depositCloseTimestamp: bigint;
+        withdrawOpenTimestamp: bigint;
+        whitelistedMinters: Cell | null;
+        lastCollectTime: bigint;
+        withdrawFeeRate: bigint;
+        managementFeeRate: bigint;
+        protocolFeeRate: bigint;
+        content: Cell;
+        maxLeverageRatio: bigint;
+        assetWalletDict: Cell | null;
+        walletAssetDict: Cell | null;
+        oracleConfig?: Cell | null;
+        rfqConfig?: Cell | null;
+        gasConfig?: Cell | null;
+        guardianAddress?: Address;
+        managementFeeRecipientAddress?: Address;
+        timelock?: bigint;
+        queueWithdrawFeeRate?: bigint;
+        crosschainConnectorAddress?: Address;
+        xchainConfig?: Cell | null;
+        xchainUpdateHash?: bigint;
+    };
+    code: {
+        walletCode: Cell;
+        poolAggregatorCode: Cell;
+        rfqCode: Cell;
+    };
+    depositQueueManager?: {
+        totalSize: bigint;
+        queueCounter: bigint;
+        pendingAssetQueueDict: Cell | null;
+        confirmedAssetQueueDict: Cell | null;
+    };
+    withdrawQueueManager?: {
+        totalSize: bigint;
+        queueCounter: bigint;
+        pendingAssetQueueDict: Cell | null;
+        confirmedAssetQueueDict: Cell | null;
+    };
+    interactiveVaultDict?: Cell;
+};
+export type VaultResponseOptions = {
+    jettonForwardTonAmount?: bigint;
+    jettonForwardPayload?: Cell;
+    actionForwardTonAmount?: bigint;
+    actionForwardPayload?: Cell;
+};
+export type FactorialPoolShare = {
+    isSupplyable: boolean;
+    isBorrowable: boolean;
+    supply: bigint;
+    borrow: bigint;
+};
+export type FactorialPool = Record<string, FactorialPoolShare>;
+export type AssetV1 = {
+    isWhitelisted: boolean;
+    isDepositable: boolean;
+    isWithdrawable: boolean;
+    exposureCap: number;
+    cash: bigint;
+    balance: bigint;
+};
+export type AssetV2 = AssetV1 & {
+    isDepositQueueActivated: boolean;
+    isWithdrawQueueActivated: boolean;
+};
+export type RequestQueueItem = {
+    amount: bigint;
+    responseAddress: Address;
+    jettonForwardTonAmount: bigint;
+    jettonForwardPayload: Cell | null;
+    actionForwardTonAmount: bigint;
+    actionForwardPayload: Cell | null;
+};
+export type SumQueue = {
+    queueId: bigint;
+    sum: bigint;
+    exchangeRate: bigint;
+    dict: Record<string, RequestQueueItem>;
+};
+export type QueueManager = {
+    totalSize: bigint;
+    queueCounter: bigint;
+    pendingAssetQueue: Record<string, SumQueue>;
+    confirmedAssetQueue: Record<string, SumQueue>;
+};
+export type InteractiveVaultConfigItem = {
+    vaultType: number;
+    supportedAssets: string[];
+};
+export type XChainConfig = {
+    connected: boolean;
+    xchainAccountAddress: bigint;
+    oftConfig?: Cell | null;
+    strategyConfig?: Cell | null;
+    afterStrategyConfig?: Cell | null;
+    lzGasFee: bigint;
+};
+export type InteractiveVaultDict = Record<string, InteractiveVaultConfigItem>;

package/dist/contracts/vault/strategy-vault/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/wton/jetton-minter.d.ts

@@ -0,0 +1,35 @@
+import { Address, Cell, Contract, ContractProvider, OpenedContract, Sender } from "@ton/ton";
+import { AddressInput } from "../common/type";
+import { WTONWallet } from "./jetton-wallet";
+export declare const WTON_UNWRAP_OP_VALUE = 8388449;
+export declare const WTON_UNWRAP_OP_LENGTH = 23;
+export declare const WTON_UNWRAP_CELL: Cell;
+export declare const WTON_UNWRAP_GAS: bigint;
+export declare class WTONMinter implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    private cache;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static Op: {
+        Mint: number;
+    };
+    static createFromAddress(address: Address): WTONMinter;
+    getState(provider: ContractProvider): Promise<import("@ton/ton").ContractState>;
+    getWalletAddress(provider: ContractProvider, address: Address): Promise<Address>;
+    sendMint(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        recipient: Address;
+        queryId?: bigint;
+    }): Promise<void>;
+    getJettonData(provider: ContractProvider): Promise<{
+        totalSupply: bigint;
+        admin: Address;
+        content: string | null;
+    }>;
+    getWallet(provider: ContractProvider, address: AddressInput): Promise<OpenedContract<WTONWallet>>;
+}

package/dist/contracts/wton/jetton-minter.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WTONMinter = exports.WTON_UNWRAP_GAS = exports.WTON_UNWRAP_CELL = exports.WTON_UNWRAP_OP_LENGTH = exports.WTON_UNWRAP_OP_VALUE = void 0;
+const ton_1 = require("@ton/ton");
+const utils_1 = require("../common/utils");
+const jetton_wallet_1 = require("./jetton-wallet");
+exports.WTON_UNWRAP_OP_VALUE = 8388449;
+exports.WTON_UNWRAP_OP_LENGTH = 23;
+exports.WTON_UNWRAP_CELL = (0, ton_1.beginCell)().storeUint(exports.WTON_UNWRAP_OP_VALUE, exports.WTON_UNWRAP_OP_LENGTH).endCell();
+exports.WTON_UNWRAP_GAS = (0, ton_1.toNano)(0.02);
+class WTONMinter {
+    address;
+    init;
+    cache = new Map();
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static Op = {
+        Mint: 0xaeaf6718,
+    };
+    static createFromAddress(address) {
+        return new WTONMinter(address);
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getWalletAddress(provider, address) {
+        const result = await provider.get("get_wallet_address", [
+            {
+                type: "slice",
+                cell: (0, ton_1.beginCell)().storeAddress(address).endCell(),
+            },
+        ]);
+        return result.stack.readAddress();
+    }
+    async sendMint(provider, via, value, opts) {
+        await provider.internal(via, {
+            value: value,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)()
+                .storeUint(WTONMinter.Op.Mint, 32)
+                .storeUint(opts.queryId ?? 0, 64)
+                .storeAddress(opts.recipient)
+                .endCell(),
+        });
+    }
+    async getJettonData(provider) {
+        const _result = await provider.get("get_jetton_data", []);
+        const totalSupply = _result.stack.readBigNumber();
+        _result.stack.readBigNumber();
+        const admin = _result.stack.readAddress();
+        const content = _result.stack.readStringOpt();
+        return {
+            totalSupply,
+            admin,
+            content,
+        };
+    }
+    async getWallet(provider, address) {
+        const key = (0, utils_1.toAddress)(address).toString();
+        const cached = this.cache.get(key);
+        if (cached)
+            return cached;
+        const wtonWalletAddress = await this.getWalletAddress(provider, (0, utils_1.toAddress)(address));
+        const wallet = provider.open(jetton_wallet_1.WTONWallet.createFromAddress(wtonWalletAddress));
+        this.cache.set(key, wallet);
+        return wallet;
+    }
+}
+exports.WTONMinter = WTONMinter;