@evaafi/sdk 0.7.0 → 0.9.0

package/src/contracts/PythMaster.ts

@@ -0,0 +1,313 @@
+import { HexString } from '@pythnetwork/hermes-client';
+import { Address, beginCell, Cell, ContractProvider, Dictionary, Sender, SendMode } from '@ton/core';
+import { PythOracleInfo, PythOracleParser } from '../api/parsers/PythOracleParser';
+import { composeFeedsCell, packPythUpdatesData } from '../api/prices';
+import { TON_MAINNET } from '../constants';
+import { FEES, OPCODES } from '../constants/general';
+import { isTonAsset } from '../utils/utils';
+import {
+    AbstractEvaaMaster,
+    BaseMasterConfig,
+    BaseMasterData,
+    EvaaParameters,
+    LiquidationInnerParameters,
+    LiquidationOperationBuilderParameters,
+    LiquidationParameters,
+    SupplyWithdrawParameters,
+    WithdrawParameters,
+} from './AbstractMaster';
+
+/**
+ * pyth specific parameters
+ */
+export type PythBaseData = {
+    priceData: Buffer | Cell;
+    targetFeeds: HexString[];
+    requestedRefTokens: bigint[];
+};
+
+export type ProxySpecificPythParams = {
+    pythAddress: Address;
+    minPublishTime: number | bigint;
+    maxPublishTime: number | bigint;
+};
+
+export type OnchainSpecificPythParams = {
+    publishGap: number | bigint;
+    maxStaleness: number | bigint;
+};
+
+export type JettonPythParams = PythBaseData & OnchainSpecificPythParams;
+
+export type TonPythParams = PythBaseData & ProxySpecificPythParams;
+
+export type PythProxyParams = {
+    pyth: PythBaseData & (ProxySpecificPythParams | OnchainSpecificPythParams) & { pythAddress: Address };
+};
+
+export type PythSupplyWithdrawParameters = SupplyWithdrawParameters & Partial<PythProxyParams>;
+
+export type PythWithdrawParameters = WithdrawParameters & {
+    pyth: TonPythParams;
+};
+
+export type PythLiquidationOperationParameters = LiquidationOperationBuilderParameters &
+    LiquidationInnerParameters &
+    PythProxyParams;
+
+export type PythLiquidationParameters = LiquidationParameters & PythLiquidationOperationParameters;
+
+// Specific master configurations
+export type PythMasterConfig = BaseMasterConfig & {
+    oraclesInfo: PythOracleInfo;
+};
+
+// Specific master data types
+export type PythMasterData = BaseMasterData & {
+    masterConfig: PythMasterConfig;
+};
+
+export class EvaaMasterPyth extends AbstractEvaaMaster<PythMasterData> {
+    constructor(parameters: EvaaParameters) {
+        super(parameters);
+    }
+
+    protected buildPythMasterMessage(
+        args: {
+            queryId: number | bigint;
+            opCode: number | bigint;
+            updateDataCell: Cell;
+            targetFeedsCell: Cell;
+            publishGap: number | bigint;
+            maxStaleness: number | bigint;
+        },
+        operationPayload: Cell,
+    ): Cell {
+        return beginCell()
+            .storeUint(args.opCode, 32)
+            .storeUint(args.queryId, 64)
+            .storeRef(
+                beginCell()
+                    .storeRef(args.updateDataCell)
+                    .storeRef(args.targetFeedsCell)
+                    .storeUint(args.publishGap, 64)
+                    .storeUint(args.maxStaleness, 64)
+                    .endCell(),
+            )
+            .storeRef(operationPayload)
+            .endCell();
+    }
+
+    protected buildPythProxyMessage(
+        targetAddress: Address,
+        priceUpdateData: Cell,
+        targetPythFeeds: Cell,
+        minPublishTime: number | bigint,
+        maxPublishTime: number | bigint,
+        operationPayload: Cell,
+    ): Cell {
+        return beginCell()
+            .storeUint(5, 32) // pyth::op_parse_price_feed_updates
+            .storeRef(priceUpdateData)
+            .storeRef(targetPythFeeds)
+            .storeUint(minPublishTime, 64)
+            .storeUint(maxPublishTime, 64)
+            .storeAddress(targetAddress)
+            .storeRef(operationPayload)
+            .endCell();
+    }
+
+    // TODO: support without OPCODES.SUPPLY_WITHDRAW_MASTER_WITHOUT_PRICES
+    createSupplyWithdrawMessage(parameters: PythSupplyWithdrawParameters): Cell {
+        const operationPayload = this.buildSupplyWithdrawOperationPayload(parameters);
+
+        if (!isTonAsset(parameters.supplyAsset)) {
+            const { priceData, targetFeeds, publishGap, maxStaleness } = parameters.pyth as JettonPythParams;
+            const masterMessage = this.buildPythMasterMessage(
+                {
+                    queryId: parameters.queryID,
+                    opCode: OPCODES.SUPPLY_WITHDRAW_MASTER_JETTON,
+                    updateDataCell: packPythUpdatesData(priceData),
+                    targetFeedsCell: composeFeedsCell(targetFeeds),
+                    publishGap,
+                    maxStaleness,
+                },
+                operationPayload,
+            );
+
+            return this.createJettonTransferMessage(parameters, FEES.SUPPLY_WITHDRAW, masterMessage);
+        } else {
+            const { priceData, targetFeeds, minPublishTime, maxPublishTime } = parameters.pyth as TonPythParams;
+            const wrappedOperationPayload = beginCell()
+                .storeUint(OPCODES.SUPPLY_WITHDRAW_MASTER, 32)
+                .storeUint(parameters.queryID, 64)
+                .storeRef(operationPayload)
+                .endCell();
+            return this.buildPythProxyMessage(
+                this.address,
+                packPythUpdatesData(priceData),
+                composeFeedsCell(targetFeeds),
+                minPublishTime,
+                maxPublishTime,
+                wrappedOperationPayload,
+            );
+        }
+    }
+
+    // private createPythWithdrawMessage(parameters: PythWithdrawParameters): Cell {
+    //     const extraTail =
+    //         (parameters.subaccountId ?? 0) == 0
+    //             ? beginCell().endCell()
+    //             : beginCell()
+    //                   .storeInt(parameters.subaccountId ?? 0, 16)
+    //                   .storeUint(0, 2)
+    //                   .endCell();
+
+    //     const wrappedOperationPayload = beginCell()
+    //         .storeUint(OPCODES.SUPPLY_WITHDRAW_MASTER, 32) // op_code: 0x4
+    //         .storeUint(parameters.queryID, 64)
+    //         .storeRef(
+    //             beginCell()
+    //                 .storeUint(parameters.asset.assetId, 256)
+    //                 .storeUint(parameters.amount, 64)
+    //                 .storeAddress(parameters.userAddress)
+    //                 .storeInt(parameters.includeUserCode ? -1 : 0, 2)
+    //                 .storeUint(parameters.amountToTransfer, 64)
+    //                 .storeRef(parameters.payload)
+    //                 .storeSlice(extraTail.beginParse())
+    //                 .endCell(),
+    //         )
+    //         .endCell();
+
+    //     const { priceData, targetFeeds, minPublishTime, maxPublishTime } = parameters.pyth as TonPythParams;
+
+    //     return makePythProxyMessage(
+    //         this.address,
+    //         packPythUpdatesData(priceData),
+    //         composeFeedsCell(targetFeeds),
+    //         minPublishTime,
+    //         maxPublishTime,
+    //         wrappedOperationPayload,
+    //     );
+    // }
+
+    buildRefTokensDict(requestedRefTokens: bigint[]): Dictionary<bigint, Buffer> {
+        const refsDict: Dictionary<bigint, Buffer> = Dictionary.empty(
+            Dictionary.Keys.BigUint(256),
+            Dictionary.Values.Buffer(0),
+        );
+        for (const refToken of requestedRefTokens) {
+            refsDict.set(refToken, Buffer.alloc(0));
+        }
+
+        return refsDict;
+    }
+
+    buildGeneralDataPayload(parameters: PythSupplyWithdrawParameters): Cell {
+        const refTokensDict = this.buildRefTokensDict(parameters.pyth?.requestedRefTokens ?? []);
+        return beginCell()
+            .storeInt(parameters.includeUserCode ? -1 : 0, 2)
+            .storeDict(refTokensDict, Dictionary.Keys.BigUint(256), Dictionary.Values.Buffer(0))
+            .storeUint(parameters.tonForRepayRemainings ?? 0n, 64)
+            .storeRef(parameters.payload)
+            .storeInt(parameters.subaccountId ?? 0, 16)
+            .storeInt(parameters.returnRepayRemainingsFlag ? -1 : 0, 2)
+            .storeInt(parameters.customPayloadSaturationFlag ? -1 : 0, 2)
+            .endCell();
+    }
+
+    async sendWithdraw(
+        provider: ContractProvider,
+        via: Sender,
+        value: bigint,
+        parameters: PythWithdrawParameters,
+    ): Promise<void> {
+        const message = this.createSupplyWithdrawMessage({
+            supplyAsset: TON_MAINNET,
+            supplyAmount: 0n,
+            queryID: parameters.queryID,
+            withdrawAsset: parameters.asset,
+            withdrawAmount: parameters.amount,
+            withdrawRecipient: parameters.userAddress,
+            includeUserCode: parameters.includeUserCode,
+            forwardAmount: parameters.forwardAmount,
+            payload: parameters.payload,
+            subaccountId: parameters.subaccountId ?? 0,
+            customPayloadSaturationFlag: parameters.customPayloadSaturationFlag ?? false,
+            returnRepayRemainingsFlag: parameters.returnRepayRemainingsFlag ?? false,
+            tonForRepayRemainings: 0n,
+            pyth: parameters.pyth,
+        });
+        await via.send({
+            value,
+            to: parameters.pyth.pythAddress,
+            sendMode: SendMode.PAY_GAS_SEPARATELY + SendMode.IGNORE_ERRORS,
+            body: message,
+        });
+    }
+
+    protected buildLiquidationOperationPayload(parameters: PythLiquidationOperationParameters): Cell {
+        const operationPayloadBuilder = this.buildLiquidationOperationPayloadBuilder(parameters);
+        const innerBuilder = this.buildLiquidationInnerBuilder(parameters);
+
+        const refTokensDict = this.buildRefTokensDict(parameters.pyth.requestedRefTokens);
+
+        return operationPayloadBuilder.storeDict(refTokensDict).storeRef(innerBuilder).endCell();
+    }
+
+    createLiquidationMessage(parameters: PythLiquidationParameters): Cell {
+        const isTon = isTonAsset(parameters.asset);
+
+        const operationPayload = this.buildLiquidationOperationPayload(parameters);
+
+        if (!isTon) {
+            const { priceData, targetFeeds, publishGap, maxStaleness } =
+                parameters.pyth as OnchainSpecificPythParams & { priceData: Buffer | Cell; targetFeeds: HexString[] };
+            const masterMessage = this.buildPythMasterMessage(
+                {
+                    queryId: parameters.queryID,
+                    opCode: OPCODES.LIQUIDATE_MASTER,
+                    updateDataCell: packPythUpdatesData(priceData as Buffer | Cell),
+                    targetFeedsCell: composeFeedsCell(targetFeeds),
+                    publishGap,
+                    maxStaleness,
+                },
+                operationPayload,
+            );
+            return this.createJettonTransferMessage(parameters, FEES.LIQUIDATION_JETTON_FWD, masterMessage);
+        } else {
+            const { priceData, targetFeeds, minPublishTime, maxPublishTime } = parameters.pyth as TonPythParams & {
+                priceData: Buffer | Cell;
+                targetFeeds: HexString[];
+            };
+            const wrappedOperationPayload = beginCell()
+                .storeUint(OPCODES.LIQUIDATE_MASTER, 32)
+                .storeUint(parameters.queryID, 64)
+                .storeRef(operationPayload)
+                .endCell();
+            return this.buildPythProxyMessage(
+                this.address,
+                packPythUpdatesData(priceData as Buffer | Cell),
+                composeFeedsCell(targetFeeds),
+                minPublishTime,
+                maxPublishTime,
+                wrappedOperationPayload,
+            );
+        }
+    }
+
+    async sendLiquidation(
+        provider: ContractProvider,
+        via: Sender,
+        value: bigint,
+        parameters: PythLiquidationParameters,
+    ): Promise<void> {
+        const message = this.createLiquidationMessage(parameters);
+
+        await this.sendTx(provider, via, value, message, parameters.asset);
+    }
+
+    async getSync(provider: ContractProvider) {
+        await this.syncMasterData(provider, new PythOracleParser());
+    }
+}

package/src/contracts/UserContract.ts

@@ -1,11 +1,9 @@
 import { Address, beginCell, Cell, Contract, ContractProvider, Dictionary, Sender, SendMode } from '@ton/core';
-import { UserData, UserLiteData } from '../types/User';
 import { parseUserData, parseUserLiteData } from '../api/parser';
-import { ExtendedAssetsConfig, ExtendedAssetsData, PoolConfig } from '../types/Master';
-import { LiquidationBaseData } from './MasterContract';
 import { OPCODES } from '../constants/general';
 import { MAINNET_POOL_CONFIG } from '../constants/pools';
-import { TON_MAINNET } from '../constants/assets';
+import { ExtendedAssetsConfig, ExtendedAssetsData, PoolConfig } from '../types/Master';
+import { UserData, UserLiteData } from '../types/User';
 
 /**
  * User contract wrapper
@@ -35,7 +33,7 @@ export class EvaaUser implements Contract {
         provider: ContractProvider,
         assetsData: ExtendedAssetsData,
         assetsConfig: ExtendedAssetsConfig,
-        applyDust: boolean = false
+        applyDust: boolean = false,
     ) {
         const state = (await provider.getState()).state;
         if (state.type === 'active') {
@@ -44,7 +42,7 @@ export class EvaaUser implements Contract {
                 assetsData,
                 assetsConfig,
                 this.poolConfig,
-                applyDust
+                applyDust,
             );
             this.lastSync = Math.floor(Date.now() / 1000);
         } else {
@@ -87,7 +85,7 @@ export class EvaaUser implements Contract {
             value,
             sendMode: SendMode.PAY_GAS_SEPARATELY + SendMode.IGNORE_ERRORS,
             body: beginCell()
-                .storeCoins(BigInt(OPCODES.ONCHAIN_GETTER))
+                .storeUint(OPCODES.ONCHAIN_GETTER, 32)
                 .storeUint(queryID, 64)
                 .storeRef(forwardPayload)
                 .endCell(),
@@ -99,7 +97,7 @@ export class EvaaUser implements Contract {
         assetsData: ExtendedAssetsData,
         assetsConfig: ExtendedAssetsConfig,
         prices: Dictionary<bigint, bigint>,
-        applyDust: boolean = false
+        applyDust: boolean = false,
     ) {
         const state = (await provider.getState()).state;
         if (state.type === 'active') {
@@ -108,7 +106,7 @@ export class EvaaUser implements Contract {
                 assetsData,
                 assetsConfig,
                 this.poolConfig,
-                applyDust
+                applyDust,
             );
             this._data = parseUserData(this._liteData, assetsData, assetsConfig, prices, this.poolConfig, applyDust);
             this.lastSync = Math.floor(Date.now() / 1000);
@@ -144,23 +142,4 @@ export class EvaaUser implements Contract {
 
         return this._data.liquidationData.liquidable;
     }
-
-    /**
-     * Get liquidation parameters for passing to liquidation message
-     * @returns liquidation parameters if user is liquidable, otherwise undefined
-     */
-    get liquidationParameters(): LiquidationBaseData | undefined {
-        if (!this._data || this._data.type === 'inactive' || !this._data.liquidationData.liquidable) {
-            return undefined;
-        }
-
-        return {
-            borrowerAddress: this._data.ownerAddress,
-            loanAsset: this._data.liquidationData.greatestLoanAsset.assetId,
-            collateralAsset: this._data.liquidationData.greatestCollateralAsset.assetId,
-            minCollateralAmount: this._data.liquidationData.minCollateralAmount,
-            liquidationAmount: this._data.liquidationData.liquidationAmount,
-            tonLiquidation: this._data.liquidationData.greatestLoanAsset.assetId === TON_MAINNET.assetId,
-        };
-    }
 }

package/src/contracts/index.ts

@@ -0,0 +1,7 @@
+export * from './AbstractMaster';
+export * from './ClassicMaster';
+export * from './PythMaster';
+
+export * from './UserContract';
+
+export * from './JettonWallet';

package/src/index.ts

@@ -1,102 +1,35 @@
 // Math
-export {
-    mulFactor,
-    mulDiv,
-    bigIntMin,
-    bigIntMax,
-    calculatePresentValue,
-    calculateCurrentRates,
-    calculateAssetData,
-    calculateAssetInterest,
-    getAvailableToBorrow,
-    calculateMaximumWithdrawAmount,
-    presentValue,
-    calculateLiquidationData,
-    predictHealthFactor,
-    calculateHealthParams,
-    calculateInterestWithSupplyBorrow,
-    predictAPY,
-    BigMath,
-    getAssetLiquidityMinusReserves,
-} from './api/math';
+export * from './api/math';
 
-export {
-    calculateLiquidationAmounts,
-    calculateMinCollateralByTransferredAmount,
-    isLiquidatable,
-    isBadDebt,
-    addReserve,
-    deductReserve,
-    addLiquidationBonus,
-    deductLiquidationBonus,
-    toAssetAmount,
-    toAssetWorth,
-    PreparedAssetInfo,
-    PreparedAssetInfoResult,
-    prepareAssetInfo,
-    findAssetById,
-    selectGreatestAssets,
-    calculateAssetsValues,
-    AssetsValues,
-    SelectedAssets,
-} from './api/liquidation';
+export * from './api/liquidation';
 
 // Parser
-export { createAssetData, createAssetConfig, parseMasterData, parseUserData, parseUserLiteData } from './api/parser';
+export * from './api/parser';
+
+// Oracles
+export * from './api/parsers';
 
 // Prices
-export { getPrices } from './api/prices';
+export * from './api/prices';
+
+// Feeds utils
+export * from './api/feeds';
 
 // Contracts' wrappers
-export { JettonWallet } from './contracts/JettonWallet';
-export {
-    EvaaParameters,
-    WithdrawParameters,
-    LiquidationBaseData,
-    LiquidationParameters,
-    Evaa
-} from './contracts/MasterContract';
-export { EvaaUser } from './contracts/UserContract';
+export * from './contracts';
 
 // Rewards contracts wrappers
+export { EvaaUserRewards } from './rewards/EvaaRewards';
+export { JettonMinter as RewardJettonMinter, type JettonMinterConfig, type MintMessage } from './rewards/JettonMinter';
+export { JettonWallet as RewardJettonWallet, type JettonWalletConfig } from './rewards/JettonWallet';
 export { RewardMaster } from './rewards/RewardMaster';
-export { type EvaaRewardsConfig } from './types/MasterRewards';
 export { RewardUser } from './rewards/RewardUser';
+export { type EvaaRewardsConfig } from './types/MasterRewards';
 export { type EvaaUserRewardsConfig } from './types/UserRewards';
-export { JettonMinter as RewardJettonMinter, type JettonMinterConfig, type MintMessage } from './rewards/JettonMinter';
-export { JettonWallet as RewardJettonWallet, type JettonWalletConfig } from './rewards/JettonWallet';
-export { EvaaUserRewards } from './rewards/EvaaRewards';
 
 // Types
-export {
-    UpgradeConfig,
-    AssetConfig,
-    MasterConfig,
-    AssetData,
-    AssetInterest,
-    AssetApy,
-    ExtendedAssetData,
-    MasterData,
-    PoolConfig,
-    ExtendedAssetsData,
-    ExtendedAssetsConfig,
-    PoolAssetConfig,
-    PoolAssetsConfig,
-    MasterConstants
-} from './types/Master';
-
-export {
-    BalanceType,
-    UserBalance,
-    UserLiqudationData,
-    LiquidableData,
-    NonLiquidableData,
-    LiquidationData,
-    UserDataInactive,
-    UserDataActive,
-    UserData,
-    BalanceChangeType
-} from './types/User';
+export * from './types/Master';
+export * from './types/User';
 
 // Constants
 export * from './constants/general';
@@ -104,8 +37,8 @@ export * from './constants/general';
 export * from './constants/pools';
 
 export * from './constants/assets';
-export * from './utils/utils';
 export * from './prices';
+export * from './utils/utils';
 
 // Utils
 export { getLastSentBoc, getTonConnectSender } from './utils/tonConnectSender';

package/src/prices/Oracle.interface.ts

@@ -0,0 +1,18 @@
+import { Dictionary } from '@ton/core';
+import { Prices } from '.';
+import { PoolAssetConfig, PoolAssetsConfig } from '../types/Master';
+import { FetchConfig } from '../utils/utils';
+
+export interface Oracle {
+    getPricesForLiquidate(realPrincipals: Dictionary<bigint, bigint>, fetchConfig?: FetchConfig): Promise<Prices>;
+
+    getPricesForSupplyWithdraw(
+        realPrincipals: Dictionary<bigint, bigint>,
+        supplyAsset: PoolAssetConfig | undefined,
+        withdrawAsset: PoolAssetConfig | undefined,
+        collateralToDebt: boolean,
+        fetchConfig?: FetchConfig,
+    ): Promise<Prices>;
+
+    getPrices(assets: PoolAssetsConfig, fetchConfig?: FetchConfig): Promise<Prices>;
+}

package/src/prices/Prices.ts

@@ -1,12 +1,17 @@
-import { Cell, Dictionary } from "@ton/core";
-import { PoolAssetConfig } from "../types/Master";
+import { Cell, Dictionary } from '@ton/core';
+import { PoolAssetConfig } from '../types/Master';
 
 export class Prices {
     #dict: Dictionary<bigint, bigint>;
     #dataCell: Cell;
-    constructor(dict: Dictionary<bigint, bigint>, dataCell: Cell) {
+    #minPublishTime?: bigint;
+    #maxPublishTime?: bigint;
+
+    constructor(dict: Dictionary<bigint, bigint>, dataCell: Cell, minPublishTime?: bigint, maxPublishTime?: bigint) {
         this.#dict = dict;
         this.#dataCell = dataCell;
+        this.#minPublishTime = minPublishTime;
+        this.#maxPublishTime = maxPublishTime;
     }
 
     get dict() {
@@ -21,6 +26,14 @@ export class Prices {
         return new Cell(this.#dataCell);
     }
 
+    get minPublishTime(): bigint | undefined {
+        return this.#minPublishTime;
+    }
+
+    get maxPublishTime(): bigint | undefined {
+        return this.#maxPublishTime;
+    }
+
     getAssetPrice<T extends bigint | PoolAssetConfig>(asset: T): bigint | undefined {
         const assetId = this.#extractAssetId(asset);
         return this.#dict.get(assetId);
@@ -29,4 +42,4 @@ export class Prices {
     #extractAssetId(asset: bigint | PoolAssetConfig): bigint {
         return typeof asset === 'bigint' ? asset : asset.assetId;
     }
-}
+}