@affluent-org/sdk 0.0.3 → 0.0.4

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

@@ -87,4 +87,41 @@ export declare class ShareVaultServiceV1 {
         forwardPayload: import("@ton/core").Cell;
         queryId: bigint | undefined;
     }>;
+    getValuationContext(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, query.PoolInfoForShareVault>;
+        netAmount: bigint;
+        exr: number;
+    }>;
+    getEXR(vaultAddress: AddressInput): Promise<number>;
 }

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

@@ -127,5 +127,11 @@ class ShareVaultServiceV1 {
     async sendWithdraw(sender, params, value) {
         return (0, send_msg_1.sendMsg)(sender, user.createWithdrawMsg(this.ctx, sender, params, value));
     }
+    async getValuationContext(vaultAddress) {
+        return query.getValuationContext(this.ctx, vaultAddress);
+    }
+    async getEXR(vaultAddress) {
+        return query.getEXR(this.ctx, vaultAddress);
+    }
 }
 exports.ShareVaultServiceV1 = ShareVaultServiceV1;

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

@@ -137,7 +137,7 @@ export declare function splitPureAndVaultAsset(ctx: AffluentContext, addresses:
     vaultAssetAddresses: string[];
     pureAssetAddresses: string[];
 }>;
-export declare function getPoolInfoForStrategyVault(ctx: AffluentContext, strategyVaultAddress: AddressInput): Promise<Record<string, PoolState>>;
+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;

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

@@ -7,7 +7,7 @@ exports.getRFQAuctionAddress = getRFQAuctionAddress;
 exports.getRFQAuction = getRFQAuction;
 exports.isVaultAsset = isVaultAsset;
 exports.splitPureAndVaultAsset = splitPureAndVaultAsset;
-exports.getPoolInfoForStrategyVault = getPoolInfoForStrategyVault;
+exports.getPoolDataForStrategyVault = getPoolDataForStrategyVault;
 exports.getPoolPositionsForStrategyVault = getPoolPositionsForStrategyVault;
 exports.getValuationContext = getValuationContext;
 exports.getPrice = getPrice;
@@ -65,19 +65,21 @@ async function splitPureAndVaultAsset(ctx, addresses) {
         pureAssetAddresses,
     };
 }
-async function getPoolInfoForStrategyVault(ctx, strategyVaultAddress) {
+async function getPoolDataForStrategyVault(ctx, strategyVaultAddress) {
     const vaultData = await getVault(ctx, strategyVaultAddress).getVaultData();
-    return Object.fromEntries(await Promise.all(Object.keys(vaultData.factorialPools)
-        .map(async (poolAddress) => {
-        const poolData = await ctx.getByContract(pool_1.Pool, core_1.Address.parse(poolAddress)).getPoolData();
-        return [poolAddress, poolData];
-    })));
+    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 getPoolInfoForStrategyVault(ctx, strategyVaultAddress);
+    const poolDatas = await getPoolDataForStrategyVault(ctx, strategyVaultAddress);
     for (const [poolAddress, poolPosition] of Object.entries(vaultData.factorialPools)) {
         const poolData = poolDatas[poolAddress];
         const position = {};
@@ -118,9 +120,12 @@ async function getPrice(ctx, strategyVaultAddress) {
 }
 async function getUnderlyingPrices(ctx, strategyVaultAddress) {
     const valuationCtx = await getValuationContext(ctx, strategyVaultAddress);
-    const priceInfoEntries = Object.entries(valuationCtx.priceInfo);
-    const underlyingPriceEntries = priceInfoEntries
-        .filter(([assetAddress, _]) => valuationCtx.storage.assets[assetAddress])
-        .map(([assetAddress, priceInfo]) => [assetAddress, priceInfo.price]);
+    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/types/address.d.ts

@@ -0,0 +1,7 @@
+export type Brand<T, B> = T & {
+    readonly __brand: B;
+};
+export type AssetAddress = Brand<string, 'AssetAddress'>;
+export type PoolAddress = Brand<string, 'PoolAddress'>;
+export type PoolAccountAddress = Brand<string, 'PoolAccountAddress'>;
+export type VaultAddress = Brand<string, 'VaultAddress'>;

package/dist/types/address.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@affluent-org/sdk",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "affluent-sdk",
   "main": "dist/index.js",
   "scripts": {