@affluent-org/sdk 0.0.2 → 0.0.3

package/dist/rfq-batch.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RFQBatchV1 = void 0;
+const ton_1 = require("@ton/ton");
+const utils_1 = require("./contracts/common/utils");
+const service_1 = require("./common/service");
+const jetton_minter_1 = require("./contracts/jetton/jetton-minter");
+const jetton_wallet_1 = require("./contracts/jetton/jetton-wallet");
+const rfq_batch_1 = require("./contracts/rfq/rfq_batch");
+const redstone_onchain_oracle_1 = require("./contracts/oracle/redstone-onchain-oracle");
+const redstoneHelper_1 = require("./utils/oracle/redstone/redstoneHelper");
+const strategy_vault_1 = require("./contracts/vault/strategy-vault");
+const unknown_contract_1 = require("./common/unknown-contract");
+const share_vault_1 = require("./contracts/vault/share-vault");
+const oracle_1 = require("./oracle/oracle");
+class RFQBatchV1 extends service_1.ServiceBaseV1 {
+    async sendAddOrder(sender, params, value) {
+        const rfqBatch = this.getByContract(rfq_batch_1.RFQBatch, (0, utils_1.toAddress)(params.rfqBatchAddress));
+        const rfqData = await rfqBatch.getRfqData();
+        const forwardPayload = rfq_batch_1.RFQBatch.createOrderMsg((0, utils_1.toAddress)(params.senderAddress), params.forwardTonAmount, params.forwardPayload);
+        const assetContract = this.getByContract(jetton_minter_1.JettonMinter, (0, utils_1.toAddress)(params.assetAddress));
+        const assetWalletAddress = await assetContract.getWalletAddress((0, utils_1.toAddress)(params.senderAddress));
+        const assetWallet = this.getByContract(jetton_wallet_1.JettonWallet, assetWalletAddress);
+        const wtonAddress = (0, utils_1.toAddress)(this.contracts.WTON);
+        // TODO - WTON
+        await assetWallet.sendTransfer(sender, value ?? (0, ton_1.toNano)(0.2), {
+            recipient: (0, utils_1.toAddress)(params.rfqBatchAddress),
+            response: sender.address,
+            amount: params.amount,
+            forwardTonAmount: (0, ton_1.toNano)(0.1),
+            forwardPayload: forwardPayload,
+        });
+    }
+    async sendSettle(sender, params, value) {
+        const rfqBatch = this.getByContract(rfq_batch_1.RFQBatch, (0, utils_1.toAddress)(params.rfqBatchAddress));
+        const rfqBatchData = await rfqBatch.getRfqData();
+        const oracleLibs = new oracle_1.OracleLibs(this.client, this.network);
+        const { oracleParams, bucket } = await oracleLibs.getOracleParamsForRFQBatch(rfqBatchData);
+        const forwardPayload = rfq_batch_1.RFQBatch.createSettleMsg(oracleParams);
+        const assetContract = this.getByContract(jetton_minter_1.JettonMinter, (0, utils_1.toAddress)(params.assetAddress));
+        const assetWalletAddress = await assetContract.getWalletAddress((0, utils_1.toAddress)(params.senderAddress));
+        const assetWallet = this.getByContract(jetton_wallet_1.JettonWallet, assetWalletAddress);
+        // TODO - WTON
+        const wtonAddress = (0, utils_1.toAddress)(this.contracts.WTON);
+        const oracleCalculateGas = BigInt(bucket.assets.size + bucket.pools.size + bucket.vaults.size) *
+            (0, ton_1.toNano)(0.06);
+        const forwardTonAmount = oracleCalculateGas + (0, ton_1.toNano)(0.4);
+        const sendValue = value ?? forwardTonAmount + (0, ton_1.toNano)(0.1);
+        await assetWallet.sendTransfer(sender, sendValue, {
+            recipient: (0, utils_1.toAddress)(params.rfqBatchAddress),
+            response: sender.address,
+            amount: params.amount,
+            forwardTonAmount,
+            forwardPayload,
+        });
+    }
+    async separateAssets(_assets, oracleConfig) {
+        const noVaultAssets = [
+            ...Object.values(oracleConfig.redstoneAssetInfo).map((item) => item.address.toString()),
+            ...Object.keys(oracleConfig.assetOnchainDataInfo).map((item) => item),
+        ];
+        const assets = [];
+        const vaultAssets = [];
+        for (const asset of _assets) {
+            if (noVaultAssets.includes(asset.toString())) {
+                assets.push(asset);
+            }
+            else {
+                vaultAssets.push(asset);
+            }
+        }
+        return {
+            assets,
+            vaultAssets,
+        };
+    }
+    async getParsedVaults(vaultAddresses) {
+        const decomposedVault = {};
+        for (let vaultAddress of vaultAddresses) {
+            const state = await this.getByContract(unknown_contract_1.UnknownContract, vaultAddress).getState();
+            if (state.state.type === "active" && state.state.data) {
+                const data = ton_1.Cell.fromBoc(state.state.data)[0];
+                try {
+                    const vaultData = strategy_vault_1.StrategyVault.parseVaultData(data);
+                    const vaultDataa = {
+                        totalSupply: vaultData.totalSupply,
+                        assets: Object.keys(vaultData.assets).reduce((acc, asset) => {
+                            acc[asset] = vaultData.assets[asset].cash;
+                            return acc;
+                        }, {}),
+                        poolPositions: Object.keys(vaultData.factorialPools).reduce((acc, pool) => {
+                            acc[pool] = Object.keys(vaultData.factorialPools[pool]).reduce((acc, asset) => {
+                                acc[asset] = {
+                                    supply: vaultData.factorialPools[pool][asset].supply,
+                                    borrow: vaultData.factorialPools[pool][asset].borrow,
+                                };
+                                return acc;
+                            }, {});
+                            return acc;
+                        }, {}),
+                    };
+                    decomposedVault[vaultAddress.toString()] = vaultDataa;
+                }
+                catch (e) {
+                    const vaultData = share_vault_1.ShareVault.parseVaultData(data);
+                    const vaultDataa = {
+                        totalSupply: vaultData.totalSupply,
+                        assets: {
+                            [vaultData.asset.toString()]: vaultData.cash,
+                        },
+                        poolPositions: Object.values(vaultData.whitelistedPools).reduce((acc, pool) => {
+                            acc[pool.address.toString()] = {
+                                [vaultData.asset.toString()]: {
+                                    supply: pool.supply,
+                                    borrow: 0n,
+                                },
+                            };
+                            return acc;
+                        }, {}),
+                    };
+                    decomposedVault[vaultAddress.toString()] = vaultDataa;
+                }
+            }
+        }
+        return decomposedVault;
+    }
+    async getExposures(vaults) {
+        const assets = new Set();
+        const pools = new Set();
+        for (let vault of Object.values(vaults)) {
+            const _assets = vault.assets;
+            for (let asset of Object.keys(_assets)) {
+                const position = vault.assets[asset];
+                assets.add(asset);
+            }
+            for (let pool of Object.keys(vault.poolPositions)) {
+                const _assets = vault.poolPositions[pool];
+                for (let asset of Object.keys(_assets)) {
+                    const position = vault.poolPositions[pool][asset];
+                    if (position.supply > 0n || position.borrow > 0n) {
+                        pools.add(pool);
+                        assets.add(asset);
+                    }
+                }
+            }
+        }
+        const result = { pools: [...pools], assets: [...assets] };
+        return result;
+    }
+    async getOracleParams(rfqBatchAddress) {
+        const rfqBatch = this.getByContract(rfq_batch_1.RFQBatch, (0, utils_1.toAddress)(rfqBatchAddress));
+        const rfqBatchData = await rfqBatch.getRfqData();
+        const oracleConfig = rfqBatchData.oracleConfig;
+        let { assets, vaultAssets } = await this.separateAssets([
+            rfqBatchData.asset0Address.toString(),
+            rfqBatchData.asset1Address.toString(),
+        ], oracleConfig);
+        const vaultPositions = await this.getParsedVaults(vaultAssets);
+        const exposures = await this.getExposures(vaultPositions);
+        const exposurePools = exposures.pools;
+        assets = [...new Set([...assets, ...exposures.assets])];
+        let requestFactorialPoolsCell = exposurePools.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(exposurePools.map((pool) => ton_1.Address.parse(pool)))
+            : null;
+        let requestFactorialVaultsCell = vaultAssets.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(vaultAssets.map((vault) => ton_1.Address.parse(vault)))
+            : null;
+        let requestFactorialCell = (0, ton_1.beginCell)()
+            .storeMaybeRef(requestFactorialPoolsCell)
+            .storeMaybeRef(requestFactorialVaultsCell)
+            .endCell();
+        assets = [...new Set([...assets, ...exposures.assets])];
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, oracleConfig);
+        const helper = (0, redstoneHelper_1.createRedstoneHelper)("prod");
+        const payload = await helper.createPayload(result.redstoneAssetNames);
+        const requestAssetCell = redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(result.requestAssets);
+        const dataFeedIdsTupleBuilder = new ton_1.TupleBuilder();
+        result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+        const feedIdCell = (0, ton_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+        const oracleParams = (0, ton_1.beginCell)()
+            .storeRef(feedIdCell)
+            .storeRef(payload)
+            .storeRef(requestAssetCell)
+            .storeRef(requestFactorialCell)
+            .endCell();
+        return oracleParams;
+    }
+    async sendLock(sender, params, value) {
+        const rfqBatch = this.getByContract(rfq_batch_1.RFQBatch, (0, utils_1.toAddress)(params.rfqBatchAddress));
+        await rfqBatch.sendLock(sender, value ?? (0, ton_1.toNano)(0.1));
+    }
+    async sendCancelOrder(sender, params, value) {
+        const rfqBatch = this.getByContract(rfq_batch_1.RFQBatch, (0, utils_1.toAddress)(params.rfqBatchAddress));
+        const rfqBatchData = await rfqBatch.getRfqData();
+        const assetIdx = rfqBatchData.asset0Address.toString() ===
+            (0, utils_1.toAddress)(params.assetAddress).toString()
+            ? 0
+            : rfqBatchData.asset1Address.toString() ===
+                (0, utils_1.toAddress)(params.assetAddress).toString()
+                ? 1
+                : -1;
+        if (assetIdx === -1)
+            throw new Error("Asset not found");
+        await rfqBatch.sendCancelOrder(sender, value ?? (0, ton_1.toNano)(0.1), {
+            assetIdx,
+        });
+    }
+    async sendPayout(sender, params, value) {
+        const rfqBatch = this.getByContract(rfq_batch_1.RFQBatch, (0, utils_1.toAddress)(params.rfqBatchAddress));
+        const rfqBatchData = await rfqBatch.getRfqData();
+        const assetIdx = rfqBatchData.asset0Address.toString() ===
+            (0, utils_1.toAddress)(params.assetAddress).toString()
+            ? 0
+            : rfqBatchData.asset1Address.toString() ===
+                (0, utils_1.toAddress)(params.assetAddress).toString()
+                ? 1
+                : -1;
+        if (assetIdx === -1)
+            throw new Error("Asset not found");
+        await rfqBatch.sendPayout(sender, value ?? (0, ton_1.toNano)(0.1), {
+            assetIdx,
+            count: params.count,
+        });
+    }
+    async sendReopen(sender, params, value) {
+        const rfqBatch = this.getByContract(rfq_batch_1.RFQBatch, (0, utils_1.toAddress)(params.rfqBatchAddress));
+        await rfqBatch.sendReopen(sender, value ?? (0, ton_1.toNano)(0.1));
+    }
+    async sendCollectFee(sender, params, value) {
+        const rfqBatch = this.getByContract(rfq_batch_1.RFQBatch, (0, utils_1.toAddress)(params.rfqBatchAddress));
+        await rfqBatch.sendCollectFee(sender, value ?? (0, ton_1.toNano)(0.1));
+    }
+    async getRfqBatchData(rfqBatchAddress) {
+        const rfqBatch = this.getByContract(rfq_batch_1.RFQBatch, (0, utils_1.toAddress)(rfqBatchAddress));
+        return await rfqBatch.getRfqData();
+    }
+    async createInternalAddOrder(sender, params, value) {
+        const rfqBatch = this.getByContract(rfq_batch_1.RFQBatch, (0, utils_1.toAddress)(params.rfqBatchAddress));
+        const rfqData = await rfqBatch.getRfqData();
+        const forwardPayload = rfq_batch_1.RFQBatch.createOrderMsg((0, utils_1.toAddress)(params.senderAddress), params.forwardTonAmount, params.forwardPayload);
+        const assetContract = this.getByContract(jetton_minter_1.JettonMinter, (0, utils_1.toAddress)(params.assetAddress));
+        const assetWalletAddress = await assetContract.getWalletAddress((0, utils_1.toAddress)(params.senderAddress));
+        const assetWallet = this.getByContract(jetton_wallet_1.JettonWallet, assetWalletAddress);
+        const wtonAddress = (0, utils_1.toAddress)(this.contracts.WTON);
+        // TODO - WTON
+        await assetWallet.sendTransfer(sender, value ?? (0, ton_1.toNano)(0.2), {
+            recipient: (0, utils_1.toAddress)(params.rfqBatchAddress),
+            response: sender.address,
+            amount: params.amount,
+            forwardTonAmount: (0, ton_1.toNano)(0.1),
+            forwardPayload: forwardPayload,
+        });
+        return assetWallet.createInternalTransfer(value ?? (0, ton_1.toNano)(0.2), {
+            recipient: (0, utils_1.toAddress)(params.rfqBatchAddress),
+            response: sender.address,
+            amount: params.amount,
+            forwardTonAmount: (0, ton_1.toNano)(0.1),
+            forwardPayload: forwardPayload,
+        });
+    }
+    async createInternalCancelOrder(params, value) {
+        const rfqBatch = this.getByContract(rfq_batch_1.RFQBatch, (0, utils_1.toAddress)(params.rfqBatchAddress));
+        const rfqBatchData = await rfqBatch.getRfqData();
+        const assetIdx = rfqBatchData.asset0Address.toString() ===
+            (0, utils_1.toAddress)(params.assetAddress).toString()
+            ? 0
+            : rfqBatchData.asset1Address.toString() ===
+                (0, utils_1.toAddress)(params.assetAddress).toString()
+                ? 1
+                : -1;
+        if (assetIdx === -1)
+            throw new Error("Asset not found");
+        return {
+            to: (0, utils_1.toAddress)(params.rfqBatchAddress),
+            value: value ?? (0, ton_1.toNano)(0.1),
+            body: (0, ton_1.beginCell)()
+                .storeUint(rfq_batch_1.RFQBatch.Op.CancelOrder, 32)
+                .storeUint(0, 64)
+                .storeUint(assetIdx, 1)
+                .endCell(),
+        };
+    }
+}
+exports.RFQBatchV1 = RFQBatchV1;

package/dist/services/share-vault/computation.d.ts

@@ -1,24 +1,21 @@
 import { ShareVaultState } from "../../contracts/vault/share-vault";
+import { getPoolInfoForShareVault } from "./query";
+import { PoolInfoForShareVault, PoolTuple } from "./type";
 /**
- * Pool info for ShareVault calculations
+ * Get pools sorted by target weight ratio for withdrawal ordering
  */
-export type PoolInfoForShareVault = {
-    cash: bigint;
-    totalSupplyAmount: bigint;
-    totalSupplyShare: bigint;
-    vaultSupplyAmount: bigint;
-};
+export declare function getPoolTupleSortedByTargetWeight(whitelistedPools: ShareVaultState["whitelistedPools"], totalAssetAmount: bigint, totalTargetWeight: bigint, poolInfoForShareVault: Record<string, PoolInfoForShareVault>): PoolTuple[];
 /**
- * Pool tuple with calculated values for withdrawal ordering
+ * Estimate how many pools need to be withdrawn from to fulfill a withdrawal request
  */
-export type PoolTuple = {
-    poolAddress: string;
-    targetWeight: bigint;
-    targetWeightRatio: number;
-    supply: bigint;
-    withdrawableAmount: bigint;
-};
+export declare function estimateWithdrawPoolCount(vaultData: ShareVaultState, poolInfo: Awaited<ReturnType<typeof getPoolInfoForShareVault>>, requestedShares: bigint): Promise<{
+    count: number;
+    sortedPools: PoolTuple[];
+}>;
 /**
- * Get pools sorted by target weight ratio for withdrawal ordering
+ * Get share vault exchange info
  */
-export declare function getPoolTupleSortedByTargetWeight(whitelistedPools: ShareVaultState["whitelistedPools"], totalAssetAmount: bigint, totalTargetWeight: bigint, poolInfoForShareVault: Record<string, PoolInfoForShareVault>): PoolTuple[];
+export declare function getExchangeRate(vaultData: ShareVaultState, poolInfo: Awaited<ReturnType<typeof getPoolInfoForShareVault>>): {
+    netAmount: bigint;
+    exr: number;
+};

package/dist/services/share-vault/computation.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPoolTupleSortedByTargetWeight = getPoolTupleSortedByTargetWeight;
+exports.estimateWithdrawPoolCount = estimateWithdrawPoolCount;
+exports.getExchangeRate = getExchangeRate;
 // ============================================================
 // Pure Computation (no I/O)
 // ============================================================
@@ -40,3 +42,40 @@ function getPoolTupleSortedByTargetWeight(whitelistedPools, totalAssetAmount, to
         return b.targetWeightRatio - a.targetWeightRatio;
     });
 }
+/**
+ * Estimate how many pools need to be withdrawn from to fulfill a withdrawal request
+ */
+async function estimateWithdrawPoolCount(vaultData, poolInfo, requestedShares) {
+    const totalAssetAmount = Object.values(poolInfo).reduce((acc, p) => acc + p.vaultSupplyAmount, 0n) + vaultData.cash;
+    const sortedPools = getPoolTupleSortedByTargetWeight(vaultData.whitelistedPools, totalAssetAmount, vaultData.totalTargetWeight, poolInfo);
+    if (vaultData.totalSupply === 0n) {
+        return { count: 0, sortedPools };
+    }
+    const requestedAmount = (requestedShares * totalAssetAmount) / vaultData.totalSupply;
+    let remainingAmount = requestedAmount - vaultData.cash;
+    if (remainingAmount <= 0n) {
+        return { count: 0, sortedPools };
+    }
+    let count = 0;
+    for (const pool of sortedPools) {
+        if (remainingAmount <= 0n)
+            break;
+        remainingAmount -= pool.withdrawableAmount;
+        count++;
+    }
+    return { count, sortedPools };
+}
+/**
+ * Get share vault exchange info
+ */
+function getExchangeRate(vaultData, poolInfo) {
+    const vaultPosition = vaultData.whitelistedPools;
+    let netAmount = vaultData.cash;
+    for (const [poolAddress, position] of Object.entries(vaultPosition)) {
+        netAmount += poolInfo[poolAddress].totalSupplyAmount * position.supply / poolInfo[poolAddress].totalSupplyShare;
+    }
+    return {
+        netAmount,
+        exr: Number(netAmount) / Number(vaultData.totalSupply),
+    };
+}

package/dist/services/share-vault/index.js

@@ -41,6 +41,7 @@ const context_1 = require("../../context");
 const send_msg_1 = require("../../lib/send-msg");
 const query = __importStar(require("./query"));
 exports.query = query;
+const computation = __importStar(require("./computation"));
 const owner = __importStar(require("./owner"));
 exports.owner = owner;
 const manager = __importStar(require("./manager"));
@@ -76,14 +77,16 @@ class ShareVaultServiceV1 {
         return query.getPoolInfoForShareVault(this.ctx, vaultData);
     }
     getPoolTupleSortedByTargetWeight(whitelistedPools, totalAssetAmount, totalTargetWeight, poolInfoForShareVault) {
-        return query.getPoolTupleSortedByTargetWeight(whitelistedPools, totalAssetAmount, totalTargetWeight, poolInfoForShareVault);
+        return computation.getPoolTupleSortedByTargetWeight(whitelistedPools, totalAssetAmount, totalTargetWeight, poolInfoForShareVault);
     }
     async estimateWithdrawPoolCount(vaultData, requestedShares) {
-        return query.estimateWithdrawPoolCount(this.ctx, vaultData, requestedShares);
+        const poolInfo = await query.getPoolInfoForShareVault(this.ctx, vaultData);
+        return computation.estimateWithdrawPoolCount(vaultData, poolInfo, requestedShares);
     }
     /** @deprecated Use estimateWithdrawPoolCount instead */
     async estimateWithdrawLiquidityFulfillmentPoolCount(vaultData, requestedShares) {
-        return query.estimateWithdrawPoolCount(this.ctx, vaultData, requestedShares);
+        const poolInfo = await query.getPoolInfoForShareVault(this.ctx, vaultData);
+        return computation.estimateWithdrawPoolCount(vaultData, poolInfo, requestedShares);
     }
     // ============================================================
     // Owner

package/dist/services/share-vault/query.d.ts

@@ -3,8 +3,8 @@ import { AffluentContext } from "../../context";
 import { AddressInput, AddressLike } from "../../contracts/common/type";
 import { ShareVault, ShareVaultState } from "../../contracts/vault/share-vault";
 import { JettonWallet } from "../../contracts/jetton/jetton-wallet";
-import { PoolInfoForShareVault, PoolTuple } from "./computation";
-export { PoolInfoForShareVault, PoolTuple, getPoolTupleSortedByTargetWeight } from "./computation";
+import { PoolInfoForShareVault } from "./type";
+export { PoolInfoForShareVault, PoolTuple } from "./type";
 /**
  * Get ShareVault contract instance
  */
@@ -25,10 +25,40 @@ export declare function getVaultWallet(ctx: AffluentContext, vaultAddress: Addre
  * Get pool info for all whitelisted pools
  */
 export declare function getPoolInfoForShareVault(ctx: AffluentContext, vaultData: ShareVaultState): Promise<Record<string, PoolInfoForShareVault>>;
-/**
- * Estimate how many pools need to be withdrawn from to fulfill a withdrawal request
- */
-export declare function estimateWithdrawPoolCount(ctx: AffluentContext, vaultData: ShareVaultState, requestedShares: bigint): Promise<{
-    count: number;
-    sortedPools: PoolTuple[];
+export declare function getValuationContext(ctx: AffluentContext, vaultAddress: AddressInput): Promise<{
+    storage: {
+        totalSupply: bigint;
+        owner: Address | null;
+        manager: Address | null;
+        asset: Address;
+        balance: bigint;
+        cash: bigint;
+        totalTargetWeight: bigint;
+        nextAggregatorIndex: bigint;
+        isWtonVault: boolean;
+        assetWallet: Address | null;
+        whitelistedPools: Record<string, {
+            isWhitelisted: boolean;
+            targetWeight: bigint;
+            supply: bigint;
+        } & {
+            address: Address;
+        }>;
+        minimumGasFee: {
+            supply: bigint;
+            withdraw: bigint;
+            factorialSupply: bigint;
+            factorialWithdraw: bigint;
+            mintVaultShareTokens: bigint;
+        };
+        code: import("@ton/core").Cell;
+        address: Address;
+    };
+    totalSupply: bigint;
+    asset: Address;
+    reserve: bigint;
+    poolPositions: Record<string, PoolInfoForShareVault>;
+    netAmount: bigint;
+    exr: number;
 }>;
+export declare function getEXR(ctx: AffluentContext, vaultAddress: AddressInput): Promise<number>;

package/dist/services/share-vault/query.js

@@ -33,22 +33,19 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPoolTupleSortedByTargetWeight = void 0;
 exports.getVault = getVault;
 exports.getVaultData = getVaultData;
 exports.getVaultWalletAddress = getVaultWalletAddress;
 exports.getVaultWallet = getVaultWallet;
 exports.getPoolInfoForShareVault = getPoolInfoForShareVault;
-exports.estimateWithdrawPoolCount = estimateWithdrawPoolCount;
+exports.getValuationContext = getValuationContext;
+exports.getEXR = getEXR;
 const core_1 = require("@ton/core");
 const utils_1 = require("../../contracts/common/utils");
 const share_vault_1 = require("../../contracts/vault/share-vault");
 const pool_1 = require("../../contracts/core/pool");
 const jetton_wallet_1 = require("../../contracts/jetton/jetton-wallet");
 const computation_1 = require("./computation");
-// Re-export computation functions and types
-var computation_2 = require("./computation");
-Object.defineProperty(exports, "getPoolTupleSortedByTargetWeight", { enumerable: true, get: function () { return computation_2.getPoolTupleSortedByTargetWeight; } });
 /**
  * Get ShareVault contract instance
  */
@@ -112,27 +109,23 @@ async function getPoolInfoForShareVault(ctx, vaultData) {
     }
     return poolInfo;
 }
-/**
- * Estimate how many pools need to be withdrawn from to fulfill a withdrawal request
- */
-async function estimateWithdrawPoolCount(ctx, vaultData, requestedShares) {
+async function getValuationContext(ctx, vaultAddress) {
+    const vault = getVault(ctx, vaultAddress);
+    const vaultData = await vault.getVaultData();
     const poolInfo = await getPoolInfoForShareVault(ctx, vaultData);
-    const totalAssetAmount = Object.values(poolInfo).reduce((acc, p) => acc + p.vaultSupplyAmount, 0n) + vaultData.cash;
-    const sortedPools = (0, computation_1.getPoolTupleSortedByTargetWeight)(vaultData.whitelistedPools, totalAssetAmount, vaultData.totalTargetWeight, poolInfo);
-    if (vaultData.totalSupply === 0n) {
-        return { count: 0, sortedPools };
-    }
-    const requestedAmount = (requestedShares * totalAssetAmount) / vaultData.totalSupply;
-    let remainingAmount = requestedAmount - vaultData.cash;
-    if (remainingAmount <= 0n) {
-        return { count: 0, sortedPools };
-    }
-    let count = 0;
-    for (const pool of sortedPools) {
-        if (remainingAmount <= 0n)
-            break;
-        remainingAmount -= pool.withdrawableAmount;
-        count++;
-    }
-    return { count, sortedPools };
+    const exrInfo = (0, computation_1.getExchangeRate)(vaultData, poolInfo);
+    return {
+        storage: vaultData,
+        totalSupply: vaultData.totalSupply,
+        asset: vaultData.asset,
+        reserve: vaultData.cash,
+        poolPositions: poolInfo,
+        netAmount: exrInfo.netAmount,
+        exr: exrInfo.exr,
+    };
+}
+async function getEXR(ctx, vaultAddress) {
+    return getValuationContext(ctx, vaultAddress).then((vaultCtx) => {
+        return vaultCtx.exr;
+    });
 }

package/dist/services/share-vault/type.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Pool info for ShareVault calculations
+ */
+export type PoolInfoForShareVault = {
+    cash: bigint;
+    totalSupplyAmount: bigint;
+    totalSupplyShare: bigint;
+    vaultSupplyAmount: bigint;
+};
+/**
+ * Pool tuple with calculated values for withdrawal ordering
+ */
+export type PoolTuple = {
+    poolAddress: string;
+    targetWeight: bigint;
+    targetWeightRatio: number;
+    supply: bigint;
+    withdrawableAmount: bigint;
+};

package/dist/services/share-vault/type.js

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

package/dist/services/share-vault/user/index.js

@@ -23,6 +23,7 @@ const jetton_wallet_1 = require("../../../contracts/jetton/jetton-wallet");
 const jetton_wallet_2 = require("../../../contracts/wton/jetton-wallet");
 const jetton_minter_2 = require("../../../contracts/wton/jetton-minter");
 const query_1 = require("../query");
+const computation_1 = require("../computation");
 __exportStar(require("./types"), exports);
 // ============================================================
 // Supply
@@ -82,7 +83,8 @@ async function createWithdrawMsg(ctx, sender, params, value) {
     const assetAddress = vaultData.asset;
     const isWTON = ctx.isWTON(assetAddress);
     // Estimate pool count for gas calculation
-    const { count: poolCount } = await (0, query_1.estimateWithdrawPoolCount)(ctx, vaultData, params.amount);
+    const poolInfo = await (0, query_1.getPoolInfoForShareVault)(ctx, vaultData);
+    const { count: poolCount } = await (0, computation_1.estimateWithdrawPoolCount)(vaultData, poolInfo, params.amount);
     const gas = share_vault_1.ShareVault.calculateGasFee(share_vault_1.ShareVault.Op.Withdraw, share_vault_1.ShareVault.Gas.baseFee, poolCount, vaultData.minimumGasFee, isWTON);
     const forwardPayload = share_vault_1.ShareVault.createWithdrawForwardPayload({
         jettonForwardTonAmount: isWTON ? jetton_minter_2.WTON_UNWRAP_GAS : 0n,

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

@@ -0,0 +1 @@
+export {};

package/dist/services/strategy-vault/computation.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getStrategyVaultExchangeInfo(vaultData, poolInfo) {
+    const priceInfo = {};
+    for (const assetAddress of Object.keys(vaultData.assets)) {
+        priceInfo[assetAddress] = 0n;
+    }
+    return {
+        totalSupply: vaultData.totalSupply,
+        price: 0n,
+        exr: (assetAddress) => 0,
+        toShares: (assetAddress, amount) => 0n,
+        toAmount: (assetAddress, shares) => 0n,
+    };
+}