@affluent-org/sdk 0.0.2 → 0.0.4

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

@@ -2121,4 +2121,143 @@ export declare class StrategyVaultV1 {
         userAddress: import("@ton/core").Address;
         queryId: bigint;
     }>;
+    getValuationContext(vaultAddress: AddressLike): Promise<{
+        storage: {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: import("@ton/core").Address | null;
+            xchainConfig: Record<string, {
+                connected: boolean;
+                xchainAccountAddress: bigint;
+                oftConfig: Map<string, {
+                    destinationAddress: import("@ton/core").Address;
+                    forwardGas: bigint;
+                    forwardPayload?: import("@ton/core").Cell | null;
+                    lzTransferFeeRate?: bigint;
+                }> | null;
+                strategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                afterStrategyConfig: Map<bigint, {
+                    isExecutable: boolean;
+                }> | null;
+                lzGasFee: bigint;
+            }>;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        } | {
+            globalDepositValueCap: bigint;
+            withdrawFeeRate: number;
+            queueWithdrawFeeRate: number;
+            depositQueueManager: import("../../contracts/vault/strategy-vault").QueueManager;
+            withdrawQueueManager: import("../../contracts/vault/strategy-vault").QueueManager;
+            interactiveVaultDict: Record<string, import("../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+            xchainConnectorAddress: null;
+            xchainConfig: null;
+            xchainUpdateHash: bigint;
+            owner: import("@ton/core").Address;
+            manager: import("@ton/core").Address;
+            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+            aggregatorIndex: bigint;
+            content: import("@ton/core").Cell;
+            totalSupply: bigint;
+            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+            rfqConfig: {
+                priceDeviationTolerance: number;
+                rfqEventEmitterAddress: string | null;
+            } | null;
+            gasConfig: Record<string, bigint> | null;
+            isPrivateVault: boolean;
+            depositCloseTimestamp: number;
+            withdrawOpenTimestamp: number;
+            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
+            lastCollectTime: number;
+            managementFeeRatePerYear: number;
+            protocolFeeRatePerYear: number;
+            collectedManagementFee: bigint;
+            collectedProtocolFee: bigint;
+            rfqCode: import("@ton/core").Cell;
+            walletCode: import("@ton/core").Cell;
+            dataAggregatorCode: import("@ton/core").Cell;
+            protocolFeeManagerAddress: import("@ton/core").Address;
+            rfqIndex: bigint;
+            isExecutingStrategy: boolean;
+            maxLeverageRatio: number;
+            assetWalletDict: Record<string, string>;
+            walletAssetDict: Record<string, string>;
+            managementFeeRecipientAddress: import("@ton/core").Address | null;
+            guardianAddress: import("@ton/core").Address | null;
+            timelock: bigint;
+            pendingOwnerActionIndex: bigint;
+            pendingOwnerActionCount: bigint;
+            pendingOwnerAction: any;
+            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
+            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
+            version: string;
+            address: import("@ton/core").Address;
+            balance: bigint;
+            code: import("@ton/core").Cell;
+        };
+        totalSupply: bigint;
+        reserves: {
+            [k: string]: bigint;
+        };
+        poolPositions: Record<string, Record<string, {
+            supplyShare: bigint;
+            supplyAmount: bigint;
+            borrowShare: bigint;
+            borrowAmount: bigint;
+        }>>;
+        price: bigint;
+        priceInfo: import("../composite-oracle").Prices;
+    }>;
+    getPrice(vaultAddress: AddressLike): Promise<bigint>;
+    getUnderlyingPrices(vaultAddress: AddressLike): Promise<any>;
 }

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

@@ -264,5 +264,14 @@ class StrategyVaultV1 {
     async sendCancelWithdrawQueue(sender, params) {
         return (0, send_msg_1.sendMsg)(sender, user.createCancelWithdrawQueueMsg(this.ctx, params));
     }
+    async getValuationContext(vaultAddress) {
+        return query.getValuationContext(this.ctx, vaultAddress);
+    }
+    async getPrice(vaultAddress) {
+        return query.getPrice(this.ctx, vaultAddress);
+    }
+    async getUnderlyingPrices(vaultAddress) {
+        return query.getUnderlyingPrices(this.ctx, vaultAddress);
+    }
 }
 exports.StrategyVaultV1 = StrategyVaultV1;

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

@@ -4,6 +4,7 @@ import { AddressInput, AddressLike } from "../../contracts/common/type";
 import { JettonWallet } from "../../contracts/jetton/jetton-wallet";
 import { RFQAuction } from "../../contracts/rfq/rfq_auction";
 import { StrategyVault } from "../../contracts/vault/strategy-vault";
+import { PoolState } from "../../contracts/core/pool/type";
 export declare function getVault(ctx: AffluentContext, strategyVaultAddress: AddressInput): OpenedContract<StrategyVault>;
 export declare function getVaultData(ctx: AffluentContext, strategyVaultAddress: AddressLike): Promise<{
     globalDepositValueCap: bigint;
@@ -136,3 +137,149 @@ export declare function splitPureAndVaultAsset(ctx: AffluentContext, addresses:
     vaultAssetAddresses: string[];
     pureAssetAddresses: string[];
 }>;
+export declare function getPoolDataForStrategyVault(ctx: AffluentContext, strategyVaultAddress: AddressInput): Promise<Record<string, PoolState>>;
+export declare function getPoolPositionsForStrategyVault(ctx: AffluentContext, strategyVaultAddress: AddressInput): Promise<Record<string, Record<string, {
+    supplyShare: bigint;
+    supplyAmount: bigint;
+    borrowShare: bigint;
+    borrowAmount: bigint;
+}>>>;
+export declare function getValuationContext(ctx: AffluentContext, strategyVaultAddress: AddressInput): Promise<{
+    storage: {
+        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?: import("@ton/core").Cell | null;
+                lzTransferFeeRate?: bigint;
+            }> | null;
+            strategyConfig: Map<bigint, {
+                isExecutable: boolean;
+            }> | null;
+            afterStrategyConfig: Map<bigint, {
+                isExecutable: boolean;
+            }> | null;
+            lzGasFee: bigint;
+        }>;
+        xchainUpdateHash: bigint;
+        owner: Address;
+        manager: Address;
+        assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+        factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+        aggregatorIndex: bigint;
+        content: import("@ton/core").Cell;
+        totalSupply: bigint;
+        oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+        rfqConfig: {
+            priceDeviationTolerance: number;
+            rfqEventEmitterAddress: string | null;
+        } | null;
+        gasConfig: Record<string, bigint> | null;
+        isPrivateVault: boolean;
+        depositCloseTimestamp: number;
+        withdrawOpenTimestamp: number;
+        whitelistedMinters: import("@ton/core").Dictionary<Address, Boolean>;
+        lastCollectTime: number;
+        managementFeeRatePerYear: number;
+        protocolFeeRatePerYear: number;
+        collectedManagementFee: bigint;
+        collectedProtocolFee: bigint;
+        rfqCode: import("@ton/core").Cell;
+        walletCode: import("@ton/core").Cell;
+        dataAggregatorCode: import("@ton/core").Cell;
+        protocolFeeManagerAddress: 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: import("@ton/core").Cell;
+    } | {
+        globalDepositValueCap: bigint;
+        withdrawFeeRate: number;
+        queueWithdrawFeeRate: number;
+        depositQueueManager: import("../../contracts/vault/strategy-vault").QueueManager;
+        withdrawQueueManager: import("../../contracts/vault/strategy-vault").QueueManager;
+        interactiveVaultDict: Record<string, import("../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
+        xchainConnectorAddress: null;
+        xchainConfig: null;
+        xchainUpdateHash: bigint;
+        owner: Address;
+        manager: Address;
+        assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
+        factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
+        aggregatorIndex: bigint;
+        content: import("@ton/core").Cell;
+        totalSupply: bigint;
+        oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
+        rfqConfig: {
+            priceDeviationTolerance: number;
+            rfqEventEmitterAddress: string | null;
+        } | null;
+        gasConfig: Record<string, bigint> | null;
+        isPrivateVault: boolean;
+        depositCloseTimestamp: number;
+        withdrawOpenTimestamp: number;
+        whitelistedMinters: import("@ton/core").Dictionary<Address, Boolean>;
+        lastCollectTime: number;
+        managementFeeRatePerYear: number;
+        protocolFeeRatePerYear: number;
+        collectedManagementFee: bigint;
+        collectedProtocolFee: bigint;
+        rfqCode: import("@ton/core").Cell;
+        walletCode: import("@ton/core").Cell;
+        dataAggregatorCode: import("@ton/core").Cell;
+        protocolFeeManagerAddress: 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: import("@ton/core").Cell;
+    };
+    totalSupply: bigint;
+    reserves: {
+        [k: string]: bigint;
+    };
+    poolPositions: Record<string, Record<string, {
+        supplyShare: bigint;
+        supplyAmount: bigint;
+        borrowShare: bigint;
+        borrowAmount: bigint;
+    }>>;
+    price: bigint;
+    priceInfo: import("../composite-oracle").Prices;
+}>;
+export declare function getPrice(ctx: AffluentContext, strategyVaultAddress: AddressInput): Promise<bigint>;
+export declare function getUnderlyingPrices(ctx: AffluentContext, strategyVaultAddress: AddressInput): Promise<any>;

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

@@ -7,10 +7,18 @@ exports.getRFQAuctionAddress = getRFQAuctionAddress;
 exports.getRFQAuction = getRFQAuction;
 exports.isVaultAsset = isVaultAsset;
 exports.splitPureAndVaultAsset = splitPureAndVaultAsset;
+exports.getPoolDataForStrategyVault = getPoolDataForStrategyVault;
+exports.getPoolPositionsForStrategyVault = getPoolPositionsForStrategyVault;
+exports.getValuationContext = getValuationContext;
+exports.getPrice = getPrice;
+exports.getUnderlyingPrices = getUnderlyingPrices;
+const core_1 = require("@ton/core");
 const utils_1 = require("../../contracts/common/utils");
 const jetton_wallet_1 = require("../../contracts/jetton/jetton-wallet");
 const rfq_auction_1 = require("../../contracts/rfq/rfq_auction");
 const strategy_vault_1 = require("../../contracts/vault/strategy-vault");
+const composite_oracle_1 = require("../composite-oracle");
+const pool_1 = require("../../contracts/core/pool");
 function getVault(ctx, strategyVaultAddress) {
     return ctx.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(strategyVaultAddress));
 }
@@ -57,3 +65,67 @@ async function splitPureAndVaultAsset(ctx, addresses) {
         pureAssetAddresses,
     };
 }
+async function getPoolDataForStrategyVault(ctx, strategyVaultAddress) {
+    const vaultData = await getVault(ctx, strategyVaultAddress).getVaultData();
+    const poolAddresses = Object.keys(vaultData.factorialPools);
+    const poolDataEntriesPromises = poolAddresses.map(async (poolAddress) => {
+        const pool = ctx.getByContract(pool_1.Pool, core_1.Address.parse(poolAddress));
+        return [poolAddress, await pool.getPoolData()];
+    });
+    const poolDataEntries = await Promise.all(poolDataEntriesPromises);
+    return Object.fromEntries(poolDataEntries);
+}
+async function getPoolPositionsForStrategyVault(ctx, strategyVaultAddress) {
+    const strategyVault = getVault(ctx, strategyVaultAddress);
+    const vaultData = await strategyVault.getVaultData();
+    const poolInfo = {};
+    const poolDatas = await getPoolDataForStrategyVault(ctx, strategyVaultAddress);
+    for (const [poolAddress, poolPosition] of Object.entries(vaultData.factorialPools)) {
+        const poolData = poolDatas[poolAddress];
+        const position = {};
+        for (const [assetAddress, assetPosition] of Object.entries(poolPosition)) {
+            const amountPosition = (0, pool_1.positionShareToAmount)(assetPosition, poolData.assets[assetAddress]);
+            position[assetAddress] = {
+                supplyShare: assetPosition.supply,
+                supplyAmount: amountPosition.supply,
+                borrowShare: assetPosition.borrow,
+                borrowAmount: amountPosition.borrow,
+            };
+        }
+        poolInfo[poolAddress] = position;
+    }
+    return poolInfo;
+}
+async function getValuationContext(ctx, strategyVaultAddress) {
+    const compositeOracle = new composite_oracle_1.CompositeOracleV1(ctx);
+    const vaultData = await getVaultData(ctx, (0, utils_1.toAddress)(strategyVaultAddress));
+    const { allPrices: priceInfo } = await compositeOracle.getVaultPriceWithDetails((0, utils_1.toAddress)(strategyVaultAddress));
+    const vaultPrice = priceInfo[(0, utils_1.toAddress)(strategyVaultAddress).toString()].price;
+    if (!vaultPrice)
+        throw new Error("Vault price not found");
+    const poolPositions = await getPoolPositionsForStrategyVault(ctx, strategyVaultAddress);
+    return {
+        storage: vaultData,
+        totalSupply: vaultData.totalSupply,
+        reserves: Object.fromEntries(Object.entries(vaultData.assets)
+            .map(([assetAddress, assetData]) => [assetAddress, assetData.cash])),
+        poolPositions,
+        price: vaultPrice,
+        priceInfo,
+    };
+}
+async function getPrice(ctx, strategyVaultAddress) {
+    const valuationCtx = await getValuationContext(ctx, strategyVaultAddress);
+    return valuationCtx.price;
+}
+async function getUnderlyingPrices(ctx, strategyVaultAddress) {
+    const valuationCtx = await getValuationContext(ctx, strategyVaultAddress);
+    const underlyingPriceEntries = Object.keys(valuationCtx.storage.assets)
+        .map(assetAddress => {
+        const priceData = valuationCtx.priceInfo[assetAddress];
+        if (!priceData)
+            throw new Error(`Price data not found for asset ${assetAddress}`);
+        return [assetAddress, priceData.price];
+    });
+    return Object.fromEntries(underlyingPriceEntries);
+}

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

@@ -0,0 +1,2 @@
+import { AssetState } from "../../contracts/core/pool/type";
+export type PoolInfoForStrategyVault = Record<string, Record<string, AssetState>>;

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

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

package/dist/share-vault.d.ts

@@ -0,0 +1,91 @@
+import { Address, Sender } from "@ton/ton";
+import { ShareVaultManagerSetTargetWeightAction, ShareVaultManagerSupplyAction, ShareVaultManagerWithdrawAction, ShareVaultUserActionParams } from "./types/action";
+import { TxStep, TxCallBackFn } from "./utils/tracker/type";
+import { ServiceBaseV1 } from "./common/service";
+import { ShareVaultState, WhitelistedPool } from "./contracts/vault/share-vault/type";
+type PoolInfoForShareVault = {
+    cash: bigint;
+    totalSupplyAmount: bigint;
+    totalSupplyShare: bigint;
+    vaultSupplyAmount: bigint;
+};
+export declare class ShareVaultV1 extends ServiceBaseV1 {
+    private walletAddresses;
+    private getJettonWalletAddress;
+    findTx(action: any, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: ShareVaultUserActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    } | undefined>;
+    supply(sender: Sender, params: ShareVaultUserActionParams): Promise<void>;
+    supplyAndWaitTx(sender: Sender, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: ShareVaultUserActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    findSupplyTx(queryId: bigint, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: ShareVaultUserActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    withdraw(sender: Sender, params: ShareVaultUserActionParams): Promise<void>;
+    withdrawAndWaitTx(sender: Sender, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: ShareVaultUserActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    findWithdrawTx(queryId: bigint, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: ShareVaultUserActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    supplyToPool(sender: Sender, params: ShareVaultManagerSupplyAction): Promise<void>;
+    withdrawFromPool(sender: Sender, params: ShareVaultManagerWithdrawAction): Promise<void>;
+    withdrawFromPoolSimulate(sender: Address, params: ShareVaultManagerWithdrawAction): Promise<void>;
+    setTargetWeight(sender: Sender, params: ShareVaultManagerSetTargetWeightAction): Promise<void>;
+    getVaultData(vaultAddress: Address | string): Promise<ShareVaultState>;
+    getPoolCashAmounts(vaultData: ShareVaultState): Promise<Record<string, bigint>>;
+    getPoolInfoForShareVault(vaultData: ShareVaultState): Promise<Record<string, PoolInfoForShareVault>>;
+    estimateWithdrawLiquidityFulfillmentPoolCount(vaultData: ShareVaultState, requst_vault_shares: bigint): Promise<{
+        count: number;
+        sortedPools: {
+            targetWeightRatio: number;
+            poolAddress: string;
+            availableAmount: bigint;
+            pool: any;
+        }[];
+    }>;
+    getPoolTupleSortedByTargetWeight(whitelistedPools: Record<string, WhitelistedPool>, totalAssetAmount: bigint, totalTargetWeight: bigint, poolInfoForShareVault: Record<string, PoolInfoForShareVault>): {
+        targetWeightRatio: number;
+        poolAddress: string;
+        availableAmount: bigint;
+        pool: any;
+    }[];
+    WTON: {
+        unwrap: (sender: Sender, params: {
+            amount: bigint;
+            sender: Address | string;
+            recipient: Address | string;
+        }) => Promise<void>;
+        wrap: (sender: Sender, params: {
+            amount: bigint;
+            recipient: Address | string;
+        }) => Promise<void>;
+    };
+}
+export {};