@evaafi/sdk 0.9.0-a → 0.9.1

package/dist/contracts/AbstractMaster.js

@@ -9,38 +9,82 @@ const userJettonWallet_1 = require("../utils/userJettonWallet");
 const JettonWallet_1 = require("./JettonWallet");
 const UserContract_1 = require("./UserContract");
 /**
- * Abstract EVAA Master base that encapsulates shared logic and structure.
- * Concrete implementations (Classic/Pyth) should override message creation for
- * withdraw/liquidation and supply-withdraw wrapping.
+ * Abstract base class for EVAA Master contracts
+ *
+ * This class provides shared functionality for both Classic and Pyth master implementations,
+ * including message creation, validation, and transaction handling. Concrete implementations
+ * must override oracle-specific methods for withdraw/liquidation operations.
+ *
+ * @template T - Master data type extending MasterData with specific oracle configuration
+ * @abstract
+ * @implements {Contract}
  */
 class AbstractEvaaMaster {
+    /**
+     * Initialize the abstract master contract
+     * @param parameters - Configuration parameters for the Evaa master
+     */
     constructor(parameters) {
         this.lastSync = 0;
         this._poolConfig = parameters.poolConfig;
         this.address = this._poolConfig.masterAddress;
         this.debug = parameters?.debug;
     }
+    /**
+     * Get the current pool configuration
+     * @returns {PoolConfig} The pool configuration object
+     */
     get poolConfig() {
         return this._poolConfig;
     }
+    /**
+     * Get the synchronized master data
+     * @returns {T | undefined} Master data if available, undefined otherwise
+     */
     get data() {
         return this._data;
     }
-    // ---------- Common helpers ----------
-    createJettonTransferMessage(parameters, defaultFees, message) {
+    // ========== VALIDATION METHODS ==========
+    /**
+     * Validates jetton parameters ensuring at least one amount field is provided
+     * @private
+     * @static
+     * @param parameters - Jetton parameters to validate
+     * @returns {ValidJettonParams} Validated parameters
+     * @throws {Error} When no amount fields are provided
+     */
+    static validateJettonParams(parameters) {
         if (parameters.amount == undefined &&
             parameters.liquidationAmount == undefined &&
             parameters.supplyAmount == undefined) {
-            throw new Error('Either amount or liquidationAmount or supplyAmount must be provided');
+            throw new Error(`JettonParams validation failed: ${general_1.VALIDATION.ERRORS.MISSING_JETTON_AMOUNT}`);
+        }
+        return parameters;
+    }
+    /**
+     * Creates a jetton transfer message with the provided parameters
+     * @protected
+     * @param parameters - Jetton transfer parameters
+     * @param defaultFees - Default fee amount for the operation
+     * @param message - Operation message cell to include
+     * @returns {Cell} Complete jetton transfer message cell
+     * @throws {Error} When validation fails or required addresses are missing
+     */
+    createJettonTransferMessage(parameters, defaultFees, message) {
+        const validParams = AbstractEvaaMaster.validateJettonParams(parameters);
+        const amount = validParams.amount ?? validParams.liquidationAmount ?? validParams.supplyAmount ?? 0n;
+        const responseAddress = validParams.responseAddress ?? validParams.userAddress ?? validParams.liquidatorAddress;
+        if (!responseAddress) {
+            throw new Error(`JettonTransfer validation failed: ${general_1.VALIDATION.ERRORS.MISSING_RESPONSE_ADDRESS}`);
         }
         return (0, core_1.beginCell)()
             .storeUint(general_1.OPCODES.JETTON_TRANSFER, 32)
-            .storeUint(parameters.queryID, 64)
-            .storeCoins(parameters.amount ?? parameters.liquidationAmount ?? parameters.supplyAmount ?? 0n)
-            .storeAddress(parameters.destinationAddress ?? this.address)
-            .storeAddress(parameters.responseAddress ?? parameters.userAddress ?? parameters.liquidatorAddress)
+            .storeUint(validParams.queryID, 64)
+            .storeCoins(amount)
+            .storeAddress(validParams.destinationAddress ?? this.address)
+            .storeAddress(responseAddress)
             .storeBit(0)
-            .storeCoins(parameters.forwardAmount ?? defaultFees)
+            .storeCoins(validParams.forwardAmount ?? defaultFees)
             .storeBit(1)
             .storeRef(message)
             .endCell();
@@ -58,8 +102,27 @@ class AbstractEvaaMaster {
         const generalData = this.buildGeneralDataPayload(parameters);
         return (0, core_1.beginCell)().storeRef(supplyData).storeRef(withdrawData).storeRef(generalData).endCell();
     }
-    // ---------- Public message builders (shared) ----------
+    // ========== MESSAGE BUILDERS ==========
+    /**
+     * Validates supply operation parameters
+     * @private
+     * @static
+     * @param parameters - Supply parameters to validate
+     * @throws {Error} When amount is invalid or subaccount ID is out of range
+     */
+    static validateSupplyParameters(parameters) {
+        if (parameters.subaccountId !== undefined && !(0, __1.isValidSubaccountId)(parameters.subaccountId)) {
+            throw new Error(`Supply validation failed: ${general_1.VALIDATION.ERRORS.INVALID_SUBACCOUNT_ID}`);
+        }
+    }
+    /**
+     * Creates a supply operation message
+     * @param parameters - Supply operation parameters
+     * @returns {Cell} Complete supply message cell
+     * @throws {Error} When validation fails
+     */
     createSupplyMessage(parameters) {
+        AbstractEvaaMaster.validateSupplyParameters(parameters);
         const subaccountId = parameters.subaccountId ?? 0;
         const isTon = (0, __1.isTonAsset)(parameters.asset);
         const operationPayload = (0, core_1.beginCell)()
@@ -81,7 +144,15 @@ class AbstractEvaaMaster {
             return operationPayload;
         }
     }
-    // ---------- Sending operations ----------
+    // ========== TRANSACTION OPERATIONS ==========
+    /**
+     * Sends a supply operation to the master contract
+     * @param provider - Contract provider instance
+     * @param via - Sender instance
+     * @param value - Transaction value in nanoTON
+     * @param parameters - Supply operation parameters
+     * @throws {Error} When validation fails or transaction fails
+     */
     async sendSupply(provider, via, value, parameters) {
         const message = this.createSupplyMessage(parameters);
         await this.sendTx(provider, via, value, message, parameters.asset);
@@ -106,7 +177,15 @@ class AbstractEvaaMaster {
             .storeInt(parameters.includeUserCode ? -1 : 0, 2)
             .storeUint((0, __1.isTonAsset)(parameters.asset) ? parameters.liquidationAmount : 0, 64);
     }
-    // ---------- Read helpers ----------
+    // ========== CONTRACT INTERACTION HELPERS ==========
+    /**
+     * Calculates the user smart contract address for a given user and subaccount
+     * @param userAddress - The user's wallet address
+     * @param lendingCode - The user contract code cell
+     * @param subaccountId - Optional subaccount identifier (default: 0)
+     * @returns {Address} The calculated user contract address
+     * @throws {Error} When subaccount ID is invalid
+     */
     calculateUserSCAddr(userAddress, lendingCode, subaccountId = 0) {
         const subaccount = (0, core_1.beginCell)();
         if (subaccountId !== 0) {
@@ -129,6 +208,12 @@ class AbstractEvaaMaster {
             .endCell();
         return new core_1.Address(0, stateInit.hash());
     }
+    /**
+     * Creates a user contract instance for the given address and subaccount
+     * @param userAddress - The user's wallet address
+     * @param subaccountId - Optional subaccount identifier (default: 0)
+     * @returns {EvaaUser} User contract instance
+     */
     openUserContract(userAddress, subaccountId = 0) {
         return UserContract_1.EvaaUser.createFromAddress(this.calculateUserSCAddr(userAddress, this._poolConfig.lendingCode, subaccountId), this._poolConfig);
     }
@@ -167,12 +252,12 @@ class AbstractEvaaMaster {
         if (state.type === 'active') {
             this._data = (0, parser_1.parseMasterData)(state.data.toString('base64'), this._poolConfig.poolAssetsConfig, this._poolConfig.masterConstants, oracleParser);
             if (this._data.upgradeConfig.masterCodeVersion !== this._poolConfig.masterVersion) {
-                throw Error(`Outdated SDK pool version. It supports only master code version ${this._poolConfig.masterVersion}, but the current master code version is ${this._data.upgradeConfig.masterCodeVersion}`);
+                throw new Error(`${general_1.VALIDATION.ERRORS.OUTDATED_SDK_VERSION}. SDK supports version ${this._poolConfig.masterVersion}, but contract version is ${this._data.upgradeConfig.masterCodeVersion}`);
             }
             this.lastSync = Math.floor(Date.now() / 1000);
         }
         else {
-            throw Error('Master contract is not active');
+            throw new Error(general_1.VALIDATION.ERRORS.MASTER_CONTRACT_INACTIVE);
         }
     }
 }

package/dist/contracts/ClassicMaster.d.ts

@@ -2,26 +2,26 @@ import { Builder, Cell, ContractProvider, Sender } from '@ton/core';
 import { LiquidationParameters } from '..';
 import { ClassicOracleInfo } from '../api/parsers/ClassicOracleParser';
 import { AbstractEvaaMaster, BaseMasterConfig, BaseMasterData, EvaaParameters, LiquidationInnerParameters, LiquidationOperationBuilderParameters, SupplyWithdrawParameters, WithdrawParameters } from './AbstractMaster';
-export type ClassicSupplyWithdrawParameters = SupplyWithdrawParameters & {
-    priceData?: Cell;
-};
+export interface ClassicSupplyWithdrawParameters extends SupplyWithdrawParameters {
+    readonly priceData?: Cell;
+}
 /**
  * Parameters for the withdraw message
  * @property priceData - price data cell. Can be obtained from the getPrices function
  */
-export type ClassicWithdrawParameters = WithdrawParameters & {
-    priceData: Cell;
-};
+export interface ClassicWithdrawParameters extends WithdrawParameters {
+    readonly priceData?: Cell;
+}
 export type ClassicLiquidationOperationParameters = LiquidationOperationBuilderParameters & LiquidationInnerParameters & {
     priceData: Cell;
 };
 export type ClassicLiquidationParameters = LiquidationParameters & ClassicLiquidationOperationParameters;
-export type ClassicMasterConfig = BaseMasterConfig & {
-    oraclesInfo: ClassicOracleInfo;
-};
-export type ClassicMasterData = BaseMasterData & {
-    masterConfig: ClassicMasterConfig;
-};
+export interface ClassicMasterConfig extends BaseMasterConfig {
+    readonly oraclesInfo: ClassicOracleInfo;
+}
+export interface ClassicMasterData extends BaseMasterData {
+    readonly masterConfig: ClassicMasterConfig;
+}
 export declare class EvaaMasterClassic extends AbstractEvaaMaster<ClassicMasterData> {
     constructor(parameters: EvaaParameters);
     buildGeneralDataPayload(parameters: ClassicSupplyWithdrawParameters): Cell;

package/dist/contracts/PythMaster.d.ts

@@ -3,26 +3,29 @@
 import { HexString } from '@pythnetwork/hermes-client';
 import { Address, Cell, ContractProvider, Dictionary, Sender } from '@ton/core';
 import { PythOracleInfo } from '../api/parsers/PythOracleParser';
+import { PoolAssetConfig } from '../types/Master';
 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 interface PythBaseData {
+    readonly priceData: Buffer | Cell;
+    readonly targetFeeds: HexString[];
+    readonly refAssets: PoolAssetConfig[];
+}
+export interface ProxySpecificPythParams {
+    readonly pythAddress: Address;
+    readonly minPublishTime: number | bigint;
+    readonly maxPublishTime: number | bigint;
+}
+export interface OnchainSpecificPythParams {
+    readonly publishGap: number | bigint;
+    readonly maxStaleness: number | bigint;
+}
+export interface JettonPythParams extends PythBaseData, OnchainSpecificPythParams {
+}
+export interface TonPythParams extends PythBaseData, ProxySpecificPythParams {
+}
 export type PythProxyParams = {
     pyth: PythBaseData & (ProxySpecificPythParams | OnchainSpecificPythParams) & {
         pythAddress: Address;
@@ -30,16 +33,16 @@ export type PythProxyParams = {
 };
 export type PythSupplyWithdrawParameters = SupplyWithdrawParameters & Partial<PythProxyParams>;
 export type PythWithdrawParameters = WithdrawParameters & {
-    pyth: TonPythParams;
+    pyth?: TonPythParams;
 };
 export type PythLiquidationOperationParameters = LiquidationOperationBuilderParameters & LiquidationInnerParameters & PythProxyParams;
 export type PythLiquidationParameters = LiquidationParameters & PythLiquidationOperationParameters;
-export type PythMasterConfig = BaseMasterConfig & {
-    oraclesInfo: PythOracleInfo;
-};
-export type PythMasterData = BaseMasterData & {
-    masterConfig: PythMasterConfig;
-};
+export interface PythMasterConfig extends BaseMasterConfig {
+    readonly oraclesInfo: PythOracleInfo;
+}
+export interface PythMasterData extends BaseMasterData {
+    readonly masterConfig: PythMasterConfig;
+}
 export declare class EvaaMasterPyth extends AbstractEvaaMaster<PythMasterData> {
     constructor(parameters: EvaaParameters);
     protected buildPythMasterMessage(args: {
@@ -51,8 +54,21 @@ export declare class EvaaMasterPyth extends AbstractEvaaMaster<PythMasterData> {
         maxStaleness: number | bigint;
     }, operationPayload: Cell): Cell;
     protected buildPythProxyMessage(targetAddress: Address, priceUpdateData: Cell, targetPythFeeds: Cell, minPublishTime: number | bigint, maxPublishTime: number | bigint, operationPayload: Cell): Cell;
+    /**
+     * Creates a wrapped operation payload for TON assets
+     */
+    private createWrappedOperationPayload;
+    /**
+     * Creates a jetton transfer message with pyth data
+     */
+    private createJettonPythMessage;
+    /**
+     * Creates a TON pyth proxy message
+     */
+    private createTonPythMessage;
+    protected createSupplyWithdrawMessageNoPrices(parameters: SupplyWithdrawParameters, operationPayload: Cell): Cell;
     createSupplyWithdrawMessage(parameters: PythSupplyWithdrawParameters): Cell;
-    buildRefTokensDict(requestedRefTokens: bigint[]): Dictionary<bigint, Buffer>;
+    buildRefTokensDict(refAssets: PoolAssetConfig[]): Dictionary<bigint, Buffer>;
     buildGeneralDataPayload(parameters: PythSupplyWithdrawParameters): Cell;
     sendWithdraw(provider: ContractProvider, via: Sender, value: bigint, parameters: PythWithdrawParameters): Promise<void>;
     protected buildLiquidationOperationPayload(parameters: PythLiquidationOperationParameters): Cell;

package/dist/contracts/PythMaster.js

@@ -36,73 +36,74 @@ class EvaaMasterPyth extends AbstractMaster_1.AbstractEvaaMaster {
             .storeRef(operationPayload)
             .endCell();
     }
-    // TODO: support without OPCODES.SUPPLY_WITHDRAW_MASTER_WITHOUT_PRICES
-    createSupplyWithdrawMessage(parameters) {
-        const operationPayload = this.buildSupplyWithdrawOperationPayload(parameters);
+    /**
+     * Creates a wrapped operation payload for TON assets
+     */
+    createWrappedOperationPayload(opCode, queryID, operationPayload) {
+        return (0, core_1.beginCell)().storeUint(opCode, 32).storeUint(queryID, 64).storeRef(operationPayload).endCell();
+    }
+    /**
+     * Creates a jetton transfer message with pyth data
+     */
+    createJettonPythMessage(parameters, operationPayload, pythParams, opCode) {
+        const { priceData, targetFeeds, publishGap, maxStaleness } = pythParams;
+        const masterMessage = this.buildPythMasterMessage({
+            queryId: parameters.queryID,
+            opCode,
+            updateDataCell: (0, prices_1.packPythUpdatesData)(priceData),
+            targetFeedsCell: (0, prices_1.composeFeedsCell)(targetFeeds),
+            publishGap,
+            maxStaleness,
+        }, operationPayload);
+        return this.createJettonTransferMessage(parameters, general_1.FEES.SUPPLY_WITHDRAW, masterMessage);
+    }
+    /**
+     * Creates a TON pyth proxy message
+     */
+    createTonPythMessage(parameters, operationPayload, pythParams, opCode) {
+        const { priceData, targetFeeds, minPublishTime, maxPublishTime } = pythParams;
+        const wrappedOperationPayload = this.createWrappedOperationPayload(opCode, parameters.queryID, operationPayload);
+        return this.buildPythProxyMessage(this.address, (0, prices_1.packPythUpdatesData)(priceData), (0, prices_1.composeFeedsCell)(targetFeeds), minPublishTime, maxPublishTime, wrappedOperationPayload);
+    }
+    createSupplyWithdrawMessageNoPrices(parameters, operationPayload) {
+        const messageBody = (0, core_1.beginCell)()
+            .storeUint(general_1.OPCODES.SUPPLY_WITHDRAW_MASTER_WITHOUT_PRICES, 32)
+            .storeSlice(operationPayload.beginParse())
+            .endCell();
         if (!(0, utils_1.isTonAsset)(parameters.supplyAsset)) {
-            const { priceData, targetFeeds, publishGap, maxStaleness } = parameters.pyth;
-            const masterMessage = this.buildPythMasterMessage({
-                queryId: parameters.queryID,
-                opCode: general_1.OPCODES.SUPPLY_WITHDRAW_MASTER_JETTON,
-                updateDataCell: (0, prices_1.packPythUpdatesData)(priceData),
-                targetFeedsCell: (0, prices_1.composeFeedsCell)(targetFeeds),
-                publishGap,
-                maxStaleness,
-            }, operationPayload);
-            return this.createJettonTransferMessage(parameters, general_1.FEES.SUPPLY_WITHDRAW, masterMessage);
+            return this.createJettonTransferMessage(parameters, general_1.FEES.SUPPLY_WITHDRAW + general_1.FEES.JETTON_FWD, messageBody);
         }
         else {
-            const { priceData, targetFeeds, minPublishTime, maxPublishTime } = parameters.pyth;
-            const wrappedOperationPayload = (0, core_1.beginCell)()
-                .storeUint(general_1.OPCODES.SUPPLY_WITHDRAW_MASTER, 32)
+            return (0, core_1.beginCell)()
+                .storeUint(general_1.OPCODES.SUPPLY_WITHDRAW_MASTER_WITHOUT_PRICES, 32)
                 .storeUint(parameters.queryID, 64)
-                .storeRef(operationPayload)
+                .storeSlice(operationPayload.beginParse())
                 .endCell();
-            return this.buildPythProxyMessage(this.address, (0, prices_1.packPythUpdatesData)(priceData), (0, prices_1.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) {
+    createSupplyWithdrawMessage(parameters) {
+        const operationPayload = this.buildSupplyWithdrawOperationPayload(parameters);
+        // Handle case without pyth data
+        if (!parameters.pyth) {
+            return this.createSupplyWithdrawMessageNoPrices(parameters, operationPayload);
+        }
+        if (!(0, utils_1.isTonAsset)(parameters.supplyAsset)) {
+            return this.createJettonPythMessage(parameters, // as JettonParams & { queryID: number | bigint },
+            operationPayload, parameters.pyth, general_1.OPCODES.SUPPLY_WITHDRAW_MASTER_JETTON);
+        }
+        else {
+            return this.createTonPythMessage(parameters, operationPayload, parameters.pyth, general_1.OPCODES.SUPPLY_WITHDRAW_MASTER);
+        }
+    }
+    buildRefTokensDict(refAssets) {
         const refsDict = core_1.Dictionary.empty(core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.Buffer(0));
-        for (const refToken of requestedRefTokens) {
-            refsDict.set(refToken, Buffer.alloc(0));
+        for (const refAsset of refAssets) {
+            refsDict.set(refAsset.assetId, Buffer.alloc(0));
         }
         return refsDict;
     }
     buildGeneralDataPayload(parameters) {
-        const refTokensDict = this.buildRefTokensDict(parameters.pyth?.requestedRefTokens ?? []);
+        const refTokensDict = this.buildRefTokensDict(parameters.pyth?.refAssets ?? []);
         return (0, core_1.beginCell)()
             .storeInt(parameters.includeUserCode ? -1 : 0, 2)
             .storeDict(refTokensDict, core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.Buffer(0))
@@ -132,7 +133,7 @@ class EvaaMasterPyth extends AbstractMaster_1.AbstractEvaaMaster {
         });
         await via.send({
             value,
-            to: parameters.pyth.pythAddress,
+            to: parameters.pyth?.pythAddress ?? this.address,
             sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
             body: message,
         });
@@ -140,32 +141,16 @@ class EvaaMasterPyth extends AbstractMaster_1.AbstractEvaaMaster {
     buildLiquidationOperationPayload(parameters) {
         const operationPayloadBuilder = this.buildLiquidationOperationPayloadBuilder(parameters);
         const innerBuilder = this.buildLiquidationInnerBuilder(parameters);
-        const refTokensDict = this.buildRefTokensDict(parameters.pyth.requestedRefTokens);
+        const refTokensDict = this.buildRefTokensDict(parameters.pyth.refAssets);
         return operationPayloadBuilder.storeDict(refTokensDict).storeRef(innerBuilder).endCell();
     }
     createLiquidationMessage(parameters) {
-        const isTon = (0, utils_1.isTonAsset)(parameters.asset);
         const operationPayload = this.buildLiquidationOperationPayload(parameters);
-        if (!isTon) {
-            const { priceData, targetFeeds, publishGap, maxStaleness } = parameters.pyth;
-            const masterMessage = this.buildPythMasterMessage({
-                queryId: parameters.queryID,
-                opCode: general_1.OPCODES.LIQUIDATE_MASTER,
-                updateDataCell: (0, prices_1.packPythUpdatesData)(priceData),
-                targetFeedsCell: (0, prices_1.composeFeedsCell)(targetFeeds),
-                publishGap,
-                maxStaleness,
-            }, operationPayload);
-            return this.createJettonTransferMessage(parameters, general_1.FEES.LIQUIDATION_JETTON_FWD, masterMessage);
+        if (!(0, utils_1.isTonAsset)(parameters.asset)) {
+            return this.createJettonPythMessage(parameters, operationPayload, parameters.pyth, general_1.OPCODES.LIQUIDATE_MASTER);
         }
         else {
-            const { priceData, targetFeeds, minPublishTime, maxPublishTime } = parameters.pyth;
-            const wrappedOperationPayload = (0, core_1.beginCell)()
-                .storeUint(general_1.OPCODES.LIQUIDATE_MASTER, 32)
-                .storeUint(parameters.queryID, 64)
-                .storeRef(operationPayload)
-                .endCell();
-            return this.buildPythProxyMessage(this.address, (0, prices_1.packPythUpdatesData)(priceData), (0, prices_1.composeFeedsCell)(targetFeeds), minPublishTime, maxPublishTime, wrappedOperationPayload);
+            return this.createTonPythMessage(parameters, operationPayload, parameters.pyth, general_1.OPCODES.LIQUIDATE_MASTER);
         }
     }
     async sendLiquidation(provider, via, value, parameters) {

package/dist/contracts/PythOracle.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Address, Cell, Contract, ContractProvider } from '@ton/core';
+export declare class PythOracle implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): PythOracle;
+    getUpdateFee(provider: ContractProvider, vm: Buffer): Promise<bigint>;
+}

package/dist/contracts/PythOracle.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythOracle = void 0;
+const pyth_ton_js_1 = require("@pythnetwork/pyth-ton-js");
+class PythOracle {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new this(address);
+    }
+    async getUpdateFee(provider, vm) {
+        const result = await provider.get('get_update_fee', [{ type: 'slice', cell: (0, pyth_ton_js_1.createCellChain)(vm) }]);
+        const numUpdates = result.stack.readNumber();
+        return (0, pyth_ton_js_1.calculateUpdatePriceFeedsFee)(BigInt(numUpdates)) + BigInt(numUpdates);
+    }
+}
+exports.PythOracle = PythOracle;

package/dist/contracts/index.d.ts

@@ -3,3 +3,4 @@ export * from './ClassicMaster';
 export * from './PythMaster';
 export * from './UserContract';
 export * from './JettonWallet';
+export * from './PythOracle';

package/dist/contracts/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./ClassicMaster"), exports);
 __exportStar(require("./PythMaster"), exports);
 __exportStar(require("./UserContract"), exports);
 __exportStar(require("./JettonWallet"), exports);
+__exportStar(require("./PythOracle"), exports);

package/dist/index.d.ts

@@ -17,7 +17,7 @@ export * from './types/User';
 export * from './constants/general';
 export * from './constants/pools';
 export * from './constants/assets';
-export * from './prices';
+export * from './oracles';
 export * from './utils/utils';
 export { getLastSentBoc, getTonConnectSender } from './utils/tonConnectSender';
 export { getUserJettonWallet } from './utils/userJettonWallet';

package/dist/index.js

@@ -46,7 +46,7 @@ __exportStar(require("./types/User"), exports);
 __exportStar(require("./constants/general"), exports);
 __exportStar(require("./constants/pools"), exports);
 __exportStar(require("./constants/assets"), exports);
-__exportStar(require("./prices"), exports);
+__exportStar(require("./oracles"), exports);
 __exportStar(require("./utils/utils"), exports);
 // Utils
 var tonConnectSender_1 = require("./utils/tonConnectSender");

package/dist/{prices → oracles}/Types.d.ts

@@ -38,10 +38,6 @@ export type PythFeedUpdateType = {
     parsed: PriceUpdate['parsed'];
     binary: Buffer;
 };
-export type PriceData = {
-    dict: Dictionary<bigint, bigint>;
-    dataCell: Cell;
-};
 export type OraclePricesData = {
     timestamp: number;
     prices: Dictionary<bigint, bigint>;

package/dist/oracles/collectors/AbstractCollector.d.ts

@@ -0,0 +1,10 @@
+import { Dictionary } from '@ton/core';
+import { PoolAssetConfig } from '../../types/Master';
+import { FetchConfig } from '../../utils/utils';
+import { ClassicPrices } from '../prices/ClassicPrices';
+import { PythPrices } from '../prices/PythPrices';
+export declare abstract class AbstractCollector {
+    abstract getPricesForLiquidate(realPrincipals: Dictionary<bigint, bigint>, fetchConfig?: FetchConfig): Promise<ClassicPrices | PythPrices>;
+    abstract getPricesForSupplyWithdraw(realPrincipals: Dictionary<bigint, bigint>, supplyAsset: PoolAssetConfig | undefined, withdrawAsset: PoolAssetConfig | undefined, collateralToDebt: boolean, fetchConfig?: FetchConfig): Promise<ClassicPrices | PythPrices>;
+    abstract getPrices(assets: PoolAssetConfig[], fetchConfig?: FetchConfig): Promise<ClassicPrices | PythPrices>;
+}

package/dist/oracles/collectors/AbstractCollector.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractCollector = void 0;
+class AbstractCollector {
+}
+exports.AbstractCollector = AbstractCollector;

package/dist/oracles/collectors/ClassicCollector.d.ts

@@ -0,0 +1,22 @@
+import { Dictionary } from '@ton/core';
+import { ExtendedEvaaOracle, PoolAssetConfig } from '../../types/Master';
+import { FetchConfig } from '../../utils/utils';
+import { ClassicPrices } from '../prices/ClassicPrices';
+import { PriceSource } from '../sources';
+import { PriceSourcesConfig } from '../Types';
+import { AbstractCollector } from './AbstractCollector';
+export type ClassicCollectorConfig = {
+    poolAssetsConfig: PoolAssetConfig[];
+    minimalOracles: number;
+    evaaOracles: ExtendedEvaaOracle[];
+    sourcesConfig?: PriceSourcesConfig;
+    additionalPriceSources?: PriceSource[];
+};
+export declare class ClassicCollector extends AbstractCollector {
+    #private;
+    constructor(config: ClassicCollectorConfig);
+    getPricesForLiquidate(realPrincipals: Dictionary<bigint, bigint>, fetchConfig?: FetchConfig): Promise<ClassicPrices>;
+    getPricesForWithdraw(realPrincipals: Dictionary<bigint, bigint>, withdrawAsset: PoolAssetConfig, collateralToDebt?: boolean, fetchConfig?: FetchConfig): Promise<ClassicPrices>;
+    getPricesForSupplyWithdraw(realPrincipals: Dictionary<bigint, bigint>, supplyAsset: PoolAssetConfig | undefined, withdrawAsset: PoolAssetConfig | undefined, collateralToDebt: boolean, fetchConfig?: FetchConfig): Promise<ClassicPrices>;
+    getPrices(assets?: PoolAssetConfig[], fetchConfig?: FetchConfig): Promise<ClassicPrices>;
+}