@affluent-org/sdk 0.0.2 → 0.0.3

package/dist/pool.d.ts

@@ -0,0 +1,216 @@
+import { Address, Cell, Sender } from "@ton/ton";
+import { PoolState } from "./contracts/core/pool/type";
+import { OnchainDataInfo } from "./contracts/oracle/redstone-onchain-oracle/type";
+import { LiquidateActionParams, TransferInActionParams, TansferOutActionParams } from "./types/action";
+import { TxCallBackFn, TxStep } from "./utils/tracker/type";
+import { AssetPriceInfo } from "./contracts/oracle/redstone-onchain-oracle/type";
+import { AccountAssetState, AccountState } from "./contracts/core/account/type";
+import { ServiceBaseV1 } from "./common/service";
+import { MaxBorrowableResult, MaxWithdrawableResult } from "./types/pool";
+export declare class PoolV1 extends ServiceBaseV1 {
+    private walletAddresses;
+    private accountAddresses;
+    private getJettonWalletAddress;
+    getAccountAddress(owner: string, pool: string): Promise<Address>;
+    findAndCallback(target: Address, step: TxStep, createdLt: string | bigint, callbackFn?: TxCallBackFn): Promise<import("./utils/tracker/type").MatchedTxResult>;
+    supply(sender: Sender, params: TransferInActionParams): Promise<void>;
+    supplyAndWaitTx(sender: Sender, params: TransferInActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: TransferInActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    findTx(action: any, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: TransferInActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    } | undefined>;
+    findSupplyTx(queryId: bigint, params: TransferInActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: TransferInActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    withdraw(sender: Sender, params: TansferOutActionParams): Promise<void>;
+    withdrawAndWaitTx(sender: Sender, params: TansferOutActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: TansferOutActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    findWithdrawTx(queryId: bigint, params: TansferOutActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: TansferOutActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    borrow(sender: Sender, params: TansferOutActionParams): Promise<void>;
+    borrowAndWaitTx(sender: Sender, params: TansferOutActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: TansferOutActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    findBorrowTx(queryId: bigint, params: TansferOutActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: TansferOutActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    repay(sender: Sender, params: TransferInActionParams): Promise<void>;
+    repayAndWaitTx(sender: Sender, params: TransferInActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: TransferInActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    findRepayTx(queryId: bigint, params: TransferInActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: TransferInActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    liquidateSimulate(params: LiquidateActionParams): Promise<void>;
+    liquidateAndWaitTxSimulate(queryId: bigint, params: LiquidateActionParams, callbackFn?: TxCallBackFn): Promise<TxStep[]>;
+    liquidate(sender: Sender, params: LiquidateActionParams): Promise<void>;
+    liquidateAndWaitTx(sender: Sender, params: LiquidateActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: LiquidateActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    updateOnchainData(onchainDataInfo: OnchainDataInfo): Promise<OnchainDataInfo>;
+    getRedstonePrices(assets: string[], poolData: any): Promise<{
+        redstonePrices: AssetPriceInfo;
+        onchainData: any;
+    }>;
+    calculatePrices(_prices: AssetPriceInfo, oracleData: any): AssetPriceInfo;
+    decomposeAccountStatus(accountStatus: Record<string, AccountAssetState>, prices: AssetPriceInfo, onchainData: OnchainDataInfo): Record<string, Omit<AccountAssetState, "address">>;
+    calculateRisk(decomposedAccountStatus: Record<string, Omit<AccountAssetState, "address">>, prices: AssetPriceInfo, poolData: PoolState): {
+        result: boolean;
+        healthy: boolean;
+        unhealthy: boolean;
+        collateral: bigint;
+        debt: bigint;
+        risk: bigint;
+        riskRatio: bigint;
+        leverageRatio: bigint;
+    };
+    getOracleRequestParams(assets: string[], oracleConfig: any): Promise<{
+        feedIds: bigint[];
+        redstoneAssetNames: any[];
+        requestAssets: Address[];
+        redstoneAssets: Address[];
+    }>;
+    isHealthy(poolAddress: Address | string, ownerAddress: Address | string, delta?: Record<string, AccountAssetState>): Promise<{
+        result: boolean;
+        healthy: boolean;
+        unhealthy: boolean;
+        collateral: bigint;
+        debt: bigint;
+        risk: bigint;
+        riskRatio: bigint;
+        leverageRatio: bigint;
+    }>;
+    isHealthyV2(_poolData: PoolState, _accountData: Record<string, AccountAssetState>, prices: any): {
+        result: boolean;
+        healthy: boolean;
+        unhealthy: boolean;
+        collateral: bigint;
+        debt: bigint;
+        risk: bigint;
+        riskRatio: bigint;
+        leverageRatio: bigint;
+    };
+    getPrices(poolAddress: Address | string): Promise<{
+        [x: string]: import("./contracts/oracle/redstone-onchain-oracle/type").AssetPrice | {
+            price: bigint;
+            type: number;
+            additionalData: {
+                decomposed: Record<string, {
+                    supply: bigint;
+                    borrow: bigint;
+                }>;
+                totalSupply: bigint;
+            };
+        };
+    }>;
+    getPricesV2(poolAddress: Address | string): Promise<{
+        [x: string]: import("./contracts/oracle/redstone-onchain-oracle/type").AssetPrice | {
+            price: bigint;
+            type: number;
+            additionalData: {
+                decomposed: Record<string, {
+                    supply: bigint;
+                    borrow: bigint;
+                }>;
+                totalSupply: bigint;
+            };
+        };
+    }>;
+    calculateVaultPrices(price: AssetPriceInfo, poolInfos: Record<string, PoolState>, vaults: Record<string, VaultPosition>): Promise<Record<string, {
+        price: bigint;
+        type: number;
+        additionalData: {
+            decomposed: Record<string, {
+                supply: bigint;
+                borrow: bigint;
+            }>;
+            totalSupply: bigint;
+        };
+    }>>;
+    getParsedVaults(vaultAddresses: (Address | string)[]): Promise<Record<string, VaultPosition>>;
+    getExposures(vaults: Record<string, VaultPosition>): Promise<{
+        pools: string[];
+        assets: string[];
+    }>;
+    calculateMaxBorrowableAmount({ borrowerAddress, poolAddress, tokenAddress, BUFFER, }: {
+        borrowerAddress: Address;
+        poolAddress: Address;
+        tokenAddress: string;
+        BUFFER?: bigint;
+    }): Promise<MaxBorrowableResult>;
+    calculateMaxWithdrawableAmount({ withdrawerAddress, poolAddress, tokenAddress, BUFFER, }: {
+        withdrawerAddress: Address;
+        poolAddress: Address;
+        tokenAddress: string;
+        BUFFER?: bigint;
+    }): Promise<MaxWithdrawableResult>;
+    getPoolData(poolAddress: Address | string): Promise<PoolState>;
+    getAccountData(poolAddress: Address | string, userAddress: Address | string): Promise<AccountState>;
+    separateAssets(_assets: string[], oracleConfig: any): Promise<{
+        assets: string[];
+        vaultAssets: string[];
+    }>;
+    getPoolOracleParams(poolAddress: Address | string, actor: Address | string, executeAsset: Address | string): Promise<Cell>;
+}
+type VaultPosition = {
+    assets: Record<string, bigint>;
+    poolPositions: Record<string, Record<string, {
+        supply: bigint;
+        borrow: bigint;
+    }>>;
+    totalSupply: bigint;
+};
+export {};