@affluent-org/sdk 0.0.2 → 0.0.3

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 getPoolInfoForStrategyVault(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.getPoolInfoForStrategyVault = getPoolInfoForStrategyVault;
+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,62 @@ async function splitPureAndVaultAsset(ctx, addresses) {
         pureAssetAddresses,
     };
 }
+async function getPoolInfoForStrategyVault(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];
+    })));
+}
+async function getPoolPositionsForStrategyVault(ctx, strategyVaultAddress) {
+    const strategyVault = getVault(ctx, strategyVaultAddress);
+    const vaultData = await strategyVault.getVaultData();
+    const poolInfo = {};
+    const poolDatas = await getPoolInfoForStrategyVault(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 priceInfoEntries = Object.entries(valuationCtx.priceInfo);
+    const underlyingPriceEntries = priceInfoEntries
+        .filter(([assetAddress, _]) => valuationCtx.storage.assets[assetAddress])
+        .map(([assetAddress, priceInfo]) => [assetAddress, priceInfo.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 {};